cc: Route offscreen context creation for compositor to the browser.

content/browser/renderer_host/image_transport_factory.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/browser/renderer_host/image_transport_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "cc/output_surface.h"
 #include "cc/output_surface_client.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
+#include "content/common/gpu/client/offscreen_context.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/webkitplatformsupport_impl.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/ipc/command_buffer_proxy.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
@@ skipping 183 matching lines @@
 
   virtual void OnViewContextSwapBuffersComplete() OVERRIDE {
     compositor_->OnSwapBuffersComplete();
   }
 
   virtual void OnViewContextSwapBuffersAborted() OVERRIDE {
     // Recreating contexts directly from here causes issues, so post a task
     // instead.
     // TODO(piman): Fix the underlying issues.
     MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(&CompositorSwapClient::OnLostContext, this->AsWeakPtr()));
+        base::Bind(&CompositorSwapClient::OnLostSwapContext,
+                   this->AsWeakPtr()));
   }
 
  private:
-  void OnLostContext();
+  void OnLostSwapContext();
   ui::Compositor* compositor_;
   GpuProcessTransportFactory* factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorSwapClient);
 };
 
 class BrowserCompositorOutputSurface;
 
 // Directs vsync updates to the appropriate BrowserCompositorOutputSurface.
 class BrowserCompositorOutputSurfaceProxy
@@ skipping 119 matching lines @@
 
 void BrowserCompositorOutputSurfaceProxy::OnUpdateVSyncParameters(
     int surface_id, base::TimeTicks timebase, base::TimeDelta interval) {
   BrowserCompositorOutputSurface* surface = surface_map_.Lookup(surface_id);
   if (surface)
     surface->OnUpdateVSyncParameters(timebase, interval);
 }
 
 class GpuProcessTransportFactory
     : public ui::ContextFactory,
