Request context sharing via content::ContextProviderCommandBuffer

content/common/gpu/client/context_provider_command_buffer.cc

 // Copyright (c) 2013 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/context_provider_command_buffer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/managed_memory_policy.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_trace_implementation.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #include "gpu/skia_bindings/grcontext_for_gles2_interface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace content {
 
+ContextProviderCommandBuffer::SharedProviders::SharedProviders() = default;
+ContextProviderCommandBuffer::SharedProviders::~SharedProviders() = default;
+
 class ContextProviderCommandBuffer::LostContextCallbackProxy
     : public WebGraphicsContext3DCommandBufferImpl::
           WebGraphicsContextLostCallback {
  public:
   explicit LostContextCallbackProxy(ContextProviderCommandBuffer* provider)
       : provider_(provider) {
     provider_->context3d_->SetContextLostCallback(this);
   }
 
   ~LostContextCallbackProxy() override {
     provider_->context3d_->SetContextLostCallback(nullptr);
   }
 
   void onContextLost() override { provider_->OnLostContext(); }
 
  private:
   ContextProviderCommandBuffer* provider_;
 };
 
 ContextProviderCommandBuffer::ContextProviderCommandBuffer(
     std::unique_ptr<WebGraphicsContext3DCommandBufferImpl> context3d,
     const gpu::SharedMemoryLimits& memory_limits,
+    ContextProviderCommandBuffer* shared_context_provider,
     CommandBufferContextType type)
-    : context3d_(std::move(context3d)),
+    : shared_providers_(shared_context_provider
+                            ? shared_context_provider->shared_providers_
+                            : new SharedProviders),
+      context3d_(std::move(context3d)),
       memory_limits_(memory_limits),
       context_type_(type),
       debug_name_(CommandBufferContextTypeToString(type)) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(context3d_);
   context_thread_checker_.DetachFromThread();
 }
 
 ContextProviderCommandBuffer::~ContextProviderCommandBuffer() {
   DCHECK(main_thread_checker_.CalledOnValidThread() ||
          context_thread_checker_.CalledOnValidThread());
 
+  {
+    base::AutoLock hold(shared_providers_->lock);
+    auto it = std::find(shared_providers_->list.begin(),
+                        shared_providers_->list.end(), this);
+    if (it != shared_providers_->list.end())
+      shared_providers_->list.erase(it);
+  }
+
   // Destroy references to the context3d_ before leaking it.
   // TODO(danakj): Delete this.
   if (context3d_->GetCommandBufferProxy())
     context3d_->GetCommandBufferProxy()->SetLock(nullptr);
 
   if (lost_context_callback_proxy_) {
     // Disconnect lost callbacks during destruction.
     lost_context_callback_proxy_.reset();
   }
 }
@@ skipping 12 matching lines @@
 }
 
 bool ContextProviderCommandBuffer::BindToCurrentThread() {
   // This is called on the thread the context will be used.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (lost_context_callback_proxy_)
     return true;
 
   context3d_->SetContextType(context_type_);
-  if (!context3d_->InitializeOnCurrentThread(memory_limits_))
-    return false;
+
+  ContextProviderCommandBuffer* shared_context_provider = nullptr;
+  gpu::CommandBufferProxyImpl* shared_command_buffer = nullptr;

[piman, 2016/04/27 22:09:33]

nit: move both of those inside the AutoLock scope below (since we're not taking
a reference, they're only valid while the lock is held)

[danakj, 2016/04/28 00:25:58]

Done. I forget why I moved these out to start with..

+  scoped_refptr<gpu::gles2::ShareGroup> share_group;
+
+  // It's possible to be running BindToCurrentThread on two contexts
+  // on different threads at the same time, but which will be in the same share
+  // group. To ensure they end up in the same group, hold the lock on the
+  // shared_providers_ (which they will share) after querying the group, until
+  // this context has been added to the list.
+  {
+    base::AutoLock hold(shared_providers_->lock);
+
+    if (!shared_providers_->list.empty()) {
+      shared_context_provider = shared_providers_->list.front();
+      shared_command_buffer =
+          shared_context_provider->context3d_->GetCommandBufferProxy();
+      share_group = shared_context_provider->context3d_->GetImplementation()
+                        ->share_group();
+
+      // If any context in the share group has been lost, then abort and don't
+      // continue since we need to go back to the caller of the constructor to
+      // find the correct share group.
+      // This may happen in between the share group being chosen at the
+      // constructor, and getting to run this BindToCurrentThread method which
+      // can be on some other thread.
+      if (share_group->IsLost())
+        return false;
+    }
+
+    if (!context3d_->InitializeOnCurrentThread(
+            memory_limits_, shared_command_buffer, std::move(share_group)))
+      return false;
+
+    shared_providers_->list.push_back(this);
+  }
+
   lost_context_callback_proxy_.reset(new LostContextCallbackProxy(this));
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuClientTracing)) {
     // This wraps the real GLES2Implementation and we should always use this
     // instead when it's present.
     trace_impl_.reset(new gpu::gles2::GLES2TraceImplementation(
         context3d_->GetImplementation()));
   }
 
@@ skipping 81 matching lines @@
 
 void ContextProviderCommandBuffer::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(lost_context_callback_.is_null() ||
          lost_context_callback.is_null());
   lost_context_callback_ = lost_context_callback;
 }
 
 }  // namespace content