Plumbing explicit share groups through context creation

content/common/gpu/client/webgraphicscontext3d_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 "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "third_party/khronos/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 219 matching lines @@
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
   if (real_gl_) {
     real_gl_->SetErrorMessageCallback(NULL);
   }
 
   Destroy();
 }
 
-bool WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL() {
+bool WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL(
+    WebGraphicsContext3DCommandBufferImpl* share_context) {
   if (initialized_)
     return true;
 
   if (initialize_failed_)
     return false;
 
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::MaybeInitializeGL");
 
-  if (!CreateContext(surface_id_ != 0)) {
+  if (!CreateContext(surface_id_ != 0, share_context)) {
     Destroy();
     initialize_failed_ = true;
     return false;
   }
 
   // TODO(twiz):  This code is too fragile in that it assumes that only WebGL
   // contexts will request noExtensions.
   if (gl_ && attributes_.noExtensions)
     gl_->EnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation");
 
@@ skipping 28 matching lines @@
     attributes_.stencil = pvalues[2] > 0;
     attributes_.antialias = pvalues[3] > 0;
   }
 
   visible_ = true;
   initialized_ = true;
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::InitializeCommandBuffer(
-    bool onscreen) {
+    bool onscreen, WebGraphicsContext3DCommandBufferImpl* share_context) {
   if (!host_.get())
     return false;
   // We need to lock g_all_shared_contexts to ensure that the context we picked
   // for our share group isn't deleted.
   // (There's also a lock in our destructor.)
   base::AutoLock lock(g_all_shared_contexts_lock.Get());
+
   CommandBufferProxyImpl* share_group = NULL;
-  if (attributes_.shareResources) {
+
+  if (share_context)
+    share_group = share_context->command_buffer_.get();
+
+  if (attributes_.shareResources && !share_group) {
     ContextMap& all_contexts = g_all_shared_contexts.Get();
     ContextMap::const_iterator it = all_contexts.find(host_.get());
     if (it != all_contexts.end())
       share_group = it->second->command_buffer_.get();
   }
 
   std::vector<int32> attribs;
   attribs.push_back(ALPHA_SIZE);
   attribs.push_back(attributes_.alpha ? 8 : 0);
   attribs.push_back(DEPTH_SIZE);
@@ skipping 26 matching lines @@
   }
 
   if (!command_buffer_)
     return false;
 
   // Initialize the command buffer.
   return command_buffer_->Initialize();
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::CreateContext(
-    bool onscreen) {
+    bool onscreen, WebGraphicsContext3DCommandBufferImpl* share_context) {
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
   if (!command_buffer_ &&
-      !InitializeCommandBuffer(onscreen)) {
+      !InitializeCommandBuffer(onscreen, share_context)) {
     return false;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!gles2_helper_->Initialize(mem_limits_.command_buffer_size))
     return false;
 
   if (attributes_.noAutomaticFlushes)
     gles2_helper_->SetAutomaticFlushes(false);
 
   // Create a transfer buffer used to copy resources between the renderer
   // process and the GPU process.
   transfer_buffer_ .reset(new gpu::TransferBuffer(gles2_helper_.get()));
 
   DCHECK(host_.get());
   scoped_ptr<base::AutoLock> lock;
   scoped_refptr<gpu::gles2::ShareGroup> share_group;
-  if (attributes_.shareResources) {
+
+  if (share_context)
+    share_group = share_context->GetImplementation()->share_group();
+
+  if (attributes_.shareResources && !share_group) {
     // Make sure two clients don't try to create a new ShareGroup
     // simultaneously.
     lock.reset(new base::AutoLock(g_all_shared_contexts_lock.Get()));
     ContextMap& all_contexts = g_all_shared_contexts.Get();
     ContextMap::const_iterator it = all_contexts.find(host_.get());
     if (it != all_contexts.end()) {
       share_group = it->second->GetImplementation()->share_group();
       DCHECK(share_group);
     }
   }
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool free_command_buffer_when_invisible =
       command_line.HasSwitch(switches::kEnablePruneGpuCommandBuffers);
 
   // Create the object exposing the OpenGL API.
   real_gl_.reset(new gpu::gles2::GLES2Implementation(
       gles2_helper_.get(),
       share_group,
       transfer_buffer_.get(),
       bind_generates_resources_,
       free_command_buffer_when_invisible,
       command_buffer_.get()));
   gl_ = real_gl_.get();
 
   if (attributes_.shareResources) {

[no sievers, 2013/12/11 00:36:27]

You might want to check '&& !share_context' here also, because it'd be bad if
you inserted this context here and it is actually not in the global share group
(another context would potentially use it to share with).

I'd also DCHECK() somewhere that neither this context nor share_context have
shareResources set.

     // Don't add ourselves to the list before others can get to our ShareGroup.
     g_all_shared_contexts.Get().insert(std::make_pair(host_.get(), this));
     lock.reset();
   }
 
   if (!real_gl_->Initialize(
       mem_limits_.start_transfer_buffer_size,
       mem_limits_.min_transfer_buffer_size,
       mem_limits_.max_transfer_buffer_size,
       mem_limits_.mapped_memory_reclaim_limit)) {
     return false;
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGpuClientTracing)) {
     trace_gl_.reset(new gpu::gles2::GLES2TraceImplementation(gl_));
     gl_ = trace_gl_.get();
   }
 
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::makeContextCurrent() {
-  if (!MaybeInitializeGL())
+  if (!MaybeInitializeGL(NULL))
     return false;
   gles2::SetGLContext(gl_);
   if (command_buffer_->GetLastError() != gpu::error::kNoError)
     return false;
 
   return true;
 }
 
 uint32_t WebGraphicsContext3DCommandBufferImpl::lastFlushID() {
   return flush_id_;
@@ skipping 747 matching lines @@
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   return state.error == gpu::error::kLostContext;
 }
 
 // static
 WebGraphicsContext3DCommandBufferImpl*
 WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
     GpuChannelHost* host,
     const WebGraphicsContext3D::Attributes& attributes,
     const GURL& active_url,
-    const SharedMemoryLimits& limits) {
+    const SharedMemoryLimits& limits,
+    WebGraphicsContext3D* share_context) {
   if (!host)
     return NULL;
-  return new WebGraphicsContext3DCommandBufferImpl(0,
-                                                   active_url,
-                                                   host,
-                                                   attributes,
-                                                   false,
-                                                   limits);
+
+  WebGraphicsContext3DCommandBufferImpl* context =
+      new WebGraphicsContext3DCommandBufferImpl(0,
+                                                active_url,
+                                                host,
+                                                attributes,
+                                                false,
+                                                limits);
+
+  if (context && share_context) {
+    if (!context->MaybeInitializeGL(NULL)) {

[no sievers, 2013/12/10 19:53:34]

This can't be done here but has to happen on the thread where the context is
used. Specifically, it's a problem with the compositor in threaded mode and the
offscreen context provider it creates through this codepath.

It should probably be named better (BindToThread() like in l
ContextProviderCommandBuffer::BindToCurrentThread()).

[no sievers, 2013/12/11 00:36:27]

Can you maybe just pull this out by calling makeContextCurrent() in
RendererWebKitPlatformSupportImpl::createOffscreenGraphicsContext3D()?

+      delete context;
+      return NULL;
+    }
+  }
+
+  return context;
 }
 
 DELEGATE_TO_GL_5(texImageIOSurface2DCHROMIUM, TexImageIOSurface2DCHROMIUM,
                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Duint, WGC3Duint)
 
 DELEGATE_TO_GL_5(texStorage2DEXT, TexStorage2DEXT,
                  WGC3Denum, WGC3Dint, WGC3Duint, WGC3Dint, WGC3Dint)
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createQueryEXT() {
   GLuint o;
@@ skipping 160 matching lines @@
 
 void WebGraphicsContext3DCommandBufferImpl::OnErrorMessage(
     const std::string& message, int id) {
   if (error_message_callback_) {
     blink::WebString str = blink::WebString::fromUTF8(message.c_str());
     error_message_callback_->onErrorMessage(str, id);
   }
 }
 
 }  // namespace content