-      public ImageTransportFactory,
-      public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback {
+      public OffscreenContextClient,
+      public ImageTransportFactory {
  public:
   GpuProcessTransportFactory()
-      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
+      : shared_context_main_thread_(this),
+        shared_context_compositor_thread_(this),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
     output_surface_proxy_ = new BrowserCompositorOutputSurfaceProxy();
   }
 
   virtual ~GpuProcessTransportFactory() {
     DCHECK(per_compositor_data_.empty());
   }
 
   virtual WebGraphicsContext3DCommandBufferImpl* CreateOffscreenContext()
       OVERRIDE {
     base::WeakPtr<WebGraphicsContext3DSwapBuffersClient> swap_client;
     return CreateContextCommon(swap_client, 0);
   }
 
   virtual cc::OutputSurface* CreateOutputSurface(
       ui::Compositor* compositor) OVERRIDE {
     PerCompositorData* data = per_compositor_data_[compositor];
     if (!data)
       data = CreatePerCompositorData(compositor);
     WebGraphicsContext3DCommandBufferImpl* context =
         CreateContextCommon(data->swap_client->AsWeakPtr(),
                             data->surface_id);
     return new BrowserCompositorOutputSurface(
         context,
         per_compositor_data_[compositor]->surface_id,
         output_surface_proxy_);
   }
 
+  virtual WebKit::WebGraphicsContext3D* OffscreenContextForMainThread()
+      OVERRIDE {
+    return shared_context_main_thread_.Context3d();
+  }
+
+  virtual WebKit::WebGraphicsContext3D*
+      OffscreenContextForCompositorThread() OVERRIDE {
+    return shared_context_compositor_thread_.Context3d();
+  }
+
+  virtual GrContext* OffscreenGrContextForMainThread() OVERRIDE {
+    return shared_context_main_thread_.GrContext();
+  }
+
+  virtual GrContext* OffscreenGrContextForCompositorThread() OVERRIDE {
+    return shared_context_compositor_thread_.GrContext();
+  }
+
   virtual void RemoveCompositor(ui::Compositor* compositor) OVERRIDE {
     PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
     if (it == per_compositor_data_.end())
       return;
     PerCompositorData* data = it->second;
     DCHECK(data);
     GpuSurfaceTracker::Get()->RemoveSurface(data->surface_id);
     delete data;
     per_compositor_data_.erase(it);
     if (per_compositor_data_.empty()) {
       gl_helper_.reset();
       callback_factory_.InvalidateWeakPtrs();
     }
   }
 
   virtual ui::ContextFactory* AsContextFactory() OVERRIDE {
     return this;
   }
 
   virtual gfx::GLSurfaceHandle CreateSharedSurfaceHandle() OVERRIDE {
-    CreateSharedContextLazy();
+    // This class always creates offscreen contests of this type.
+    WebGraphicsContext3DCommandBufferImpl* context3d =
+        static_cast<WebGraphicsContext3DCommandBufferImpl*>(
+            shared_context_main_thread_.Context3d());
+
     gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
         gfx::kNullPluginWindow, true);
-    handle.parent_gpu_process_id = shared_context_->GetGPUProcessID();
-    handle.parent_client_id = shared_context_->GetChannelID();
-
+    handle.parent_gpu_process_id = context3d->GetGPUProcessID();
+    handle.parent_client_id = context3d->GetChannelID();
     return handle;
   }
 
   virtual void DestroySharedSurfaceHandle(
       gfx::GLSurfaceHandle surface) OVERRIDE {
   }
 
   virtual scoped_refptr<ui::Texture> CreateTransportClient(
       float device_scale_factor) {
-    if (!shared_context_.get())
+    if (!shared_context_main_thread_.Context3d())
         return NULL;
     scoped_refptr<ImageTransportClientTexture> image(
-        new ImageTransportClientTexture(shared_context_.get(),
-                                        device_scale_factor));
+        new ImageTransportClientTexture(
+            shared_context_main_thread_.Context3d(),
+            device_scale_factor));
     return image;
   }
 
   virtual scoped_refptr<ui::Texture> CreateOwnedTexture(
       const gfx::Size& size,
       float device_scale_factor,
       unsigned int texture_id) OVERRIDE {
-    if (!shared_context_.get())
-        return NULL;
-    scoped_refptr<OwnedTexture> image(
-        new OwnedTexture(shared_context_.get(), size, device_scale_factor,
-                         texture_id));
+    if (!shared_context_main_thread_.Context3d())
+      return NULL;
+    scoped_refptr<OwnedTexture> image(new OwnedTexture(
+        shared_context_main_thread_.Context3d(),
+        size,
+        device_scale_factor,
+        texture_id));
     return image;
   }
 
   virtual GLHelper* GetGLHelper() {
     if (!gl_helper_.get()) {
-      CreateSharedContextLazy();
-      WebKit::WebGraphicsContext3D* context_for_thread =
+      WebKit::WebGraphicsContext3D* main_thread_context =
+          shared_context_main_thread_.Context3d();
+      if (!main_thread_context)
+        return NULL;
+      WebGraphicsContext3DCommandBufferImpl* helper_thread_context =
           CreateOffscreenContext();
-      if (!context_for_thread)
+      if (!helper_thread_context)
         return NULL;
-      gl_helper_.reset(new GLHelper(shared_context_.get(),
-                                    context_for_thread));
+      gl_helper_.reset(new GLHelper(main_thread_context,
+                                    helper_thread_context));
     }
     return gl_helper_.get();
   }
 
   virtual uint32 InsertSyncPoint() OVERRIDE {
-    if (!shared_context_.get())
+    if (!shared_context_main_thread_.Context3d())
       return 0;
-    return shared_context_->insertSyncPoint();
+    return shared_context_main_thread_.Context3d()->
+        insertSyncPoint();
   }
 
   virtual void AddObserver(ImageTransportFactoryObserver* observer) {
     observer_list_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(ImageTransportFactoryObserver* observer) {
     observer_list_.RemoveObserver(observer);
   }
 
-  // WebGraphicsContextLostCallback implementation, called for the shared
-  // context.
-  virtual void onContextLost() {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&GpuProcessTransportFactory::OnLostSharedContext,
-                   callback_factory_.GetWeakPtr()));
+  // OffscreenContextClient implementation.
+  virtual void DidCreateContext(OffscreenContext* offscreen_context,
+                                bool success) OVERRIDE {
+    if (success)
+      return;
+    if (offscreen_context == &shared_context_main_thread_) {
+      // If we can't recreate contexts, we won't be able to show the UI. Better
+      // crash at this point.
+      LOG(FATAL) << "Failed to initialize UI shared main thread context.";
+    }
   }
 
