Switch all contexts in a share group to be on the same screen as the window they present to.

ui/gl/gl_context_cgl.cc

 // Copyright (c) 2012 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/gl/gl_context_cgl.h"
 
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_cgl.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 namespace gfx {
 
+bool g_support_renderer_switching;
+
+static CGLPixelFormatObj GetPixelFormat() {
+  static CGLPixelFormatObj format;

[Ken Russell (switch to Gerrit), 2013/03/01 22:00:58]

Does this need to be initialized to NULL?

[jbauman, 2013/03/02 03:52:23]

No, static variables are always initialized to 0 (essentially).

+  if (format)
+    return format;
+  std::vector<CGLPixelFormatAttribute> attribs;
+  // If the system supports dual gpus then allow offline renderers for every
+  // context, so that they can all be in the same share group.
+  if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
+    attribs.push_back(kCGLPFAAllowOfflineRenderers);
+    g_support_renderer_switching = true;
+  }
+  if (GetGLImplementation() == kGLImplementationAppleGL) {
+    attribs.push_back(kCGLPFARendererID);
+    attribs.push_back((CGLPixelFormatAttribute) kCGLRendererGenericFloatID);
+    g_support_renderer_switching = false;
+  }
+  attribs.push_back((CGLPixelFormatAttribute) 0);
+
+  GLint num_virtual_screens;
+  if (CGLChoosePixelFormat(&attribs.front(),
+                           &format,
+                           &num_virtual_screens) != kCGLNoError) {
+    LOG(ERROR) << "Error choosing pixel format.";
+    return NULL;
+  }
+  if (!format) {
+    LOG(ERROR) << "format == 0.";
+    return NULL;
+  }
+  DCHECK_NE(num_virtual_screens, 0);
+  return format;
+}
+
 GLContextCGL::GLContextCGL(GLShareGroup* share_group)
   : GLContext(share_group),
     context_(NULL),
     gpu_preference_(PreferIntegratedGpu),
-    discrete_pixelformat_(NULL) {
+    discrete_pixelformat_(NULL),
+    screen_(-1),
+    renderer_(-1) {
 }
 
 bool GLContextCGL::Initialize(GLSurface* compatible_surface,
                               GpuPreference gpu_preference) {
   DCHECK(compatible_surface);
 
   gpu_preference = ui::GpuSwitchingManager::GetInstance()->AdjustGpuPreference(
       gpu_preference);
 
   GLContextCGL* share_context = share_group() ?
       static_cast<GLContextCGL*>(share_group()->GetContext()) : NULL;
 
-  std::vector<CGLPixelFormatAttribute> attribs;
-  // If the system supports dual gpus then allow offline renderers for every
-  // context, so that they can all be in the same share group.
-  if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus())
-    attribs.push_back(kCGLPFAAllowOfflineRenderers);
-  if (GetGLImplementation() == kGLImplementationAppleGL) {
-    attribs.push_back(kCGLPFARendererID);
-    attribs.push_back((CGLPixelFormatAttribute) kCGLRendererGenericFloatID);
-  }
-  attribs.push_back((CGLPixelFormatAttribute) 0);
-
-  CGLPixelFormatObj format;
-  GLint num_pixel_formats;
-  if (CGLChoosePixelFormat(&attribs.front(),
-                           &format,
-                           &num_pixel_formats) != kCGLNoError) {
-    LOG(ERROR) << "Error choosing pixel format.";
+  CGLPixelFormatObj format = GetPixelFormat();
+  if (!format)
     return false;
-  }
-  if (!format) {
-    LOG(ERROR) << "format == 0.";
-    return false;
-  }
-  DCHECK_NE(num_pixel_formats, 0);
 
   // If using the discrete gpu, create a pixel format requiring it before we
   // create the context.
   if (!ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus() ||
       gpu_preference == PreferDiscreteGpu) {
     std::vector<CGLPixelFormatAttribute> discrete_attribs;
     discrete_attribs.push_back((CGLPixelFormatAttribute) 0);
     GLint num_pixel_formats;
     if (CGLChoosePixelFormat(&discrete_attribs.front(),
                              &discrete_pixelformat_,
                              &num_pixel_formats) != kCGLNoError) {
       LOG(ERROR) << "Error choosing pixel format.";
       return false;
     }
   }
 
   CGLError res = CGLCreateContext(
       format,
       share_context ?
           static_cast<CGLContextObj>(share_context->GetHandle()) : NULL,
       reinterpret_cast<CGLContextObj*>(&context_));
-  CGLReleasePixelFormat(format);
   if (res != kCGLNoError) {
     LOG(ERROR) << "Error creating context.";
     Destroy();
     return false;
   }
 
   gpu_preference_ = gpu_preference;
   return true;
 }
 
 void GLContextCGL::Destroy() {
   if (discrete_pixelformat_) {
     CGLReleasePixelFormat(discrete_pixelformat_);
     discrete_pixelformat_ = NULL;
   }
   if (context_) {
     CGLDestroyContext(static_cast<CGLContextObj>(context_));
     context_ = NULL;
   }
 }
 
 bool GLContextCGL::MakeCurrent(GLSurface* surface) {
   DCHECK(context_);
+  int renderer = share_group()->GetRenderer();
+  int screen;
+  CGLGetVirtualScreen(static_cast<CGLContextObj>(context_), &screen);
+
+  if (g_support_renderer_switching &&
+      (screen != screen_ || renderer != renderer_)) {
+    CGLPixelFormatObj format = GetPixelFormat();
+    // Attempt to find a virtual screen that's using the requested renderer,
+    // and switch the context to use that screen.
+    int virtual_screen_count;
+    if (CGLDescribePixelFormat(format, 0, kCGLPFAVirtualScreenCount,
+                               &virtual_screen_count) != kCGLNoError)
+      return false;
+
+    for (int i = 0; i < virtual_screen_count; ++i) {
+      int screen_renderer;
+      if (CGLDescribePixelFormat(format, i, kCGLPFARendererID,
+                                 &screen_renderer) != kCGLNoError)
+        return false;
+
+      screen_renderer &= kCGLRendererIDMatchingMask;
+      if (screen_renderer == renderer) {
+        CGLSetVirtualScreen(static_cast<CGLContextObj>(context_), i);
+        screen_ = i;
+        break;
+      }
+    }
+    renderer_ = renderer;
+  }
+
   if (IsCurrent(surface))
     return true;
 
   TRACE_EVENT0("gpu", "GLContextCGL::MakeCurrent");
 
   if (CGLSetCurrentContext(
       static_cast<CGLContextObj>(context_)) != kCGLNoError) {
     LOG(ERROR) << "Unable to make gl context current.";
     return false;
   }
@@ skipping 103 matching lines @@
 
 GpuPreference GLContextCGL::GetGpuPreference() {
   return gpu_preference_;
 }
 
 void ScopedCGLDestroyRendererInfo::operator()(CGLRendererInfoObj x) const {
   CGLDestroyRendererInfo(x);
 }
 
 }  // namespace gfx