Fix for 300ms scroll lag on 2013 Mac Pros once idle for 10seconds

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>
 
@@ skipping 13 matching lines @@
 
 struct CGLRendererInfoObjDeleter {
   void operator()(CGLRendererInfoObj* x) {
     if (x)
       CGLDestroyRendererInfo(*x);
   }
 };
 
 }  // namespace
 
-static CGLPixelFormatObj GetPixelFormat() {
+static CGLPixelFormatObj GetPixelFormat(bool prevent_switchable) {
   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()) {
+  // context, so that they can all be in the same share group. Don't do this for
+  // discrete GPUs to avoid being offloaded to an idle GPU by OSX.
+  if (!prevent_switchable) {
     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;
   }
   if (GetGLImplementation() == kGLImplementationDesktopGLCoreProfile) {
     // These constants don't exist in the 10.6 SDK against which
@@ skipping 34 matching lines @@
 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;
 
-  CGLPixelFormatObj format = GetPixelFormat();
+  const bool prevent_switchable = gpu_preference == PreferDiscreteGpu ||
+      !ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus();
+
+  CGLPixelFormatObj format = GetPixelFormat(prevent_switchable);
   if (!format)
     return false;
 
   // If using the discrete gpu, create a pixel format requiring it before we
   // create the context.
-  if (!ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus() ||
-      gpu_preference == PreferDiscreteGpu) {
+  if (prevent_switchable) {
     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;
     }
     // The renderer might be switched after this, so ignore the saved ID.
@@ skipping 43 matching lines @@
     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();
+      CGLPixelFormatObj format = GetPixelFormat(false);
       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_id;
         if (CGLDescribePixelFormat(format, i, kCGLPFARendererID,
                                    &screen_renderer_id) != kCGLNoError)
           return false;
@@ skipping 136 matching lines @@
 
 GLContextCGL::~GLContextCGL() {
   Destroy();
 }
 
 GpuPreference GLContextCGL::GetGpuPreference() {
   return gpu_preference_;
 }
 
 }  // namespace gfx