src/ui/gl/gl_implementation_mac.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/base_paths.h"
   6 #include "base/files/file_path.h"
   7 #include "base/logging.h"
   8 #include "base/mac/foundation_util.h"
   9 #include "base/native_library.h"
  10 #include "base/path_service.h"
  11 #include "base/threading/thread_restrictions.h"
  12 #include "ui/gl/gl_bindings.h"
  13 #include "ui/gl/gl_gl_api_implementation.h"
  14 #include "ui/gl/gl_implementation.h"
  15 #include "ui/gl/gl_osmesa_api_implementation.h"
  16
  17 namespace gfx {
  18 namespace {
  19 const char kOpenGLFrameworkPath[] =
  20     "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL";
  21 }  // namespace
  22
  23 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) {
  24   impls->push_back(kGLImplementationDesktopGL);
  25   impls->push_back(kGLImplementationAppleGL);
  26   impls->push_back(kGLImplementationOSMesaGL);
  27 }
  28
  29 bool InitializeGLBindings(GLImplementation implementation) {
  30   // Prevent reinitialization with a different implementation. Once the gpu
  31   // unit tests have initialized with kGLImplementationMock, we don't want to
  32   // later switch to another GL implementation.
  33   if (GetGLImplementation() != kGLImplementationNone)
  34     return true;
  35
  36   // Allow the main thread or another to initialize these bindings
  37   // after instituting restrictions on I/O. Going forward they will
  38   // likely be used in the browser process on most platforms. The
  39   // one-time initialization cost is small, between 2 and 5 ms.
  40   base::ThreadRestrictions::ScopedAllowIO allow_io;
  41
  42   switch (implementation) {
  43     case kGLImplementationOSMesaGL: {
  44       // osmesa.so is located in the build directory. This code path is only
  45       // valid in a developer build environment.
  46       base::FilePath exe_path;
  47       if (!PathService::Get(base::FILE_EXE, &exe_path)) {
  48         LOG(ERROR) << "PathService::Get failed.";
  49         return false;
  50       }
  51       base::FilePath bundle_path = base::mac::GetAppBundlePath(exe_path);
  52       // Some unit test targets depend on osmesa but aren't built as app
  53       // bundles. In that case, the .so is next to the executable.
  54       if (bundle_path.empty())
  55         bundle_path = exe_path;
  56       base::FilePath build_dir_path = bundle_path.DirName();
  57       base::FilePath osmesa_path = build_dir_path.Append("osmesa.so");
  58
  59       // When using OSMesa, just use OSMesaGetProcAddress to find entry points.
  60       base::NativeLibrary library = base::LoadNativeLibrary(osmesa_path, NULL);
  61       if (!library) {
  62         LOG(ERROR) << "osmesa.so not found at " << osmesa_path.value();
  63         return false;
  64       }
  65
  66       GLGetProcAddressProc get_proc_address =
  67           reinterpret_cast<GLGetProcAddressProc>(
  68               base::GetFunctionPointerFromNativeLibrary(
  69                   library, "OSMesaGetProcAddress"));
  70       if (!get_proc_address) {
  71         LOG(ERROR) << "OSMesaGetProcAddress not found.";
  72         base::UnloadNativeLibrary(library);
  73         return false;
  74       }
  75
  76       SetGLGetProcAddressProc(get_proc_address);
  77       AddGLNativeLibrary(library);
  78       SetGLImplementation(kGLImplementationOSMesaGL);
  79
  80       InitializeGLBindingsGL();
  81       InitializeGLBindingsOSMESA();
  82       break;
  83     }
  84     case kGLImplementationDesktopGL:
  85     case kGLImplementationAppleGL: {
  86       base::NativeLibrary library = base::LoadNativeLibrary(
  87           base::FilePath(kOpenGLFrameworkPath), NULL);
  88       if (!library) {
  89         LOG(ERROR) << "OpenGL framework not found";
  90         return false;
  91       }
  92
  93       AddGLNativeLibrary(library);
  94       SetGLImplementation(implementation);
  95
  96       InitializeGLBindingsGL();
  97       break;
  98     }
  99     case kGLImplementationMockGL: {
 100       SetGLGetProcAddressProc(GetMockGLProcAddress);
 101       SetGLImplementation(kGLImplementationMockGL);
 102       InitializeGLBindingsGL();
 103       break;
 104     }
 105     default:
 106       return false;
 107   }
 108
 109   return true;
 110 }
 111
 112 bool InitializeGLExtensionBindings(GLImplementation implementation,
 113     GLContext* context) {
 114   switch (implementation) {
 115     case kGLImplementationOSMesaGL:
 116       InitializeGLExtensionBindingsGL(context);
 117       InitializeGLExtensionBindingsOSMESA(context);
 118       break;
 119     case kGLImplementationDesktopGL:
 120     case kGLImplementationAppleGL:
 121       InitializeGLExtensionBindingsGL(context);
 122       break;
 123     case kGLImplementationMockGL:
 124       InitializeGLExtensionBindingsGL(context);
 125       break;
 126     default:
 127       return false;
 128   }
 129
 130   return true;
 131 }
 132
 133 void InitializeDebugGLBindings() {
 134   InitializeDebugGLBindingsGL();
 135   InitializeDebugGLBindingsOSMESA();
 136 }
 137
 138 void ClearGLBindings() {
 139   ClearGLBindingsGL();
 140   ClearGLBindingsOSMESA();
 141   SetGLImplementation(kGLImplementationNone);
 142
 143   UnloadGLNativeLibraries();
 144 }
 145
 146 bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) {
 147   return false;
 148 }
 149
 150 }  // namespace gfx