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

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
+#include "cc/context_provider.h"
 #include "cc/input_handler.h"
 #include "cc/layer.h"
 #include "cc/layer_tree_host.h"
 #include "cc/output_surface.h"
 #include "cc/thread_impl.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/test_web_graphics_context_3d.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
+#include "webkit/gpu/grcontext_for_webgraphicscontext3d.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/chromeos/chromeos_version.h"
 #endif
 
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 100.0;
@@ skipping 22 matching lines @@
  private:
   friend class ui::PostedSwapQueue;
 
   SwapType type_;
   bool posted_;
   ui::PostedSwapQueue* posted_swaps_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingSwap);
 };
 
+class NullContextProvider : public cc::ContextProvider {
+ public:
+  virtual bool InitializeOnMainThread() OVERRIDE { return false; }
+  virtual bool BindToCurrentThread() OVERRIDE { return false; }
+  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE { return NULL; }
+  virtual class GrContext* GrContext() OVERRIDE { return NULL; }
+  virtual void VerifyContexts() OVERRIDE {}
+
+ protected:
+  virtual ~NullContextProvider() {}
+};
+
+struct MainThreadNullContextProvider {
+  scoped_refptr<NullContextProvider> provider;
+
+  static MainThreadNullContextProvider* GetInstance() {
+    return Singleton<MainThreadNullContextProvider>::get();
+  }
+};
+
+struct CompositorThreadNullContextProvider {
+  scoped_refptr<NullContextProvider> provider;
+
+  static CompositorThreadNullContextProvider* GetInstance() {
+    return Singleton<CompositorThreadNullContextProvider>::get();
+  }
+};
+
 }  // namespace
 
 namespace ui {
 
 // static
 ContextFactory* ContextFactory::GetInstance() {
   // We leak the shared resources so that we don't race with
   // the tear down of the gl_bindings.
   if (!g_context_factory) {
     DVLOG(1) << "Using DefaultSharedResource";
@@ skipping 32 matching lines @@
 cc::OutputSurface* DefaultContextFactory::CreateOutputSurface(
     Compositor* compositor) {
   return new cc::OutputSurface(
       make_scoped_ptr(CreateContextCommon(compositor, false)));
 }
 
 WebKit::WebGraphicsContext3D* DefaultContextFactory::CreateOffscreenContext() {
   return CreateContextCommon(NULL, true);
 }
 
+class DefaultContextFactory::DefaultContextProvider
+    : public cc::ContextProvider {
+ public:
+  DefaultContextProvider(ContextFactory* factory)
+      : factory_(factory),
+        destroyed_(false) {}
+
+  virtual bool InitializeOnMainThread() OVERRIDE {
+    context3d_.reset(factory_->CreateOffscreenContext());
+    return !!context3d_;
+  }
+
+  virtual bool BindToCurrentThread() {
+    return context3d_->makeContextCurrent();
+  }
+
+  virtual WebKit::WebGraphicsContext3D* Context3d() { return context3d_.get(); }
+
+  virtual class GrContext* GrContext() {
+    if (!gr_context_) {
+      gr_context_.reset(
+          new webkit::gpu::GrContextForWebGraphicsContext3D(context3d_.get()));
+    }
+    return gr_context_->get();
+  }
+
+  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 ~DefaultContextProvider() {}
+
+ private:
+  ContextFactory* factory_;
+  base::Lock destroyed_lock_;
+  bool destroyed_;
+  scoped_ptr<WebKit::WebGraphicsContext3D> context3d_;
+  scoped_ptr<webkit::gpu::GrContextForWebGraphicsContext3D> gr_context_;
+};
+
+scoped_refptr<cc::ContextProvider>
+DefaultContextFactory::OffscreenContextProviderForMainThread() {
+  if (!offscreen_contexts_main_thread_ ||
+      !offscreen_contexts_main_thread_->DestroyedOnMainThread()) {
+    offscreen_contexts_main_thread_ = new DefaultContextProvider(this);
+  }
+  return offscreen_contexts_main_thread_;
+}
+
+scoped_refptr<cc::ContextProvider>
+DefaultContextFactory::OffscreenContextProviderForCompositorThread() {
+  if (!offscreen_contexts_compositor_thread_ ||
+      !offscreen_contexts_compositor_thread_->DestroyedOnMainThread()) {
+    offscreen_contexts_compositor_thread_ = new DefaultContextProvider(this);
+  }
+  return offscreen_contexts_compositor_thread_;
+}
+
 void DefaultContextFactory::RemoveCompositor(Compositor* compositor) {
 }
 
 WebKit::WebGraphicsContext3D* DefaultContextFactory::CreateContextCommon(
     Compositor* compositor,
     bool offscreen) {
   DCHECK(offscreen || compositor);
   WebKit::WebGraphicsContext3D::Attributes attrs;
   attrs.depth = false;
   attrs.stencil = false;
@@ skipping 376 matching lines @@
 void Compositor::didCompleteSwapBuffers() {
   DCHECK(g_compositor_thread);
   NotifyEnd();
 }
 
 void Compositor::scheduleComposite() {
   if (!disable_schedule_composite_)
     ScheduleDraw();
 }
 
+scoped_refptr<cc::ContextProvider>
+Compositor::OffscreenContextProviderForMainThread() {
+  if (g_test_compositor_enabled) {
+    if (!MainThreadNullContextProvider::GetInstance()->provider) {
+      MainThreadNullContextProvider::GetInstance()->provider =
+          new NullContextProvider;
+    }
+    return MainThreadNullContextProvider::GetInstance()->provider;
+  }
+  return ContextFactory::GetInstance()->OffscreenContextProviderForMainThread();
+}
+
+scoped_refptr<cc::ContextProvider>
+Compositor::OffscreenContextProviderForCompositorThread() {
+  if (g_test_compositor_enabled) {
+    if (!CompositorThreadNullContextProvider::GetInstance()->provider) {
+      CompositorThreadNullContextProvider::GetInstance()->provider =
+          new NullContextProvider;
+    }
+    return CompositorThreadNullContextProvider::GetInstance()->provider;
+  }
+  return ContextFactory::GetInstance()->
+      OffscreenContextProviderForCompositorThread();
+}
+
 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
   if (!compositor_lock_) {
     compositor_lock_ = new CompositorLock(this);
     if (g_compositor_thread)
       host_->setDeferCommits(true);
     FOR_EACH_OBSERVER(CompositorObserver,
                       observer_list_,
                       OnCompositingLockStateChanged(this));
   }
   return compositor_lock_;
@@ skipping 36 matching lines @@
 
 COMPOSITOR_EXPORT void DisableTestCompositor() {
   g_test_compositor_enabled = false;
 }
 
 COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
   return g_test_compositor_enabled;
 }
 
 }  // namespace ui