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

webkit/gpu/webgraphicscontext3d_in_process_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 "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
@@ skipping 85 matching lines @@
   // already in place. We could add more entry points and messages to
   // allocate both fake PluginWindowHandles and NativeViewIds and map
   // from fake NativeViewIds to PluginWindowHandles, but this seems like
   // unnecessary complexity at the moment.
   //
   static GLInProcessContext* CreateViewContext(
       gfx::PluginWindowHandle render_surface,
       GLInProcessContext* context_group,
       const char* allowed_extensions,
       const int32* attrib_list,
-      const GURL& active_arl);
+      const GURL& active_url,
+      gfx::GpuPreference gpu_preference);
 
   // Create a GLInProcessContext that renders to an offscreen frame buffer. If
   // parent is not NULL, that GLInProcessContext can access a copy of the
   // created GLInProcessContext's frame buffer that is updated every time
   // SwapBuffers is called. It is not as general as shared GLInProcessContexts
   // in other implementations of OpenGL. If parent is not NULL, it must be used
   // on the same thread as the parent. A child GLInProcessContext may not
   // outlive its parent.  attrib_list must be NULL or a NONE-terminated list of
   // attribute/value pairs.
   static GLInProcessContext* CreateOffscreenContext(
       GLInProcessContext* parent,
       const gfx::Size& size,
       GLInProcessContext* context_group,
       const char* allowed_extensions,
       const int32* attrib_list,
-      const GURL& active_url);
+      const GURL& active_url,
+      gfx::GpuPreference gpu_preference);
 
   // For an offscreen frame buffer GLInProcessContext, return the texture ID
   // with respect to the parent GLInProcessContext. Returns zero if
   // GLInProcessContext does not have a parent.
   uint32 GetParentTextureId();
 
   // Create a new texture in the parent's GLInProcessContext.  Returns zero if
   // GLInProcessContext does not have a parent.
   uint32 CreateParentTexture(const gfx::Size& size);
 
@@ skipping 33 matching lines @@
 
  private:
   GLInProcessContext(GLInProcessContext* parent);
 
   bool Initialize(bool onscreen,
                   gfx::PluginWindowHandle render_surface,
                   const gfx::Size& size,
                   GLInProcessContext* context_group,
                   const char* allowed_extensions,
                   const int32* attrib_list,
-                  const GURL& active_url);
+                  const GURL& active_url,
+                  gfx::GpuPreference gpu_preference);
   void Destroy();
 
   void OnSwapBuffers();
   void OnContextLost();
 
   base::WeakPtr<GLInProcessContext> parent_;
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
   scoped_ptr<Callback0::Type> context_lost_callback_;
   uint32 parent_texture_id_;
   scoped_ptr<CommandBufferService> command_buffer_;
@@ skipping 46 matching lines @@
 
 GLInProcessContext::~GLInProcessContext() {
   Destroy();
 }
 
 GLInProcessContext* GLInProcessContext::CreateViewContext(
     gfx::PluginWindowHandle render_surface,
     GLInProcessContext* context_group,
     const char* allowed_extensions,
     const int32* attrib_list,
-    const GURL& active_url) {
+    const GURL& active_url,
+    gfx::GpuPreference gpu_preference) {
 #if defined(ENABLE_GPU)
   scoped_ptr<GLInProcessContext> context(new GLInProcessContext(NULL));
   if (!context->Initialize(
       true,
       render_surface,
       gfx::Size(),
       context_group,
       allowed_extensions,
       attrib_list,
-      active_url))
+      active_url,
+      gpu_preference))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 GLInProcessContext* GLInProcessContext::CreateOffscreenContext(
     GLInProcessContext* parent,
     const gfx::Size& size,
     GLInProcessContext* context_group,
     const char* allowed_extensions,
     const int32* attrib_list,
-    const GURL& active_url) {
+    const GURL& active_url,
+    gfx::GpuPreference gpu_preference) {
 #if defined(ENABLE_GPU)
   scoped_ptr<GLInProcessContext> context(new GLInProcessContext(parent));
   if (!context->Initialize(
       false,
       gfx::kNullPluginWindow,
       size,
       context_group,
       allowed_extensions,
       attrib_list,
-      active_url))
+      active_url,
+      gpu_preference))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 // In the normal command buffer implementation, all commands are passed over IPC
 // to the gpu process where they are fed to the GLES2Decoder from a single
