Force GPU switch with CGLSetVirtualScreen only for compositor

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;
 
+bool g_force_cgl_set_virtual_screen = false;
+
 static CGLPixelFormatObj GetPixelFormat() {
   static CGLPixelFormatObj format;
   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;
@@ skipping 86 matching lines @@
     discrete_pixelformat_ = NULL;
   }
   if (context_) {
     CGLDestroyContext(static_cast<CGLContextObj>(context_));
     context_ = NULL;
   }
 }
 
 bool GLContextCGL::MakeCurrent(GLSurface* surface) {
   DCHECK(context_);
-  int renderer_id = share_group()->GetRendererID();
-  int screen;
-  CGLGetVirtualScreen(static_cast<CGLContextObj>(context_), &screen);
 
-  if (g_support_renderer_switching &&
-      !discrete_pixelformat_ && renderer_id != -1 &&
-      (screen != screen_ || renderer_id != renderer_id_)) {
-    // Attempt to find a virtual screen that's using the requested renderer,
-    // and switch the context to use that screen. Don't attempt to switch if
-    // the context requires the discrete GPU.
-    CGLPixelFormatObj format = GetPixelFormat();
-    int virtual_screen_count;
-    if (CGLDescribePixelFormat(format, 0, kCGLPFAVirtualScreenCount,
-                               &virtual_screen_count) != kCGLNoError)
-      return false;
+  // The call to CGLSetVirtualScreen can hang on some AMD drivers
+  // http://crbug.com/227228
+  if (g_force_cgl_set_virtual_screen) {
+    int renderer_id = share_group()->GetRendererID();
+    int screen;
+    CGLGetVirtualScreen(static_cast<CGLContextObj>(context_), &screen);
 
-    for (int i = 0; i < virtual_screen_count; ++i) {
-      int screen_renderer_id;
-      if (CGLDescribePixelFormat(format, i, kCGLPFARendererID,
-                                 &screen_renderer_id) != kCGLNoError)
+    if (g_support_renderer_switching &&
+        !discrete_pixelformat_ && renderer_id != -1 &&
+        (screen != screen_ || renderer_id != renderer_id_)) {
+      // Attempt to find a virtual screen that's using the requested renderer,
+      // and switch the context to use that screen. Don't attempt to switch if
+      // the context requires the discrete GPU.
+      CGLPixelFormatObj format = GetPixelFormat();
+      int virtual_screen_count;
+      if (CGLDescribePixelFormat(format, 0, kCGLPFAVirtualScreenCount,
+                                 &virtual_screen_count) != kCGLNoError)
         return false;
 
-      screen_renderer_id &= kCGLRendererIDMatchingMask;
-      if (screen_renderer_id == renderer_id) {
-        CGLSetVirtualScreen(static_cast<CGLContextObj>(context_), i);
-        screen_ = i;
-        break;
+      for (int i = 0; i < virtual_screen_count; ++i) {
+        int screen_renderer_id;
+        if (CGLDescribePixelFormat(format, i, kCGLPFARendererID,
+                                   &screen_renderer_id) != kCGLNoError)
+          return false;
+
+        screen_renderer_id &= kCGLRendererIDMatchingMask;
+        if (screen_renderer_id == renderer_id) {
+          CGLSetVirtualScreen(static_cast<CGLContextObj>(context_), i);
+          screen_ = i;
+          break;
+        }
       }
+      renderer_id_ = renderer_id;
     }
-    renderer_id_ = renderer_id;
   }
 
   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.";
@@ skipping 92 matching lines @@
                             kCGLRPVideoMemory,
                             &video_memory) != kCGLNoError)
         continue;
     *bytes = video_memory;
     return true;
   }
 
   return false;
 }
 
+// static
+void GLContextCGL::ForceCGLSetVirtualScreen() {
+  g_force_cgl_set_virtual_screen = true;
+}
+
 GLContextCGL::~GLContextCGL() {
   Destroy();
 }
 
 GpuPreference GLContextCGL::GetGpuPreference() {
   return gpu_preference_;
 }
 
 void ScopedCGLDestroyRendererInfo::operator()(CGLRendererInfoObj x) const {
   CGLDestroyRendererInfo(x);
 }
 
 }  // namespace gfx