ui/gl/gl_implementation.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 "ui/gl/gl_implementation.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "base/at_exit.h"
  11 #include "base/command_line.h"
  12 #include "base/logging.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/string_util.h"
  15 #include "ui/gl/gl_bindings.h"
  16 #include "ui/gl/gl_gl_api_implementation.h"
  17 #include "ui/gl/gl_version_info.h"
  18
  19 namespace gfx {
  20
  21 namespace {
  22
  23 const struct {
  24   const char* name;
  25   GLImplementation implementation;
  26 } kGLImplementationNamePairs[] = {
  27   { kGLImplementationDesktopName, kGLImplementationDesktopGL },
  28   { kGLImplementationOSMesaName, kGLImplementationOSMesaGL },
  29 #if defined(OS_MACOSX)
  30   { kGLImplementationAppleName, kGLImplementationAppleGL },
  31 #endif
  32   { kGLImplementationEGLName, kGLImplementationEGLGLES2 },
  33   { kGLImplementationMockName, kGLImplementationMockGL }
  34 };
  35
  36 typedef std::vector<base::NativeLibrary> LibraryArray;
  37
  38 GLImplementation g_gl_implementation = kGLImplementationNone;
  39 LibraryArray* g_libraries;
  40 GLGetProcAddressProc g_get_proc_address;
  41
  42 void CleanupNativeLibraries(void* unused) {
  43   if (g_libraries) {
  44     // We do not call base::UnloadNativeLibrary() for these libraries as
  45     // unloading libGL without closing X display is not allowed. See
  46     // crbug.com/250813 for details.
  47     delete g_libraries;
  48     g_libraries = NULL;
  49   }
  50 }
  51
  52 }
  53
  54 base::ThreadLocalPointer<GLApi>* g_current_gl_context_tls = NULL;
  55 OSMESAApi* g_current_osmesa_context;
  56
  57 #if defined(OS_WIN)
  58
  59 EGLApi* g_current_egl_context;
  60 WGLApi* g_current_wgl_context;
  61
  62 #elif defined(USE_X11)
  63
  64 EGLApi* g_current_egl_context;
  65 GLXApi* g_current_glx_context;
  66
  67 #elif defined(USE_OZONE)
  68
  69 EGLApi* g_current_egl_context;
  70
  71 #elif defined(OS_ANDROID)
  72
  73 EGLApi* g_current_egl_context;
  74
  75 #endif
  76
  77 GLImplementation GetNamedGLImplementation(const std::string& name) {
  78   for (size_t i = 0; i < arraysize(kGLImplementationNamePairs); ++i) {
  79     if (name == kGLImplementationNamePairs[i].name)
  80       return kGLImplementationNamePairs[i].implementation;
  81   }
  82
  83   return kGLImplementationNone;
  84 }
  85
  86 const char* GetGLImplementationName(GLImplementation implementation) {
  87   for (size_t i = 0; i < arraysize(kGLImplementationNamePairs); ++i) {
  88     if (implementation == kGLImplementationNamePairs[i].implementation)
  89       return kGLImplementationNamePairs[i].name;
  90   }
  91
  92   return "unknown";
  93 }
  94
  95 void SetGLImplementation(GLImplementation implementation) {
  96   g_gl_implementation = implementation;
  97 }
  98
  99 GLImplementation GetGLImplementation() {
 100   return g_gl_implementation;
 101 }
 102
 103 bool HasDesktopGLFeatures() {
 104   return kGLImplementationDesktopGL == g_gl_implementation ||
 105          kGLImplementationDesktopGLCoreProfile == g_gl_implementation ||
 106          kGLImplementationOSMesaGL == g_gl_implementation ||
 107          kGLImplementationAppleGL == g_gl_implementation;
 108 }
 109
 110 void AddGLNativeLibrary(base::NativeLibrary library) {
 111   DCHECK(library);
 112
 113   if (!g_libraries) {
 114     g_libraries = new LibraryArray;
 115     base::AtExitManager::RegisterCallback(CleanupNativeLibraries, NULL);
 116   }
 117
 118   g_libraries->push_back(library);
 119 }
 120
 121 void UnloadGLNativeLibraries() {
 122   CleanupNativeLibraries(NULL);
 123 }
 124
 125 void SetGLGetProcAddressProc(GLGetProcAddressProc proc) {
 126   DCHECK(proc);
 127   g_get_proc_address = proc;
 128 }
 129
 130 void* GetGLProcAddress(const char* name) {
 131   DCHECK(g_gl_implementation != kGLImplementationNone);
 132
 133   if (g_libraries) {
 134     for (size_t i = 0; i < g_libraries->size(); ++i) {
 135       void* proc = base::GetFunctionPointerFromNativeLibrary((*g_libraries)[i],
 136                                                              name);
 137       if (proc)
 138         return proc;
 139     }
 140   }
 141   if (g_get_proc_address) {
 142     void* proc = g_get_proc_address(name);
 143     if (proc)
 144       return proc;
 145   }
 146
 147   return NULL;
 148 }
 149
 150 void InitializeNullDrawGLBindings() {
 151   // This is platform independent, so it does not need to live in a platform
 152   // specific implementation file.
 153   InitializeNullDrawGLBindingsGL();
 154 }
 155
 156 bool HasInitializedNullDrawGLBindings() {
 157   return HasInitializedNullDrawGLBindingsGL();
 158 }
 159
 160 std::string FilterGLExtensionList(
 161     const char* extensions,
 162     const std::vector<std::string>& disabled_extensions) {
 163   if (extensions == NULL)
 164     return "";
 165
 166   std::vector<std::string> extension_vec = base::SplitString(
 167       extensions, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 168
 169   auto is_disabled = [&disabled_extensions](const std::string& ext) {
 170     return std::find(disabled_extensions.begin(), disabled_extensions.end(),
 171                      ext) != disabled_extensions.end();
 172   };
 173   extension_vec.erase(
 174       std::remove_if(extension_vec.begin(), extension_vec.end(), is_disabled),
 175       extension_vec.end());
 176
 177   return base::JoinString(extension_vec, " ");
 178 }
 179
 180 DisableNullDrawGLBindings::DisableNullDrawGLBindings() {
 181   initial_enabled_ = SetNullDrawGLBindingsEnabledGL(false);
 182 }
 183
 184 DisableNullDrawGLBindings::~DisableNullDrawGLBindings() {
 185   SetNullDrawGLBindingsEnabledGL(initial_enabled_);
 186 }
 187
 188 GLWindowSystemBindingInfo::GLWindowSystemBindingInfo()
 189     : direct_rendering(true) {}
 190
 191 std::string GetGLExtensionsFromCurrentContext() {
 192   if (WillUseGLGetStringForExtensions()) {
 193     return reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
 194   }
 195
 196   std::vector<std::string> exts;
 197   GLint num_extensions = 0;
 198   glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
 199   for (GLint i = 0; i < num_extensions; ++i) {
 200     const char* extension = reinterpret_cast<const char*>(
 201         glGetStringi(GL_EXTENSIONS, i));
 202     DCHECK(extension != NULL);
 203     exts.push_back(extension);
 204   }
 205   return base::JoinString(exts, " ");
 206 }
 207
 208 bool WillUseGLGetStringForExtensions() {
 209   const char* version_str =
 210       reinterpret_cast<const char*>(glGetString(GL_VERSION));
 211   unsigned major_version, minor_version;
 212   bool is_es, is_es3;
 213   gfx::GLVersionInfo::ParseVersionString(
 214       version_str, &major_version, &minor_version, &is_es, &is_es3);
 215   return is_es || major_version < 3;
 216 }
 217
 218 }  // namespace gfx