aura: Attach lost context callback to the shared main thread context

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 389 matching lines @@
   // 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 (offscreen_compositor_contexts_.get())
     return offscreen_compositor_contexts_;
 
   offscreen_compositor_contexts_ = ContextProviderCommandBuffer::Create(
       GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
       "Compositor-Offscreen");
 
-  if (!offscreen_compositor_contexts_.get())
-    return NULL;
-
-  if (!ui::Compositor::WasInitializedWithThread()) {
-    offscreen_compositor_contexts_->SetLostContextCallback(base::Bind(
-        &GpuProcessTransportFactory::
-            OnLostMainThreadSharedContextInsideCallback,
-        callback_factory_.GetWeakPtr()));
-  }
-
   return offscreen_compositor_contexts_;
 }
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::SharedMainThreadContextProvider() {
   if (shared_main_thread_contexts_.get())
     return shared_main_thread_contexts_;
 
   if (ui::Compositor::WasInitializedWithThread()) {
     // In threaded compositing mode, we have to create our own context for the
     // main thread since the compositor's context will be bound to the
     // compositor thread.
     shared_main_thread_contexts_ = ContextProviderCommandBuffer::Create(
         GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
         "Offscreen-MainThread");
   } else {
     // In single threaded compositing mode, we can just reuse the compositor's
     // shared context.
     shared_main_thread_contexts_ =
         static_cast<ContextProviderCommandBuffer*>(
             OffscreenCompositorContextProvider().get());
   }
 
-  if (shared_main_thread_contexts_ &&
-      !shared_main_thread_contexts_->BindToCurrentThread())
-    shared_main_thread_contexts_ = NULL;
+  if (shared_main_thread_contexts_) {
+    shared_main_thread_contexts_->SetLostContextCallback(
+        base::Bind(&GpuProcessTransportFactory::
+                        OnLostMainThreadSharedContextInsideCallback,
+                   callback_factory_.GetWeakPtr()));
+    if (!shared_main_thread_contexts_->BindToCurrentThread())
+      shared_main_thread_contexts_ = NULL;
+  }
   return shared_main_thread_contexts_;
 }
 
 void GpuProcessTransportFactory::OnLostContext(ui::Compositor* compositor) {
   LOG(ERROR) << "Lost UI compositor context.";
   PerCompositorData* data = per_compositor_data_[compositor];
   DCHECK(data);
 
   // Prevent callbacks from other contexts in the same share group from
   // calling us again.
@@ skipping 80 matching lines @@
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_offscreen_compositor_contexts = NULL;
   lost_shared_main_thread_contexts  = NULL;
 }
 
 }  // namespace content