Add option to use GLContextVirtual in WGC3DIPCBI

webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.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 "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 13 matching lines @@
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/gl_context_virtual.h"
+#include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
-#include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 #include "webkit/gpu/gl_bindings_skia_cmd_buffer.h"
 
 using gpu::Buffer;
 using gpu::CommandBuffer;
 using gpu::CommandBufferService;
 using gpu::gles2::GLES2CmdHelper;
 using gpu::gles2::GLES2Implementation;
@@ skipping 46 matching lines @@
   // Create a GLInProcessContext, if |is_offscreen| is true, renders to an
   // offscreen context. |attrib_list| must be NULL or a NONE-terminated list
   // of attribute/value pairs.
   static GLInProcessContext* CreateContext(
       bool is_offscreen,
       gfx::AcceleratedWidget window,
       const gfx::Size& size,
       bool share_resources,
       const char* allowed_extensions,
       const int32* attrib_list,
-      gfx::GpuPreference gpu_preference);
+      gfx::GpuPreference gpu_preference,
+      bool use_virtualized_gl_context);
 
   // 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 30 matching lines @@
   ::gpu::gles2::GLES2Decoder* GetDecoder();
 
  private:
   explicit GLInProcessContext(bool share_resources);
 
   bool Initialize(bool is_offscreen,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list,
-                  gfx::GpuPreference gpu_preference);
+                  gfx::GpuPreference gpu_preference,
+                  bool use_virtualized_gl_context);
   void Destroy();
 
   void OnContextLost();
 
   base::Closure context_lost_callback_;
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferService> command_buffer_;
   scoped_ptr< ::gpu::GpuScheduler> gpu_scheduler_;
   scoped_ptr< ::gpu::gles2::GLES2Decoder> decoder_;
   scoped_refptr<gfx::GLContext> context_;
@@ skipping 43 matching lines @@
   Destroy();
 }
 
 GLInProcessContext* GLInProcessContext::CreateContext(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     bool share_resources,
     const char* allowed_extensions,
     const int32* attrib_list,
-    gfx::GpuPreference gpu_preference) {
+    gfx::GpuPreference gpu_preference,
+    bool use_virtualized_gl_context) {
   scoped_ptr<GLInProcessContext> context(
       new GLInProcessContext(share_resources));
   if (!context->Initialize(
       is_offscreen,
       window,
       size,
       allowed_extensions,
       attrib_list,
-      gpu_preference))
+      gpu_preference,
+      use_virtualized_gl_context))
     return NULL;
 
   return context.release();
 }
 
 // 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
 // thread. In layout tests, any thread could call this function. GLES2Decoder,
 // and in particular the GL implementations behind it, are not generally
 // threadsafe, so we guard entry points with a mutex.
