Support dynamic switching between integrated and discrete GPUs on Mac OS X.

ui/gfx/gl/gl_surface_cgl.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/gl/gl_surface_cgl.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/mac/mac_util.h"
 #include "ui/gfx/gl/gl_bindings.h"
+#include "ui/gfx/gl/gl_context.h"
 
 namespace gfx {
 
 namespace {
 CGLPixelFormatObj g_pixel_format;
 }
 
 GLSurfaceCGL::GLSurfaceCGL() {
 }
 
 GLSurfaceCGL::~GLSurfaceCGL() {
 }
 
 bool GLSurfaceCGL::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
-  static const CGLPixelFormatAttribute attribs[] = {
-    (CGLPixelFormatAttribute) kCGLPFAPBuffer,
-    (CGLPixelFormatAttribute) 0
-  };
+  // This is called from the sandbox warmup code on Mac OS X.
+  // GPU-related stuff is very slow without this, probably because
+  // the sandbox prevents loading graphics drivers or some such.
+  std::vector<CGLPixelFormatAttribute> attribs;
+  if (GLContext::SupportsDualGpus()) {
+      // Avoid switching to the discrete GPU just for this pixel

[Mark Mentovai, 2011/10/12 00:48:18]

Fix indentation.

[Ken Russell (switch to Gerrit), 2011/10/12 01:16:36]

Done.

+      // format selection.
+    attribs.push_back(kCGLPFAAllowOfflineRenderers);
+  }
+  attribs.push_back((CGLPixelFormatAttribute) 0);

[Mark Mentovai, 2011/10/12 00:48:18]

Use a proper C++<style>(cast).

[Ken Russell (switch to Gerrit), 2011/10/12 01:16:36]

Done.

+
+  CGLPixelFormatObj format;
   GLint num_pixel_formats;
-  if (CGLChoosePixelFormat(attribs,
-                           &g_pixel_format,
+  if (CGLChoosePixelFormat(&attribs.front(),
+                           &format,
                            &num_pixel_formats) != kCGLNoError) {
     LOG(ERROR) << "Error choosing pixel format.";
     return false;
   }
   if (num_pixel_formats == 0) {
     LOG(ERROR) << "num_pixel_formats == 0.";
     return false;
   }
-  if (!g_pixel_format) {
+  if (!format) {
     LOG(ERROR) << "pixel_format == 0.";

[Mark Mentovai, 2011/10/12 00:48:18]

This isn’t called pixel_format now (and actually wasn’t called pixel_format
before, either.)

[Ken Russell (switch to Gerrit), 2011/10/12 01:16:36]

Fixed.

     return false;
   }
-
+  CGLReleasePixelFormat(format);

[Mark Mentovai, 2011/10/12 00:48:18]

Is there any way for format to be nonzero but num_pixel_formats to be zero? If
so, this gets leaked when you do the num_pixel_formats == 0 early return.

Even if there’s no possibility for a leak, it’s possible that someone will
insert additional logic that contains an early return and does leak format.

You can mitigate this with a scoper, but if you don’t want to do a whole scoper,
could you do something like this?

if (CGLChoosePixelFormat() != kCGLNoError) {
  return false;
}
if (format) {
  CGLReleasePixelFormat();
} else {
  return false;
}
if (num_pixel_formats == 0) {
  return false;
}

[Ken Russell (switch to Gerrit), 2011/10/12 01:16:36]

Thanks for the suggestion. Implemented.

   initialized = true;
   return true;
 }
 
 void* GLSurfaceCGL::GetPixelFormat() {
   return g_pixel_format;
 }
 
 PbufferGLSurfaceCGL::PbufferGLSurfaceCGL(const gfx::Size& size)
   : size_(size),
@@ skipping 38 matching lines @@
 
 gfx::Size PbufferGLSurfaceCGL::GetSize() {
   return size_;
 }
 
 void* PbufferGLSurfaceCGL::GetHandle() {
   return pbuffer_;
 }
 
 }  // namespace gfx