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

content/renderer/gpu/render_widget_compositor.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/renderer/gpu/render_widget_compositor.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
+#include "base/synchronization/lock.h"
 #include "base/time.h"
+#include "cc/context_provider.h"
 #include "cc/layer.h"
 #include "cc/layer_tree_debug_state.h"
 #include "cc/layer_tree_host.h"
 #include "cc/switches.h"
 #include "cc/thread_impl.h"
 #include "content/renderer/gpu/compositor_thread.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerTreeViewClient.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebSharedGraphicsContext3D.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/compositor_bindings/web_to_ccinput_handler_adapter.h"
 
 namespace cc {
 class Layer;
 }
 
 using WebKit::WebFloatPoint;
 using WebKit::WebSize;
@@ skipping 404 matching lines @@
 void RenderWidgetCompositor::didCompleteSwapBuffers() {
   widget_->didCompleteSwapBuffers();
 }
 
 // TODO(jamesr): This goes through WebViewImpl just to do suppression, refactor
 // that piece out.
 void RenderWidgetCompositor::scheduleComposite() {
   client_->scheduleComposite();
 }
 
+class RenderWidgetCompositor::MainThreadContextProvider
+    : public cc::ContextProvider {
+ public:
+  virtual bool InitializeOnMainThread() OVERRIDE { return true; }
+  virtual bool BindToCurrentThread() OVERRIDE { return true; }
+
+  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
+    return WebKit::WebSharedGraphicsContext3D::mainThreadContext();

[jamesr, 2013/02/22 19:11:40]

We also have WebKit::WebView::sharedGraphicsContext3D() that exposes the same
thing and that this class could get access to fairly easily.  We should remove
one of these or the other, someday.

[danakj, 2013/02/22 19:17:53]

Ohh, okay. Thanks for the heads up.

+  }
+  virtual class GrContext* GrContext() OVERRIDE {
+    return WebKit::WebSharedGraphicsContext3D::mainThreadGrContext();
+  }
+
+  virtual void VerifyContexts() OVERRIDE {}
+
+ protected:
+  virtual ~MainThreadContextProvider() {}
+};
+
+scoped_refptr<cc::ContextProvider>
+RenderWidgetCompositor::OffscreenContextProviderForMainThread() {
+  if (!contexts_main_thread_)
+    contexts_main_thread_ = new MainThreadContextProvider;
+  return contexts_main_thread_;
+}
+
+class RenderWidgetCompositor::CompositorThreadContextProvider
+    : public cc::ContextProvider {
+ public:
+  CompositorThreadContextProvider() : destroyed_(false) {}
+
+  virtual bool InitializeOnMainThread() OVERRIDE {
+    return WebKit::WebSharedGraphicsContext3D::createCompositorThreadContext();
+  }
+  virtual bool BindToCurrentThread() OVERRIDE {
+    return Context3d()->makeContextCurrent();
+  }
+
+  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
+    return WebKit::WebSharedGraphicsContext3D::compositorThreadContext();
+  }
+  virtual class GrContext* GrContext() OVERRIDE {
+    return WebKit::WebSharedGraphicsContext3D::compositorThreadGrContext();
+  }
+
+  virtual void VerifyContexts() OVERRIDE {
+    if (Context3d() && !Context3d()->isContextLost())
+      return;
+    base::AutoLock lock(destroyed_lock_);
+    destroyed_ = true;
+  }
+  bool DestroyedOnMainThread() {
+    base::AutoLock lock(destroyed_lock_);
+    return destroyed_;
+  }
+
+ protected:
+  virtual ~CompositorThreadContextProvider() {}
+
+ private:
+  base::Lock destroyed_lock_;
+  bool destroyed_;
+};
+
+scoped_refptr<cc::ContextProvider>
+RenderWidgetCompositor::OffscreenContextProviderForCompositorThread() {
+  if (!contexts_compositor_thread_ ||
+      contexts_compositor_thread_->DestroyedOnMainThread())
+    contexts_compositor_thread_ = new CompositorThreadContextProvider;
+  return contexts_compositor_thread_;
+}
+
 }  // namespace content