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/debug/trace_event.h" 11 #include "base/logging.h" 12 #include "base/mac/mac_util.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "ui/gl/gl_bindings.h" 15 #include "ui/gl/gl_context.h" 16 #include "ui/gl/gl_implementation.h" 17 #include "ui/gl/gl_surface_osmesa.h" 18 #include "ui/gl/gl_surface_stub.h" 19 #include "ui/gl/gpu_switching_manager.h" 20 21 namespace gfx { 22 namespace { 23 24 // A "no-op" surface. It is not required that a CGLContextObj have an 25 // associated drawable (pbuffer or fullscreen context) in order to be 26 // made current. Everywhere this surface type is used, we allocate an 27 // FBO at the user level as the drawable of the associated context. 28 class GL_EXPORT NoOpGLSurface : public GLSurface { 29 public: NoOpGLSurface(const gfx::Size & size)30 explicit NoOpGLSurface(const gfx::Size& size) : size_(size) {} 31 32 // Implement GLSurface. Initialize()33 virtual bool Initialize() OVERRIDE { return true; } Destroy()34 virtual void Destroy() OVERRIDE {} IsOffscreen()35 virtual bool IsOffscreen() OVERRIDE { return true; } SwapBuffers()36 virtual bool SwapBuffers() OVERRIDE { 37 NOTREACHED() << "Cannot call SwapBuffers on a NoOpGLSurface."; 38 return false; 39 } GetSize()40 virtual gfx::Size GetSize() OVERRIDE { return size_; } GetHandle()41 virtual void* GetHandle() OVERRIDE { return NULL; } GetDisplay()42 virtual void* GetDisplay() OVERRIDE { return NULL; } 43 44 protected: ~NoOpGLSurface()45 virtual ~NoOpGLSurface() {} 46 47 private: 48 gfx::Size size_; 49 50 DISALLOW_COPY_AND_ASSIGN(NoOpGLSurface); 51 }; 52 53 // static InitializeOneOffForSandbox()54bool 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 InitializeOneOffInternal()95bool 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 CreateViewGLSurface(gfx::AcceleratedWidget window)110scoped_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 CreateOffscreenGLSurface(const gfx::Size & size)133scoped_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 162