@@ skipping 150 matching lines @@
       share_resources_(share_resources),
       context_lost_(false) {
 }
 
 bool GLInProcessContext::Initialize(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const char* allowed_extensions,
     const int32* attrib_list,
-    gfx::GpuPreference gpu_preference) {
+    gfx::GpuPreference gpu_preference,
+    bool use_virtualized_gl_context) {
   // Use one share group for all contexts.
   CR_DEFINE_STATIC_LOCAL(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();
 
   std::vector<int32> attribs;
@@ skipping 63 matching lines @@
       surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, size);
     else
       surface_ = gfx::GLSurface::CreateViewGLSurface(false, window);
 
     if (!surface_.get()) {
       LOG(ERROR) << "Could not create GLSurface.";
       Destroy();
       return false;
     }
 
-    context_ = gfx::GLContext::CreateGLContext(share_group.get(),
-                                               surface_.get(),
-                                               gpu_preference);
+    if (use_virtualized_gl_context) {
+      context_ = share_group->GetSharedContext();
+      if (!context_) {
+        context_ = gfx::GLContext::CreateGLContext(share_group.get(),
+                                                   surface_.get(),
+                                                   gpu_preference);
+        share_group->SetSharedContext(context_);
+      }
+
+      // This should be a non-virtual GL context.
+      DCHECK(context_->GetHandle());

[no sievers, 2013/04/19 18:38:40]

Won't this DCHECK() fail for WebView (where we never have a context)?
It's probably fine to not have that check...

+      context_ = new ::gpu::GLContextVirtual(share_group.get(),
+                                             context_,
+                                             decoder_->AsWeakPtr());
+      if (context_->Initialize(surface_, gpu_preference)) {

[no sievers, 2013/04/19 18:39:45]

Oh, and you could fall back to the else-path in here, if the initialization
failed.
That would be the case on some platform where not all surfaces are compatible
with the shared context.

+        LOG(INFO) << "Created virtual GL context.";
+      }
+    } else {
+      context_ = gfx::GLContext::CreateGLContext(share_group.get(),
+                                                 surface_.get(),
+                                                 gpu_preference);
+    }
+
     if (!context_.get()) {
       LOG(ERROR) << "Could not create GLContext.";
       Destroy();
       return false;
     }
 
     if (!context_->MakeCurrent(surface_.get())) {
       LOG(ERROR) << "Could not make context current.";
       Destroy();
       return false;
@@ skipping 87 matching lines @@
 void GLInProcessContext::OnContextLost() {
   if (!context_lost_callback_.is_null())
     context_lost_callback_.Run();
 }
 
 
 // static
 WebGraphicsContext3DInProcessCommandBufferImpl*
 WebGraphicsContext3DInProcessCommandBufferImpl::CreateViewContext(
     const WebKit::WebGraphicsContext3D::Attributes& attributes,
-    gfx::AcceleratedWidget window) {
+    gfx::AcceleratedWidget window,
+    bool use_virtualized_gl_context) {
   return new WebGraphicsContext3DInProcessCommandBufferImpl(
-      attributes, false, window);
+      attributes, false, window, use_virtualized_gl_context);
 }
 
 // static
 WebGraphicsContext3DInProcessCommandBufferImpl*
 WebGraphicsContext3DInProcessCommandBufferImpl::CreateOffscreenContext(
     const WebKit::WebGraphicsContext3D::Attributes& attributes) {
   return new WebGraphicsContext3DInProcessCommandBufferImpl(
-      attributes, true, gfx::kNullAcceleratedWidget);
+      attributes, true, gfx::kNullAcceleratedWidget, false);
 }
 
 WebGraphicsContext3DInProcessCommandBufferImpl::
     WebGraphicsContext3DInProcessCommandBufferImpl(
         const WebKit::WebGraphicsContext3D::Attributes& attributes,
         bool is_offscreen,
-        gfx::AcceleratedWidget window)
+        gfx::AcceleratedWidget window,
+        bool use_virtualized_gl_context)
     : is_offscreen_(is_offscreen),
       window_(window),
+      use_virtualized_gl_context_(use_virtualized_gl_context),
       initialized_(false),
       initialize_failed_(false),
       context_(NULL),
       gl_(NULL),
       context_lost_callback_(NULL),
       context_lost_reason_(GL_NO_ERROR),
       attributes_(attributes),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0) {
@@ skipping 35 matching lines @@
   // discrete GPU is created, or the last one is destroyed.
   gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   context_ = GLInProcessContext::CreateContext(
       is_offscreen_,
       window_,
       gfx::Size(1, 1),
       attributes_.shareResources,
       preferred_extensions,
       attribs,
-      gpu_preference);
+      gpu_preference,
+      use_virtualized_gl_context_);
 
   if (!context_) {
     initialize_failed_ = true;
     return false;
   }
 
   gl_ = context_->GetImplementation();
 
   if (gl_ && attributes_.noExtensions)
     gl_->EnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation");
@@ skipping 1072 matching lines @@
 
 DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
     WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei,
     WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
     WGC3Denum)
 
 }  // namespace gpu
 }  // namespace webkit