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

content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "gpu/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
@@ skipping 32 matching lines @@
     : initialize_failed_(false),
       context_(NULL),
       gl_(NULL),
       web_view_(NULL),
 #if defined(OS_MACOSX)
       plugin_handle_(NULL),
 #endif  // defined(OS_MACOSX)
       context_lost_callback_(0),
       context_lost_reason_(GL_NO_ERROR),
       swapbuffers_complete_callback_(0),
+      gpu_preference_(gfx::PreferIntegratedGpu),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
+  if (host_) {
+    if (host_->WillGpuSwitchOccur(false, gpu_preference_)) {
+      host_->ForciblyCloseChannel();
+    }
+  }
+
   {
     base::AutoLock lock(g_all_shared_contexts_lock.Get());
     g_all_shared_contexts.Pointer()->erase(this);
   }
   delete context_;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::initialize(
     WebGraphicsContext3D::Attributes attributes,
     WebKit::WebView* web_view,
     bool render_directly_to_web_view) {
   DCHECK(!context_);
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::initialize");
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   if (!render_thread)
     return false;
-  host_ = render_thread->EstablishGpuChannelSync(
-    content::
-      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);
-  if (!host_)
-    return false;
-  DCHECK(host_->state() == GpuChannelHost::kConnected);
+
+  // The noExtensions and canRecoverFromContextLoss flags are
+  // currently used as hints that we are creating a context on
+  // behalf of WebGL or accelerated 2D canvas, respectively.
+  if (attributes.noExtensions || !attributes.canRecoverFromContextLoss)
+    gpu_preference_ = gfx::PreferDiscreteGpu;
+
+  bool retry = false;
+
+  do {
+    host_ = render_thread->EstablishGpuChannelSync(
+        content::
+        CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);
+    if (!host_)
+      return false;
+    DCHECK(host_->state() == GpuChannelHost::kConnected);
+
+    if (!retry) {
+      // If the creation of this context requires all contexts for this
+      // renderer to be destroyed on the GPU process side, then drop the
+      // channel and recreate it.
+      if (host_->WillGpuSwitchOccur(true, gpu_preference_)) {
+        host_->ForciblyCloseChannel();
+        retry = true;
+      }
+    } else {
+      retry = false;
+    }
+  } while (retry);
 
   const GPUInfo& gpu_info = host_->gpu_info();
   UMA_HISTOGRAM_ENUMERATION(
       "GPU.WebGraphicsContext3D_Init_CanLoseContext",
       attributes.canRecoverFromContextLoss * 2 + gpu_info.can_lose_context,
       4);
   if (attributes.canRecoverFromContextLoss == false) {
     if (gpu_info.can_lose_context)
       return false;
   }
@@ skipping 52 matching lines @@
           NULL : (*g_all_shared_contexts.Pointer()->begin())->context_;
     }
 
     if (render_directly_to_web_view_) {
       context_ = RendererGLContext::CreateViewContext(
           host_,
           render_view_routing_id_,
           share_group,
           preferred_extensions,
           attribs,
-          active_url_);
+          active_url_,
+          gpu_preference_);
     } else {
       context_ = RendererGLContext::CreateOffscreenContext(
           host_,
           gfx::Size(1, 1),
           share_group,
           preferred_extensions,
           attribs,
-          active_url_);
+          active_url_,
+          gpu_preference_);
     }
   }
 
   if (!context_)
     return false;
 
   gl_ = context_->GetImplementation();
 
   // TODO(twiz):  This code is too fragile in that it assumes that only WebGL
   // contexts will request noExtensions.
@@ skipping 909 matching lines @@
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
   RenderViewImpl* renderview =
       web_view_ ? RenderViewImpl::FromWebView(web_view_) : NULL;
   if (renderview)
     renderview->OnViewContextSwapBuffersAborted();
 }
 
 #endif  // defined(ENABLE_GPU)