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"
@@ skipping 18 matching lines @@
 #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"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_setup.h"
 #include "ui/compositor/test_web_graphics_context_3d.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
+#include "webkit/gpu/grcontext_for_webgraphicscontext3d.h"
 
 #if defined(OS_WIN)
 #include "ui/surface/accelerated_surface_win.h"
 #endif
 
 namespace content {
 namespace {
 
 ImageTransportFactory* g_factory;
 
@@ skipping 367 matching lines @@
   }
 
   virtual ui::ContextFactory* AsContextFactory() OVERRIDE {
     return this;
   }
 
   virtual gfx::GLSurfaceHandle CreateSharedSurfaceHandle() OVERRIDE {
     CreateSharedContextLazy();
     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 =
+        shared_context_main_thread_->GetGPUProcessID();
+    handle.parent_client_id = shared_context_main_thread_->GetChannelID();
 
     return handle;
   }
 
   virtual void DestroySharedSurfaceHandle(
       gfx::GLSurfaceHandle surface) OVERRIDE {
   }
 
   virtual scoped_refptr<ui::Texture> CreateTransportClient(
       float device_scale_factor) OVERRIDE {
-    if (!shared_context_.get())
+    if (!shared_context_main_thread_.get())
         return NULL;
     scoped_refptr<ImageTransportClientTexture> image(
-        new ImageTransportClientTexture(shared_context_.get(),
+        new ImageTransportClientTexture(shared_context_main_thread_.get(),
                                         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())
+    if (!shared_context_main_thread_.get())
         return NULL;
-    scoped_refptr<OwnedTexture> image(
-        new OwnedTexture(shared_context_.get(), size, device_scale_factor,
-                         texture_id));
+    scoped_refptr<OwnedTexture> image(new OwnedTexture(
+        shared_context_main_thread_.get(),
+        size,
+        device_scale_factor,
+        texture_id));
     return image;
   }
 
   virtual GLHelper* GetGLHelper() OVERRIDE {
     if (!gl_helper_.get()) {
       CreateSharedContextLazy();
       WebKit::WebGraphicsContext3D* context_for_thread =
           CreateOffscreenContext();
       if (!context_for_thread)
         return NULL;
-      gl_helper_.reset(new GLHelper(shared_context_.get(),
+      gl_helper_.reset(new GLHelper(shared_context_main_thread_.get(),
                                     context_for_thread));
     }
     return gl_helper_.get();
   }
 
   virtual uint32 InsertSyncPoint() OVERRIDE {
-    if (!shared_context_.get())
+    if (!shared_context_main_thread_.get())
       return 0;
-    return shared_context_->insertSyncPoint();
+    return shared_context_main_thread_->insertSyncPoint();
   }
 
   virtual void AddObserver(ImageTransportFactoryObserver* observer) OVERRIDE {
     observer_list_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(
       ImageTransportFactoryObserver* observer) OVERRIDE {
     observer_list_.RemoveObserver(observer);
   }
 
-  // WebGraphicsContextLostCallback implementation, called for the shared
-  // context.
+  // WebGraphicsContextLostCallback implementation, called for the main thread
+  // shared context.
   virtual void onContextLost() {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&GpuProcessTransportFactory::OnLostSharedContext,
+        base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
                    callback_factory_.GetWeakPtr()));
   }
 
   void 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 52 matching lines @@
             factory,
             swap_client));
     if (!context->Initialize(
         attrs,
         false,
         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
       return NULL;
     return context.release();
   }
 
+  virtual WebKit::WebGraphicsContext3D* OffscreenContextForMainThread()
+      OVERRIDE {
+    CreateSharedContextLazy();
+    return shared_context_main_thread_.get();
+  }
+
+  virtual WebKit::WebGraphicsContext3D* OffscreenContextForCompositorThread()
+      OVERRIDE {
+    if (shared_context_compositor_thread_)
+      return shared_context_compositor_thread_.get();
+
+    // This context is for another thread. Do not MakeCurrent on this thread,
+    // and any callbacks will not be run on this thread.
+    shared_context_compositor_thread_.reset(CreateOffscreenContext());
+    return shared_context_compositor_thread_.get();
+  }
+
+  class MemoryCallbackProxy :
+      public WebKit::WebGraphicsContext3D::
+          WebGraphicsMemoryAllocationChangedCallbackCHROMIUM {
+   public:
+    MemoryCallbackProxy(
+        WebKit::WebGraphicsContext3D* context3d,
+        webkit::gpu::GrContextForWebGraphicsContext3D* gr_context)
+        : context3d_(context3d),
+          gr_context_(gr_context) {
+      context3d_->setMemoryAllocationChangedCallbackCHROMIUM(this);
+    }
+    virtual ~MemoryCallbackProxy() {
+      context3d_->setMemoryAllocationChangedCallbackCHROMIUM(NULL);
+    }
+
+   private:
+    // WebGraphicsMemoryAllocationChangedCallbackCHROMIUM implementation.
+    virtual void onMemoryAllocationChanged(
+        WebKit::WebGraphicsMemoryAllocation allocation) {
+      gr_context_->SetMemoryLimit(!!allocation.gpuResourceSizeInBytes);
+    }
+
+    WebKit::WebGraphicsContext3D* context3d_;
+    webkit::gpu::GrContextForWebGraphicsContext3D* gr_context_;
+  };
+
+  virtual GrContext* OffscreenGrContextForMainThread() OVERRIDE {
+    if (!grcontext_main_thread_ && shared_context_main_thread_) {
+      grcontext_main_thread_.reset(
+          new webkit::gpu::GrContextForWebGraphicsContext3D(
+              shared_context_main_thread_.get()));
+      memory_callback_proxy_main_thread_.reset(new MemoryCallbackProxy(
+          shared_context_main_thread_.get(), grcontext_main_thread_.get()));
+    }
+    return grcontext_main_thread_->gr_context();
+  }
+
+  virtual GrContext* OffscreenGrContextForCompositorThread()
+      OVERRIDE {
+    if (!grcontext_compositor_thread_ && shared_context_compositor_thread_) {
+      grcontext_compositor_thread_.reset(
+          new webkit::gpu::GrContextForWebGraphicsContext3D(
+              shared_context_compositor_thread_.get()));
+      memory_callback_proxy_compositor_thread_.reset(new MemoryCallbackProxy(

[piman, 2013/02/13 19:13:31]

So, this is called on the main thread, but the MemoryCallbackProxy will do
context calls in the constructor/destructor (without making the context
current). That's racy for several reasons (among others, the
setMemoryAllocationChangedCallbackCHROMIUM may end up as a noop)...

I'm not sure how to solve that well, what a mess!

In the current WebKit implementation, the create() happens on the main thread,
but the get(), which lazily creates the gr context, happens on the compositor
thread - hence why it works there (FTM the pattern in
getOrCreateContextForImplThread isn't thread safe, but who's counting.).


The closest would be to have a separate Create*ForCompositorThread (on LTHC) and
a Get*ForCompositorThread called from the impl thread. Where that call belongs
isn't clear... It could be LTHC with big red letters saying "called on impl
thread", but that feels wrong. It could be OutputSurface, I don't like the scope
creep, but short of introducing another class (LTHIClient) I don't have anything
better. 

+          shared_context_compositor_thread_.get(),
+          grcontext_compositor_thread_.get()));
+    }
+    return grcontext_compositor_thread_->gr_context();
+  }
+
+  virtual void DestroyOffscreenContext3dForCompositorThread() OVERRIDE {
+    memory_callback_proxy_compositor_thread_.reset();
+    grcontext_compositor_thread_.reset();
+    shared_context_compositor_thread_.reset();
+  }
+
   void CreateSharedContextLazy() {
-    if (shared_context_.get())
+    if (shared_context_main_thread_.get())
       return;
 
-    shared_context_.reset(CreateOffscreenContext());
-    if (!shared_context_.get()) {
+    shared_context_main_thread_.reset(CreateOffscreenContext());
+    if (!shared_context_main_thread_.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 (!shared_context_main_thread_->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);
+    shared_context_main_thread_->setContextLostCallback(this);
   }
 
-  void OnLostSharedContext() {
+  void OnLostMainThreadSharedContext() {
+    memory_callback_proxy_main_thread_.reset();
+    grcontext_main_thread_.reset();
+
     // 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<WebGraphicsContext3DCommandBufferImpl>
+        old_shared_context_main_thread(shared_context_main_thread_.release());
     scoped_ptr<GLHelper> old_helper(gl_helper_.release());
 
     FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
         observer_list_,
         OnLostResources());
   }
 
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
   PerCompositorDataMap per_compositor_data_;
-  scoped_ptr<WebGraphicsContext3DCommandBufferImpl> shared_context_;
+  scoped_ptr<WebGraphicsContext3DCommandBufferImpl> shared_context_main_thread_;
+  scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
+      shared_context_compositor_thread_;
+  scoped_ptr<webkit::gpu::GrContextForWebGraphicsContext3D>
+      grcontext_main_thread_;
+  scoped_ptr<webkit::gpu::GrContextForWebGraphicsContext3D>
+      grcontext_compositor_thread_;
+  scoped_ptr<MemoryCallbackProxy> memory_callback_proxy_main_thread_;
+  scoped_ptr<MemoryCallbackProxy> memory_callback_proxy_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_);
@@ skipping 31 matching lines @@
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }
 
 }  // namespace content