Collapse the initialize methods in WebGraphicsContext3DCommandBufferImpl

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>
@@ skipping 58 matching lines @@
          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);

[piman, 2016/05/02 20:45:17]

See buildbots. If we don't reset the lock on the CBPI, it needs to be held
during teardown.

[danakj, 2016/05/02 21:11:36]

Ah okay.. how about I set the lock to null, but avoid branching on
GetCommandBufferProxy() and just do this if we were previously bound. (moved
this into the block below and added a comment)

-
   if (lost_context_callback_proxy_) {
     // Disconnect lost callbacks during destruction.
     lost_context_callback_proxy_.reset();
   }
 }
 
 gpu::CommandBufferProxyImpl*
 ContextProviderCommandBuffer::GetCommandBufferProxy() {
   return context3d_->GetCommandBufferProxy();
 }
 
 bool ContextProviderCommandBuffer::BindToCurrentThread() {
   // This is called on the thread the context will be used.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
+  if (!context3d_)
+    return false;  // Already failed.
   if (lost_context_callback_proxy_)
-    return true;
+    return true;  // Already succeeded.
 
   // 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.
   {
     ContextProviderCommandBuffer* shared_context_provider = nullptr;
     gpu::CommandBufferProxyImpl* shared_command_buffer = nullptr;
     scoped_refptr<gpu::gles2::ShareGroup> share_group;
 
     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 (!context3d_->InitializeOnCurrentThread(
             memory_limits_, shared_command_buffer, std::move(share_group),
-            attributes_, context_type_))
+            attributes_, context_type_)) {
+      context3d_ = nullptr;
       return false;
+    }
 
     // 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.
     // We intentionally call this *after* creating the command buffer via the
     // GpuChannelHost. Once that has happened, the service knows we are in the
     // share group and if a shared context is lost, our context will be informed
     // also, and the lost context callback will occur for the owner of the
     // context provider. If we check sooner, the shared context may be lost in
     // between these two states and our context here would be left in an orphan
     // share group.
-    if (share_group && share_group->IsLost())
+    if (share_group && share_group->IsLost()) {
+      context3d_ = nullptr;
       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.
@@ skipping 18 matching lines @@
   DCHECK(context3d_);
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (trace_impl_)
     return trace_impl_.get();
   return context3d_->GetImplementation();
 }
 
 gpu::ContextSupport* ContextProviderCommandBuffer::ContextSupport() {
-  return context3d_->GetContextSupport();
+  return context3d_->GetImplementation();
 }
 
 class GrContext* ContextProviderCommandBuffer::GrContext() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (gr_context_)
     return gr_context_->get();
 
   gr_context_.reset(new skia_bindings::GrContextForGLES2Interface(ContextGL()));
 
   // If GlContext is already lost, also abandon the new GrContext.
   if (gr_context_->get() &&
       ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
     gr_context_->get()->abandonContext();
 
   return gr_context_->get();
 }
 
 void ContextProviderCommandBuffer::InvalidateGrContext(uint32_t state) {
   if (gr_context_) {
     DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
     DCHECK(context_thread_checker_.CalledOnValidThread());
     gr_context_->ResetContext(state);
   }
 }
 
 void ContextProviderCommandBuffer::SetupLock() {
-  DCHECK(context3d_);
+  DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
+  DCHECK(context_thread_checker_.CalledOnValidThread());
   context3d_->GetCommandBufferProxy()->SetLock(&context_lock_);
 }
 
 base::Lock* ContextProviderCommandBuffer::GetLock() {
   return &context_lock_;
 }
 
 gpu::Capabilities ContextProviderCommandBuffer::ContextCapabilities() {
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
   DCHECK(context_thread_checker_.CalledOnValidThread());
@@ skipping 23 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