ui/gl/gl_surface_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 "ui/gl/gl_surface.h"
   6
   7 #include <OpenGL/CGLRenderers.h>
   8
   9 #include "base/basictypes.h"
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/trace_event/trace_event.h"
  13 #include "ui/gl/gl_bindings.h"
  14 #include "ui/gl/gl_context.h"
  15 #include "ui/gl/gl_implementation.h"
  16 #include "ui/gl/gl_surface_osmesa.h"
  17 #include "ui/gl/gl_surface_stub.h"
  18 #include "ui/gl/gpu_switching_manager.h"
  19
  20 namespace gfx {
  21 namespace {
  22
  23 // A "no-op" surface. It is not required that a CGLContextObj have an
  24 // associated drawable (pbuffer or fullscreen context) in order to be
  25 // made current. Everywhere this surface type is used, we allocate an
  26 // FBO at the user level as the drawable of the associated context.
  27 class GL_EXPORT NoOpGLSurface : public GLSurface {
  28  public:
  29   explicit NoOpGLSurface(const gfx::Size& size) : size_(size) {}
  30
  31   // Implement GLSurface.
  32   bool Initialize() override { return true; }
  33   void Destroy() override {}
  34   bool IsOffscreen() override { return true; }
  35   bool SwapBuffers() override {
  36     NOTREACHED() << "Cannot call SwapBuffers on a NoOpGLSurface.";
  37     return false;
  38   }
  39   gfx::Size GetSize() override { return size_; }
  40   void* GetHandle() override { return NULL; }
  41   void* GetDisplay() override { return NULL; }
  42   bool IsSurfaceless() const override { return true; }
  43
  44  protected:
  45   ~NoOpGLSurface() override {}
  46
  47  private:
  48   gfx::Size size_;
  49
  50   DISALLOW_COPY_AND_ASSIGN(NoOpGLSurface);
  51 };
  52
  53 // static
  54 bool InitializeOneOffForSandbox() {
  55   static bool initialized = false;
  56   if (initialized)
  57     return true;
  58
  59   // This is called from the sandbox warmup code on Mac OS X.
  60   // GPU-related stuff is very slow without this, probably because
  61   // the sandbox prevents loading graphics drivers or some such.
  62   std::vector<CGLPixelFormatAttribute> attribs;
  63   if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
  64     // Avoid switching to the discrete GPU just for this pixel
  65     // format selection.
  66     attribs.push_back(kCGLPFAAllowOfflineRenderers);
  67   }
  68   if (GetGLImplementation() == kGLImplementationAppleGL) {
  69     attribs.push_back(kCGLPFARendererID);
  70     attribs.push_back(static_cast<CGLPixelFormatAttribute>(
  71       kCGLRendererGenericFloatID));
  72   }
  73   attribs.push_back(static_cast<CGLPixelFormatAttribute>(0));
  74
  75   CGLPixelFormatObj format;
  76   GLint num_pixel_formats;
  77   if (CGLChoosePixelFormat(&attribs.front(),
  78                            &format,
  79                            &num_pixel_formats) != kCGLNoError) {
  80     LOG(ERROR) << "Error choosing pixel format.";
  81     return false;
  82   }
  83   if (!format) {
  84     LOG(ERROR) << "format == 0.";
  85     return false;
  86   }
  87   CGLReleasePixelFormat(format);
  88   DCHECK_NE(num_pixel_formats, 0);
  89   initialized = true;
  90   return true;
  91 }
  92
  93 }  // namespace
  94
  95 bool GLSurface::InitializeOneOffInternal() {
  96   switch (GetGLImplementation()) {
  97     case kGLImplementationDesktopGL:
  98     case kGLImplementationAppleGL:
  99       if (!InitializeOneOffForSandbox()) {
 100         LOG(ERROR) << "GLSurfaceCGL::InitializeOneOff failed.";
 101         return false;
 102       }
 103       break;
 104     default:
 105       break;
 106   }
 107   return true;
 108 }
 109
 110 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
 111     gfx::AcceleratedWidget window) {
 112   TRACE_EVENT0("gpu", "GLSurface::CreateViewGLSurface");
 113   switch (GetGLImplementation()) {
 114     case kGLImplementationDesktopGL:
 115     case kGLImplementationAppleGL: {
 116       NOTIMPLEMENTED() << "No onscreen support on Mac.";
 117       return NULL;
 118     }
 119     case kGLImplementationOSMesaGL: {
 120       scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
 121       if (!surface->Initialize())
 122         return NULL;
 123       return surface;
 124     }
 125     case kGLImplementationMockGL:
 126       return new GLSurfaceStub;
 127     default:
 128       NOTREACHED();
 129       return NULL;
 130   }
 131 }
 132
 133 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
 134     const gfx::Size& size) {
 135   TRACE_EVENT0("gpu", "GLSurface::CreateOffscreenGLSurface");
 136   switch (GetGLImplementation()) {
 137     case kGLImplementationOSMesaGL: {
 138       scoped_refptr<GLSurface> surface(
 139           new GLSurfaceOSMesa(OSMesaSurfaceFormatRGBA, size));
 140       if (!surface->Initialize())
 141         return NULL;
 142
 143       return surface;
 144     }
 145     case kGLImplementationDesktopGL:
 146     case kGLImplementationAppleGL: {
 147       scoped_refptr<GLSurface> surface(new NoOpGLSurface(size));
 148       if (!surface->Initialize())
 149         return NULL;
 150
 151       return surface;
 152     }
 153     case kGLImplementationMockGL:
 154       return new GLSurfaceStub;
 155     default:
 156       NOTREACHED();
 157       return NULL;
 158   }
 159 }
 160
 161 }  // namespace gfx