aura: Fix raciness in context loss and recreation.

content/browser/aura/gpu_process_transport_factory.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/browser/aura/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 56 matching lines @@
     return texture_id_;
   }
 
   virtual WebKit::WebGraphicsContext3D* HostContext3D() OVERRIDE {
     return host_context_;
   }
 
   // ImageTransportFactory overrides:
   virtual void OnLostResources() OVERRIDE {
     DeleteTexture();
+    host_context_ = NULL;
   }
 
  protected:
   virtual ~OwnedTexture() {
     ImageTransportFactory::GetInstance()->RemoveObserver(this);
     DeleteTexture();
   }
 
  protected:
   void DeleteTexture() {
     if (texture_id_) {
       host_context_->deleteTexture(texture_id_);
       texture_id_ = 0;
     }
   }
 
-  // A raw pointer. This |ImageTransportClientTexture| will be destroyed
-  // before the |host_context_| via
-  // |ImageTransportFactoryObserver::OnLostContext()| handlers.
+  // The OnLostResources() callback will happen before this context
+  // pointer is destroyed.
   WebKit::WebGraphicsContext3D* host_context_;
   unsigned texture_id_;
 
   DISALLOW_COPY_AND_ASSIGN(OwnedTexture);
 };
 
 class ImageTransportClientTexture : public OwnedTexture {
  public:
   ImageTransportClientTexture(
       WebKit::WebGraphicsContext3D* host_context,
@@ skipping 274 matching lines @@
   observer_list_.AddObserver(observer);
 }
 
 void GpuProcessTransportFactory::RemoveObserver(
     ImageTransportFactoryObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::OffscreenContextProviderForMainThread() {
-  if (!shared_contexts_main_thread_.get() ||
-      shared_contexts_main_thread_->DestroyedOnMainThread()) {
+  // Don't check for DestroyedOnMainThread() here. We hear about context
+  // loss for this context through the lost context callback. If the context
+  // is lost, we want to leave this ContextProvider available until the lost
+  // context notification is sent to the ImageTransportFactoryObserver clients.
+  if (!shared_contexts_main_thread_.get()) {
     shared_contexts_main_thread_ = ContextProviderCommandBuffer::Create(
         GpuProcessTransportFactory::CreateOffscreenCommandBufferContext());
     if (shared_contexts_main_thread_) {
       shared_contexts_main_thread_->SetLostContextCallback(base::Bind(
           &GpuProcessTransportFactory::
               OnLostMainThreadSharedContextInsideCallback,
           callback_factory_.GetWeakPtr()));
 
       if (!shared_contexts_main_thread_->BindToCurrentThread())
         shared_contexts_main_thread_ = NULL;
     }
   }
   return shared_contexts_main_thread_;
 }
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::OffscreenContextProviderForCompositorThread() {
-  if (!shared_contexts_compositor_thread_.get() ||
-      shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
+  // The lifetime of this context is tied to the main thread context so that
+  // they are always in the same share group. So do not check for
+  // DestroyedOnMainThread().
+  if (!shared_contexts_compositor_thread_.get()) {
     shared_contexts_compositor_thread_ = ContextProviderCommandBuffer::Create(
         GpuProcessTransportFactory::CreateOffscreenCommandBufferContext());
   }
   return shared_contexts_compositor_thread_;
 }
 
 void GpuProcessTransportFactory::OnLostContext(ui::Compositor* compositor) {
   LOG(ERROR) << "Lost UI compositor context.";
   PerCompositorData* data = per_compositor_data_[compositor];
   DCHECK(data);
@@ skipping 65 matching lines @@
 
 void GpuProcessTransportFactory::OnLostMainThreadSharedContextInsideCallback() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
                  callback_factory_.GetWeakPtr()));
 }
 
 void GpuProcessTransportFactory::OnLostMainThreadSharedContext() {
   LOG(ERROR) << "Lost UI shared context.";
+
   // Keep old resources around while we call the observers, but ensure that
   // new resources are created if needed.
+  // Kill shared contexts for both threads in tandom so they are always in

[piman, 2013/08/22 01:14:48]

nit: s/tandom/tandem/

[danakj, 2013/08/22 01:18:04]

Done.

+  // the same share group.
 
-  scoped_refptr<ContextProviderCommandBuffer> old_contexts_main_thread =
+  scoped_refptr<cc::ContextProvider> lost_shared_contexts_main_thread =
       shared_contexts_main_thread_;
+  scoped_refptr<cc::ContextProvider> lost_shared_contexts_compositor_thread =
+      shared_contexts_compositor_thread_;
   shared_contexts_main_thread_ = NULL;
+  shared_contexts_compositor_thread_ = NULL;
 
-  scoped_ptr<GLHelper> old_helper(gl_helper_.release());
+  scoped_ptr<GLHelper> lost_gl_helper = gl_helper_.Pass();
 
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
+
+  // Kill things that use the shared context before killing the shared context.
+  lost_gl_helper.reset();
+  lost_shared_contexts_main_thread = NULL;
+  lost_shared_contexts_compositor_thread = NULL;
 }
 
 }  // namespace content