Migrate WebGL contexts on backgrounded tabs to the integrated GPU.

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 <memory>
@@ skipping 96 matching lines @@
       static_cast<GLContextCGL*>(share_group()->GetContext()) : nullptr;
 
   CGLPixelFormatObj format = GetPixelFormat();
   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) {
-    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.";
+    if (!AllocateDiscretePixelFormat())
       return false;
-    }
-    // The renderer might be switched after this, so ignore the saved ID.
-    share_group()->SetRendererID(-1);
   }
 
   CGLError res = CGLCreateContext(
       format,
       share_context ?
           static_cast<CGLContextObj>(share_context->GetHandle()) : nullptr,
       reinterpret_cast<CGLContextObj*>(&context_));
   if (res != kCGLNoError) {
     LOG(ERROR) << "Error creating context.";
     Destroy();
     return false;
   }
 
   gpu_preference_ = gpu_preference;
   // Contexts that prefer integrated gpu are known to use only the subset of GL
   // that can be safely migrated between the iGPU and the dGPU. Mark those
   // contexts as safe to forcibly transition between the GPUs by default.
   // http://crbug.com/180876, http://crbug.com/227228
   safe_to_force_gpu_switch_ = gpu_preference == PreferIntegratedGpu;
   return true;
 }
 
+bool GLContextCGL::AllocateDiscretePixelFormat() {
+  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 discrete pixel format.";
+    return false;
+  }
+  // The renderer might be switched after this, so ignore the saved ID.
+  share_group()->SetRendererID(-1);
+  return true;
+}
+
+void GLContextCGL::ReleaseDiscretePixelFormat() {
+  CGLReleasePixelFormat(discrete_pixelformat_);
+  discrete_pixelformat_ = nullptr;
+}
+
 void GLContextCGL::Destroy() {
   if (yuv_to_rgb_converter_) {
     ScopedCGLSetCurrentContext(static_cast<CGLContextObj>(context_));
     yuv_to_rgb_converter_.reset();
   }
   if (discrete_pixelformat_) {
     if (base::MessageLoop::current() != nullptr) {
       // Delay releasing the pixel format for 10 seconds to reduce the number of
       // unnecessary GPU switches.
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 126 matching lines @@
 
 
 GLContextCGL::~GLContextCGL() {
   Destroy();
 }
 
 GpuPreference GLContextCGL::GetGpuPreference() {
   return gpu_preference_;
 }
 
+void GLContextCGL::SetPerformancePreference(GpuPerformancePreference pref) {
+  if (pref == PreferLowPower) {
+    if (discrete_pixelformat_)
+      ReleaseDiscretePixelFormat();
+  } else {
+    if (gpu_preference_ == PreferDiscreteGpu && !discrete_pixelformat_)
+      AllocateDiscretePixelFormat();

[jbauman, 2017/01/19 01:13:14]

I'm not sure this would actually switch the context onto the discrete GPU. Once
an offscreen context is created it seems like it's stuck to a GPU until
GLContextCGL::ForceGpuSwitchIfNeeded does CGLSetVirtualScreen, and it won't do
that call if discrete_pixelformat_ exists.

See also
https://chromium.googlesource.com/chromium/src/+/97419c0f3a44da99c730fc572011...
for the issues we've had in the past with switching contexts from the integrated
GPU to the discrete GPU.

[Ken Russell (switch to Gerrit), 2017/01/20 04:34:52]

Thanks for tracking down that change. I'd remembered it vaguely but not done the
code archaeology.

This CL definitely causes gfxCardStatus to think that the machine has switched
back to the integrated GPU, regardless of whether we're calling
CGLSetVirtualScreen. I'm not really sure exactly what effect it has and what
resources are being migrated between GPUs. We are hoping to get some more
details from Apple's OpenGL team about how integrated/discrete GPU transitions
work and exactly what is allowed, and needed, in order to save power in this
area.

+  }
+}
+
 }  // namespace gl