-  void OnLostContext(ui::Compositor* compositor) {
+  // OffscreenContextClient implementation.
+  virtual void DidLoseContext(OffscreenContext* offscreen_context)
+      OVERRIDE {
+    if (offscreen_context == &shared_context_main_thread_) {
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
+                     callback_factory_.GetWeakPtr()));
+    }
+  }
+
+  void OnLostSwapContext(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.
     data->swap_client.reset(new CompositorSwapClient(compositor, this));
     compositor->OnSwapBuffersAborted();
   }
 
  private:
   struct PerCompositorData {
     int surface_id;
     scoped_ptr<CompositorSwapClient> swap_client;
 #if defined(OS_WIN)
     scoped_ptr<AcceleratedSurface> accelerated_surface;
 #endif
   };
 
   PerCompositorData* CreatePerCompositorData(ui::Compositor* compositor) {
     DCHECK(!per_compositor_data_[compositor]);
 
-    CreateSharedContextLazy();
-
     gfx::AcceleratedWidget widget = compositor->widget();
     GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 
     PerCompositorData* data = new PerCompositorData;
     data->surface_id = tracker->AddSurfaceForNativeWidget(widget);
     data->swap_client.reset(new CompositorSwapClient(compositor, this));
 #if defined(OS_WIN)
     if (GpuDataManagerImpl::GetInstance()->IsUsingAcceleratedSurface())
       data->accelerated_surface.reset(new AcceleratedSurface(widget));
 #endif
@@ skipping 24 matching lines @@
             factory,
             swap_client));
     if (!context->Initialize(
         attrs,
         false,
         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
       return NULL;
     return context.release();
   }
 
-  void CreateSharedContextLazy() {
-    if (shared_context_.get())
-      return;
-
-    shared_context_.reset(CreateOffscreenContext());
-    if (!shared_context_.get()) {
-      // If we can't recreate contexts, we won't be able to show the UI. Better
-      // crash at this point.
-      LOG(FATAL) << "Failed to initialize UI shared context.";
-    }
-    if (!shared_context_->makeContextCurrent()) {
-      // If we can't recreate contexts, we won't be able to show the UI. Better
-      // crash at this point.
-      LOG(FATAL) << "Failed to make UI shared context current.";
-    }
-    shared_context_->setContextLostCallback(this);
-  }
-
-  void OnLostSharedContext() {
-    // Keep old resources around while we call the observers, but ensure that
-    // new resources are created if needed.
-    scoped_ptr<WebGraphicsContext3DCommandBufferImpl> old_shared_context(
-        shared_context_.release());
-    scoped_ptr<GLHelper> old_helper(gl_helper_.release());
-
+  void OnLostMainThreadSharedContext() {

[piman, 2013/02/11 18:45:33]

Mmh, there was code here to keep alive the context and the GLHelper while we
call the observers, but resetting them so that if the OnLostResources callback
tries to access it (I'm pretty sure it does), it would recreate it.
I'm not sure how that behavior is kept, at the very least, I don't see what
resets the GLHelper.

[danakj, 2013/02/11 18:58:13]

Hm, ya I lost the GLHelper thing. I kept the resource-holding logic but it moved
to the OffscreenContext class, and since this is called via a post task, then it
doesn't do the same thing anymore. So, questions:

1) Why do we hold onto the WGC3D here? Tests don't see to depend on it.
2) Why do we call the observers on a post-task instead of in the lost-context
callback directly?

     FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
         observer_list_,
         OnLostResources());
   }
 
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
   PerCompositorDataMap per_compositor_data_;
-  scoped_ptr<WebGraphicsContext3DCommandBufferImpl> shared_context_;
+  OffscreenContext shared_context_main_thread_;
+  OffscreenContext shared_context_compositor_thread_;
   scoped_ptr<GLHelper> gl_helper_;
   ObserverList<ImageTransportFactoryObserver> observer_list_;
   base::WeakPtrFactory<GpuProcessTransportFactory> callback_factory_;
   scoped_refptr<BrowserCompositorOutputSurfaceProxy> output_surface_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuProcessTransportFactory);
 };
 
-void CompositorSwapClient::OnLostContext() {
-  factory_->OnLostContext(compositor_);
+void CompositorSwapClient::OnLostSwapContext() {
+  factory_->OnLostSwapContext(compositor_);
   // Note: previous line destroyed this. Don't access members from now on.
 }
 
 WebKit::WebGraphicsContext3D* CreateTestContext() {
   ui::TestWebGraphicsContext3D* test_context =
       new ui::TestWebGraphicsContext3D();
   test_context->Initialize();
   return test_context;
 }
 
@@ skipping 21 matching lines @@
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }
 
 }  // namespace content