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

ui/gfx/gl/gl_context_mac.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 "base/basictypes.h"
 #include "base/logging.h"
+#include "base/mac/mac_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/mesa/MesaLib/include/GL/osmesa.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_context_cgl.h"
 #include "ui/gfx/gl/gl_context_osmesa.h"
 #include "ui/gfx/gl/gl_context_stub.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_cgl.h"
 #include "ui/gfx/gl/gl_surface_osmesa.h"
 
 namespace gfx {
 
 class GLShareGroup;
 
 scoped_refptr<GLContext> GLContext::CreateGLContext(
     GLShareGroup* share_group,
-    GLSurface* compatible_surface) {
+    GLSurface* compatible_surface,
+    GpuPreference gpu_preference) {
   switch (GetGLImplementation()) {
     case kGLImplementationDesktopGL: {
       scoped_refptr<GLContext> context(new GLContextCGL(share_group));
-      if (!context->Initialize(compatible_surface))
+      if (!context->Initialize(compatible_surface, gpu_preference))
         return NULL;
 
       return context;
     }
     case kGLImplementationOSMesaGL: {
       scoped_refptr<GLContext> context(new GLContextOSMesa(share_group));
-      if (!context->Initialize(compatible_surface))
+      if (!context->Initialize(compatible_surface, gpu_preference))
         return NULL;
 
       return context;
     }
     case kGLImplementationMockGL:
       return new GLContextStub;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
+
+bool GLContext::SupportsDualGpus() {

[Mark Mentovai, 2011/10/13 03:50:33]

Found it!

[Ken Russell (switch to Gerrit), 2011/10/13 20:09:32]

Whoops, sorry. I meant gl_context_mac.cc.

+  // We need to know the GL implementation in order to correctly
+  // answer whether dual GPUs are supported. This introduces an
+  // initialization cycle with GLSurface::InitializeOneOff() which we
+  // need to break.
+  static bool initializing = false;

[Mark Mentovai, 2011/10/13 03:50:33]

You only care about one thread, right?

[Ken Russell (switch to Gerrit), 2011/10/13 20:09:32]

Yes, for the time being. gl_surface_mac.cc already doesn't have locking around
InitializeOneOff().

+  static bool initialized = false;
+  static bool supports_dual_gpus = false;
+
+  if (initialized) {
+    return supports_dual_gpus;
+  }
+
+  if (!initializing) {
+    initializing = true;
+    if (!GLSurface::InitializeOneOff()) {
+      return false;

[Mark Mentovai, 2011/10/13 03:50:33]

At this early-return point, do you want to set initializing = false and
initialized = true to avoid trying to do the one-off failure busywork on
subsequent reentry?

It seems like you might be able to get away with a single static guarding this:

  static bool initialized = false;
  if (initialized) {
    return supports_dual_gpus;
  } else {
    initialized = true;
    if (!GLSurface::InitializeOneOff()) {
      return false;
    }
  }

I can’t convince myself that having the two statics actually helps.

[Ken Russell (switch to Gerrit), 2011/10/13 20:09:32]

Sorry, this doesn't work. I need to handle the case where
GLContext::SupportsDualGpus calls GLSurface::InitializeOneOff which calls back
to GLContext::SupportsDualGpus, and I need to complete the rest of the logic in
SupportsDualGpus the second time without calling InitializeOneOff again or an
infinite loop will occur. I reorganized the logic slightly based on your
suggestion but the two booleans are needed.

+    }
+  }
+
+  initialized = true;
+
+  if (!base::mac::IsOSLionOrLater()) {
+    return false;
+  }
+
+  if (GetGLImplementation() != kGLImplementationDesktopGL) {
+    return false;
+  }
+
+  // Enumerate all hardware-accelerated renderers. If we find one
+  // online and one offline, assume we're on a dual-GPU system.
+  GLuint display_mask = static_cast<GLuint>(-1);
+  CGLRendererInfoObj renderer_info = NULL;
+  GLint num_renderers = 0;
+
+  bool found_online = false;
+  bool found_offline = false;
+
+  if (CGLQueryRendererInfo(display_mask,
+                           &renderer_info,
+                           &num_renderers) != kCGLNoError) {
+    return false;
+  }
+
+  for (GLint i = 0; i < num_renderers; ++i) {
+    GLint accelerated = 0;
+    if (CGLDescribeRenderer(renderer_info,
+                            i,
+                            kCGLRPAccelerated,
+                            &accelerated) != kCGLNoError) {
+      CGLDestroyRendererInfo(renderer_info);

[Mark Mentovai, 2011/10/13 03:50:33]

You’ve been good about not leaking this, but with a couple early-return points
scattered about, a scoper might be better.

[Ken Russell (switch to Gerrit), 2011/10/13 20:09:32]

OK. I generalized ScopedCFTypeRef to take a freeing functor because
scoped_ptr_malloc doesn't work for types like CGLRendererInfoObj where the
pointer-ness is embedded in the typedef.

+      return false;
+    }
+
+    if (!accelerated)
+      continue;
+
+    GLint online = 0;
+    if (CGLDescribeRenderer(renderer_info,
+                            i,
+                            kCGLRPOnline,
+                            &online) != kCGLNoError) {
+      CGLDestroyRendererInfo(renderer_info);
+      return false;
+    }
+
+    if (online) {
+      found_online = true;
+    } else {
+      found_offline = true;

[Mark Mentovai, 2011/10/13 03:50:33]

Will a graphics card without a display attached in a more traditional
multiple-card situation (expecting multiple displays, as opposed to the modern
single-display card-switches-on-the-fly situation) also show up as “offline?” If
so, does that present a problem for the logic?

[Ken Russell (switch to Gerrit), 2011/10/13 20:09:32]

I'm not sure, but I suspect that the card in that case will show up as online
and not offline. Apple's documentation on supporting multiple GPUs indicates
that the kCGLPFAAllowOfflineRenderers flag only affects the behavior of mixed
integrated and discrete GPUs. Anyway, I am 99% sure that all of our logic will
work fine in this rare case.

+    }
+  }
+
+  CGLDestroyRendererInfo(renderer_info);
+
+  if (found_online && found_offline) {
+    supports_dual_gpus = true;
+  }
+
+  return supports_dual_gpus;
+}
+
 }  // namespace gfx