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_context_stub_with_extensions.h"
  14 #include "ui/gl/gl_gl_api_implementation.h"
  15 #include "ui/gl/gl_implementation.h"
  16 #include "ui/gl/gl_osmesa_api_implementation.h"
  17
  18 namespace gfx {
  19 namespace {
  20 const char kOpenGLFrameworkPath[] =
  21     "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL";
  22 }  // namespace
  23
  24 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) {
  25   impls->push_back(kGLImplementationDesktopGL);
  26   impls->push_back(kGLImplementationAppleGL);
  27   impls->push_back(kGLImplementationOSMesaGL);
  28 }
  29
  30 bool InitializeStaticGLBindings(GLImplementation implementation) {
  31   // Prevent reinitialization with a different implementation. Once the gpu
  32   // unit tests have initialized with kGLImplementationMock, we don't want to
  33   // later switch to another GL implementation.
  34   DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
  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       InitializeStaticGLBindingsGL();
  81       InitializeStaticGLBindingsOSMESA();
  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       InitializeStaticGLBindingsGL();
  97       break;
  98     }
  99     case kGLImplementationMockGL: {
 100       SetGLImplementation(kGLImplementationMockGL);
 101       InitializeStaticGLBindingsGL();
 102       break;
 103     }
 104     default:
 105       return false;
 106   }
 107
 108   return true;
 109 }
 110
 111 bool InitializeDynamicGLBindings(GLImplementation implementation,
 112     GLContext* context) {
 113   switch (implementation) {
 114     case kGLImplementationOSMesaGL:
 115       InitializeDynamicGLBindingsGL(context);
 116       InitializeDynamicGLBindingsOSMESA(context);
 117       break;
 118     case kGLImplementationDesktopGL:
 119     case kGLImplementationAppleGL:
 120       InitializeDynamicGLBindingsGL(context);
 121       break;
 122     case kGLImplementationMockGL:
 123       if (!context) {
 124         scoped_refptr<GLContextStubWithExtensions> mock_context(
 125             new GLContextStubWithExtensions());
 126         mock_context->SetGLVersionString("3.0");
 127         InitializeDynamicGLBindingsGL(mock_context.get());
 128       } else
 129         InitializeDynamicGLBindingsGL(context);
 130       break;
 131     default:
 132       return false;
 133   }
 134
 135   return true;
 136 }
 137
 138 void InitializeDebugGLBindings() {
 139   InitializeDebugGLBindingsGL();
 140   InitializeDebugGLBindingsOSMESA();
 141 }
 142
 143 void ClearGLBindings() {
 144   ClearGLBindingsGL();
 145   ClearGLBindingsOSMESA();
 146   SetGLImplementation(kGLImplementationNone);
 147
 148   UnloadGLNativeLibraries();
 149 }
 150
 151 bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) {
 152   return false;
 153 }
 154
 155 }  // namespace gfx