@@ skipping 101 matching lines @@
       transfer_buffer_id_(-1),
       last_error_(SUCCESS) {
 }
 
 bool GLInProcessContext::Initialize(bool onscreen,
                                     gfx::PluginWindowHandle render_surface,
                                     const gfx::Size& size,
                                     GLInProcessContext* context_group,
                                     const char* allowed_extensions,
                                     const int32* attrib_list,
-                                    const GURL& active_url) {
+                                    const GURL& active_url,
+                                    gfx::GpuPreference gpu_preference) {
   // Use one share group for all contexts.
   static scoped_refptr<gfx::GLShareGroup> share_group(new gfx::GLShareGroup);
 
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
   // Allocate a frame buffer ID with respect to the parent.
   if (parent_.get()) {
@@ skipping 62 matching lines @@
     surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false,
                                                         gfx::Size(1, 1));
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     Destroy();
     return false;
   }
 
-  context_ = gfx::GLContext::CreateGLContext(share_group.get(), surface_.get());
+  context_ = gfx::GLContext::CreateGLContext(share_group.get(),
+                                             surface_.get(),
+                                             gpu_preference);
   if (!context_.get()) {
     LOG(ERROR) << "Could not create GLContext.";
     Destroy();
     return false;
   }
 
   if (!decoder_->Initialize(surface_.get(),
                             context_.get(),
                             size,
                             ::gpu::gles2::DisallowedFeatures(),
@@ skipping 124 matching lines @@
     GLInProcessContext::ALPHA_SIZE, alpha_size,
     GLInProcessContext::DEPTH_SIZE, depth_size,
     GLInProcessContext::STENCIL_SIZE, stencil_size,
     GLInProcessContext::SAMPLES, samples,
     GLInProcessContext::SAMPLE_BUFFERS, sample_buffers,
     GLInProcessContext::NONE,
   };
 
   const char* preferred_extensions = "*";
 
+  // TODO(kbr): more work will be needed in this implementation to

[stuartmorgan, 2011/10/12 07:13:24]

s/more/More/.

Annotate with a bug link?

[Ken Russell (switch to Gerrit), 2011/10/12 22:39:42]

OK.
Not clear to me that it is worth it. I don't have evidence that the GPU
switching code path would be testable in our test harness, outside of the full
browser.

+  // properly support GPU switching. Like in the out-of-process
+  // command buffer implementation, all previously created contexts
+  // will need to be lost either when the first context requesting the
+  // discrete GPU is created, or the last one is destroyed.
+  gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
+
   GURL active_url;
   if (web_view && web_view->mainFrame())
     active_url = GURL(web_view->mainFrame()->document().url());
 
   GLInProcessContext* parent_context = NULL;
   if (!render_directly_to_web_view) {
     WebKit::WebGraphicsContext3D* view_context =
         web_view ? web_view->graphicsContext3D() : NULL;
     if (view_context) {
       WebGraphicsContext3DInProcessCommandBufferImpl* context_impl =
           static_cast<WebGraphicsContext3DInProcessCommandBufferImpl*>(
               view_context);
       parent_context = context_impl->context_;
     }
   }
 
   WebGraphicsContext3DInProcessCommandBufferImpl* context_group = NULL;
   base::AutoLock lock(g_all_shared_contexts_lock.Get());
   if (attributes.shareResources)
     context_group = g_all_shared_contexts.Pointer()->empty() ?
         NULL : *g_all_shared_contexts.Pointer()->begin();
 
   context_ = GLInProcessContext::CreateOffscreenContext(
       parent_context,
       gfx::Size(1, 1),
       context_group ? context_group->context_ : NULL,
       preferred_extensions,
       attribs,
-      active_url);
+      active_url,
+      gpu_preference);
   web_view_ = NULL;
 
   if (!context_)
     return false;
 
   gl_ = context_->GetImplementation();
 
   if (gl_ && attributes.noExtensions)
     gl_->EnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation");
 
@@ skipping 942 matching lines @@
   context_lost_reason_ = GL_UNKNOWN_CONTEXT_RESET_ARB;
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 }
 
 }  // namespace gpu
 }  // namespace webkit
 
 #endif  // defined(ENABLE_GPU)