ui/compositor: move the browser compositor thread to the ContextFactory

Trying to get rid of more globals in ui/compositor.

BUG=None

Review URL: https://codereview.chromium.org/277713002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@269608 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/compositor/gpu_process_transport_factory.cc

@@ -11,6 +11,7 @@
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/threading/thread.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
@@ -62,6 +63,16 @@ GpuProcessTransportFactory::GpuProcessTransportFactory()
     : callback_factory_(this) {
   output_surface_proxy_ = new BrowserCompositorOutputSurfaceProxy(
       &output_surface_map_);
+#if defined(OS_CHROMEOS)
+  bool use_thread = !CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUIDisableThreadedCompositing);
+#else
+  bool use_thread = false;
+#endif
+  if (use_thread) {
+    compositor_thread_.reset(new base::Thread("Browser Compositor"));
+    compositor_thread_->Start();
+  }
 }
 
 GpuProcessTransportFactory::~GpuProcessTransportFactory() {
@@ -134,7 +145,7 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
   UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor", !!context_provider);
 
   if (!context_provider.get()) {
-    if (ui::Compositor::WasInitializedWithThread()) {
+    if (compositor_thread_.get()) {
       LOG(FATAL) << "Failed to create UI context, but can't use software"
                  " compositing with browser threaded compositing. Aborting.";
     }
@@ -150,7 +161,7 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
-      ui::Compositor::GetCompositorMessageLoop();
+      GetCompositorMessageLoop();
   if (!compositor_thread_task_runner.get())
     compositor_thread_task_runner = base::MessageLoopProxy::current();
 
@@ -178,8 +189,11 @@ scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
   PerCompositorData* data = per_compositor_data_[source];
   DCHECK(data);
 
-  data->reflector = new ReflectorImpl(
-      source, target, &output_surface_map_, data->surface_id);
+  data->reflector = new ReflectorImpl(source,
+                                      target,
+                                      &output_surface_map_,
+                                      GetCompositorMessageLoop(),
+                                      data->surface_id);
   return data->reflector;
 }
 
@@ -226,6 +240,12 @@ ui::ContextFactory* GpuProcessTransportFactory::GetContextFactory() {
   return this;
 }
 
+base::MessageLoopProxy* GpuProcessTransportFactory::GetCompositorMessageLoop() {
+  if (!compositor_thread_)
+    return NULL;
+  return compositor_thread_->message_loop_proxy();
+}
+
 gfx::GLSurfaceHandle GpuProcessTransportFactory::GetSharedSurfaceHandle() {
   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
       gfx::kNullPluginWindow, gfx::TEXTURE_TRANSPORT);

content/browser/compositor/gpu_process_transport_factory.h

@@ -15,6 +15,10 @@
 #include "content/browser/compositor/image_transport_factory.h"
 #include "ui/compositor/compositor.h"
 
+namespace base {
+class Thread;
+}
+
 namespace content {
 class BrowserCompositorOutputSurface;
 class BrowserCompositorOutputSurfaceProxy;
@@ -47,6 +51,7 @@ class GpuProcessTransportFactory
       SharedMainThreadContextProvider() OVERRIDE;
   virtual bool DoesCreateTestContexts() OVERRIDE;
   virtual cc::SharedBitmapManager* GetSharedBitmapManager() OVERRIDE;
+  virtual base::MessageLoopProxy* GetCompositorMessageLoop() OVERRIDE;
 
   // ImageTransportFactory implementation.
   virtual ui::ContextFactory* GetContextFactory() OVERRIDE;
@@ -67,6 +72,7 @@ class GpuProcessTransportFactory
   void OnLostMainThreadSharedContext();
 
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
+  scoped_ptr<base::Thread> compositor_thread_;
   PerCompositorDataMap per_compositor_data_;
   scoped_refptr<ContextProviderCommandBuffer> shared_main_thread_contexts_;
   scoped_ptr<GLHelper> gl_helper_;

content/browser/compositor/reflector_impl.cc

@@ -17,10 +17,11 @@ ReflectorImpl::ReflectorImpl(
     ui::Compositor* mirrored_compositor,
     ui::Layer* mirroring_layer,
     IDMap<BrowserCompositorOutputSurface>* output_surface_map,
+    base::MessageLoopProxy* compositor_thread_loop,
     int surface_id)
     : impl_unsafe_(output_surface_map),
       main_unsafe_(mirrored_compositor, mirroring_layer),
-      impl_message_loop_(ui::Compositor::GetCompositorMessageLoop()),
+      impl_message_loop_(compositor_thread_loop),
       main_message_loop_(base::MessageLoopProxy::current()),
       surface_id_(surface_id) {
   GLHelper* helper = ImageTransportFactory::GetInstance()->GetGLHelper();

content/browser/compositor/reflector_impl.h

@@ -37,6 +37,7 @@ class ReflectorImpl : public base::SupportsWeakPtr<ReflectorImpl>,
       ui::Compositor* mirrored_compositor,
       ui::Layer* mirroring_layer,
       IDMap<BrowserCompositorOutputSurface>* output_surface_map,
+      base::MessageLoopProxy* compositor_thread_loop,
       int surface_id);
 
   ui::Compositor* mirrored_compositor() {

content/browser/compositor/software_browser_compositor_output_surface_unittest.cc

@@ -91,7 +91,6 @@ SoftwareBrowserCompositorOutputSurfaceTest::
 void SoftwareBrowserCompositorOutputSurfaceTest::SetUp() {
   bool enable_pixel_output = false;
   ui::InitializeContextFactoryForTests(enable_pixel_output);
-  ui::Compositor::Initialize();
 
   compositor_.reset(new ui::Compositor(gfx::kNullAcceleratedWidget));
   surface_proxy_ =
@@ -106,7 +105,6 @@ void SoftwareBrowserCompositorOutputSurfaceTest::TearDown() {
 
   surface_map_.Clear();
   ui::TerminateContextFactoryForTests();
-  ui::Compositor::Terminate();
 }
 
 scoped_ptr<content::BrowserCompositorOutputSurface>

content/browser/compositor/software_output_device_ozone_unittest.cc

@@ -100,7 +100,6 @@ SoftwareOutputDeviceOzoneTest::~SoftwareOutputDeviceOzoneTest() {
 
 void SoftwareOutputDeviceOzoneTest::SetUp() {
   ui::InitializeContextFactoryForTests(enable_pixel_output_);
-  ui::Compositor::Initialize();
 
   surface_factory_.reset(new MockSurfaceFactoryOzone());
   gfx::SurfaceFactoryOzone::SetInstance(surface_factory_.get());
@@ -120,7 +119,6 @@ void SoftwareOutputDeviceOzoneTest::TearDown() {
   compositor_.reset();
   surface_factory_.reset();
   ui::TerminateContextFactoryForTests();
-  ui::Compositor::Terminate();
 }
 
 class SoftwareOutputDeviceOzonePixelTest

mojo/aura/context_factory_mojo.cc

@@ -63,4 +63,8 @@ cc::SharedBitmapManager* ContextFactoryMojo::GetSharedBitmapManager() {
   return NULL;
 }
 
+base::MessageLoopProxy* ContextFactoryMojo::GetCompositorMessageLoop() {
+  return NULL;
+}
+
 }  // namespace mojo

mojo/aura/context_factory_mojo.h

@@ -36,6 +36,7 @@ class ContextFactoryMojo : public ui::ContextFactory {
   virtual void RemoveCompositor(ui::Compositor* compositor) OVERRIDE;
   virtual bool DoesCreateTestContexts() OVERRIDE;
   virtual cc::SharedBitmapManager* GetSharedBitmapManager() OVERRIDE;
+  virtual base::MessageLoopProxy* GetCompositorMessageLoop() OVERRIDE;
 
  private:
   scoped_refptr<webkit::gpu::ContextProviderInProcess>

ui/aura/env.cc

@@ -6,7 +6,6 @@
 
 #include "ui/aura/env_observer.h"
 #include "ui/aura/input_state_lookup.h"
-#include "ui/compositor/compositor.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/events/platform/platform_event_source.h"
 
@@ -26,8 +25,6 @@ Env::Env()
 
 Env::~Env() {
   FOR_EACH_OBSERVER(EnvObserver, observers_, OnWillDestroyEnv());
-
-  ui::Compositor::Terminate();
 }
 
 //static
@@ -68,8 +65,6 @@ bool Env::IsMouseButtonDown() const {
 // Env, private:
 
 void Env::Init(bool create_event_source) {
-  ui::Compositor::Initialize();
-
   if (create_event_source && !ui::PlatformEventSource::GetInstance())
     event_source_ = ui::PlatformEventSource::CreateDefault();
 }

ui/compositor/compositor.cc

@@ -10,14 +10,10 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
-#include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
-#include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_restrictions.h"
 #include "cc/base/latency_info_swap_promise.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
@@ -39,9 +35,6 @@ namespace {
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 200.0;
 
-bool g_compositor_initialized = false;
-base::Thread* g_compositor_thread = NULL;
-
 ui::ContextFactory* g_context_factory = NULL;
 
 const int kCompositorLockTimeoutMs = 67;
@@ -92,6 +85,7 @@ namespace ui {
 Compositor::Compositor(gfx::AcceleratedWidget widget)
     : root_layer_(NULL),
       widget_(widget),
+      compositor_thread_loop_(g_context_factory->GetCompositorMessageLoop()),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
@@ -104,9 +98,6 @@ Compositor::Compositor(gfx::AcceleratedWidget widget)
       draw_on_compositing_end_(false),
       swap_state_(SWAP_NONE),
       schedule_draw_factory_(this) {
-  DCHECK(g_compositor_initialized)
-      << "Compositor::Initialize must be called before creating a Compositor.";
-
   root_web_layer_ = cc::Layer::Create();
   root_web_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 
@@ -156,12 +147,12 @@ Compositor::Compositor(gfx::AcceleratedWidget widget)
   settings.use_zero_copy = IsUIZeroCopyEnabled();
 
   base::TimeTicks before_create = base::TimeTicks::Now();
-  if (!!g_compositor_thread) {
+  if (compositor_thread_loop_) {
     host_ = cc::LayerTreeHost::CreateThreaded(
         this,
         g_context_factory->GetSharedBitmapManager(),
         settings,
-        g_compositor_thread->message_loop_proxy());
+        compositor_thread_loop_);
   } else {
     host_ = cc::LayerTreeHost::CreateSingleThreaded(
         this, this, g_context_factory->GetSharedBitmapManager(), settings);
@@ -175,8 +166,6 @@ Compositor::Compositor(gfx::AcceleratedWidget widget)
 Compositor::~Compositor() {
   TRACE_EVENT0("shutdown", "Compositor::destructor");
 
-  DCHECK(g_compositor_initialized);
-
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
@@ -190,51 +179,8 @@ Compositor::~Compositor() {
   ContextFactory::GetInstance()->RemoveCompositor(this);
 }
 
-// static
-void Compositor::Initialize() {
-#if defined(OS_CHROMEOS)
-  bool use_thread = !CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kUIDisableThreadedCompositing);
-#else
-  bool use_thread = false;
-#endif
-  if (use_thread) {
-    g_compositor_thread = new base::Thread("Browser Compositor");
-    g_compositor_thread->Start();
-  }
-
-  DCHECK(!g_compositor_initialized) << "Compositor initialized twice.";
-  g_compositor_initialized = true;
-}
-
-// static
-bool Compositor::WasInitializedWithThread() {
-  DCHECK(g_compositor_initialized);
-  return !!g_compositor_thread;
-}
-
-// static
-scoped_refptr<base::MessageLoopProxy> Compositor::GetCompositorMessageLoop() {
-  scoped_refptr<base::MessageLoopProxy> proxy;
-  if (g_compositor_thread)
-    proxy = g_compositor_thread->message_loop_proxy();
-  return proxy;
-}
-
-// static
-void Compositor::Terminate() {
-  if (g_compositor_thread) {
-    g_compositor_thread->Stop();
-    delete g_compositor_thread;
-    g_compositor_thread = NULL;
-  }
-
-  DCHECK(g_compositor_initialized) << "Compositor::Initialize() didn't happen.";
-  g_compositor_initialized = false;
-}
-
 void Compositor::ScheduleDraw() {
-  if (g_compositor_thread) {
+  if (compositor_thread_loop_) {
     host_->Composite(gfx::FrameTime::Now());
   } else if (!defer_draw_scheduling_) {
     defer_draw_scheduling_ = true;
@@ -263,7 +209,7 @@ void Compositor::SetHostHasTransparentBackground(
 }
 
 void Compositor::Draw() {
-  DCHECK(!g_compositor_thread);
+  DCHECK(!compositor_thread_loop_);
 
   defer_draw_scheduling_ = false;
   if (waiting_on_compositing_end_) {
@@ -382,7 +328,7 @@ void Compositor::DidCommitAndDrawFrame() {
 }
 
 void Compositor::DidCompleteSwapBuffers() {
-  if (g_compositor_thread) {
+  if (compositor_thread_loop_) {
     NotifyEnd();
   } else {
     DCHECK_EQ(swap_state_, SWAP_POSTED);
@@ -401,13 +347,13 @@ void Compositor::ScheduleAnimation() {
 }
 
 void Compositor::DidPostSwapBuffers() {
-  DCHECK(!g_compositor_thread);
+  DCHECK(!compositor_thread_loop_);
   DCHECK_EQ(swap_state_, SWAP_NONE);
   swap_state_ = SWAP_POSTED;
 }
 
 void Compositor::DidAbortSwapBuffers() {
-  if (!g_compositor_thread) {
+  if (!compositor_thread_loop_) {
     if (swap_state_ == SWAP_POSTED) {
       NotifyEnd();
       swap_state_ = SWAP_COMPLETED;
@@ -431,7 +377,7 @@ void Compositor::SetLayerTreeDebugState(
 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
   if (!compositor_lock_) {
     compositor_lock_ = new CompositorLock(this);
-    if (g_compositor_thread)
+    if (compositor_thread_loop_)
       host_->SetDeferCommits(true);
     FOR_EACH_OBSERVER(CompositorObserver,
                       observer_list_,
@@ -443,7 +389,7 @@ scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
 void Compositor::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
-  if (g_compositor_thread)
+  if (compositor_thread_loop_)
     host_->SetDeferCommits(false);
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,

ui/compositor/compositor.h

@@ -96,6 +96,10 @@ class COMPOSITOR_EXPORT ContextFactory {
 
   // Gets the shared bitmap manager for software mode.
   virtual cc::SharedBitmapManager* GetSharedBitmapManager() = 0;
+
+  // Gets the compositor message loop, or NULL if not using threaded
+  // compositing.
+  virtual base::MessageLoopProxy* GetCompositorMessageLoop() = 0;
 };
 
 // This class represents a lock on the compositor, that can be used to prevent
@@ -135,11 +139,6 @@ class COMPOSITOR_EXPORT Compositor
   explicit Compositor(gfx::AcceleratedWidget widget);
   virtual ~Compositor();
 
-  static void Initialize();
-  static bool WasInitializedWithThread();
-  static scoped_refptr<base::MessageLoopProxy> GetCompositorMessageLoop();
-  static void Terminate();
-
   // Schedules a redraw of the layer tree associated with this compositor.
   void ScheduleDraw();
 
@@ -265,6 +264,7 @@ class COMPOSITOR_EXPORT Compositor
   gfx::AcceleratedWidget widget_;
   scoped_refptr<cc::Layer> root_web_layer_;
   scoped_ptr<cc::LayerTreeHost> host_;
+  scoped_refptr<base::MessageLoopProxy> compositor_thread_loop_;
 
   // The manager of vsync parameters for this compositor.
   scoped_refptr<CompositorVSyncManager> vsync_manager_;

ui/compositor/layer_unittest.cc

@@ -91,7 +91,6 @@ class LayerWithRealCompositorTest : public testing::Test {
   virtual void SetUp() OVERRIDE {
     bool enable_pixel_output = true;
     InitializeContextFactoryForTests(enable_pixel_output);
-    Compositor::Initialize();
 
     const gfx::Rect host_bounds(10, 10, 500, 500);
     compositor_host_.reset(TestCompositorHost::Create(host_bounds));
@@ -101,7 +100,6 @@ class LayerWithRealCompositorTest : public testing::Test {
   virtual void TearDown() OVERRIDE {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
-    Compositor::Terminate();
   }
 
   Compositor* GetCompositor() { return compositor_host_->GetCompositor(); }
@@ -400,7 +398,6 @@ class LayerWithDelegateTest : public testing::Test {
   virtual void SetUp() OVERRIDE {
     bool enable_pixel_output = false;
     InitializeContextFactoryForTests(enable_pixel_output);
-    Compositor::Initialize();
 
     const gfx::Rect host_bounds(1000, 1000);
     compositor_host_.reset(TestCompositorHost::Create(host_bounds));
@@ -410,7 +407,6 @@ class LayerWithDelegateTest : public testing::Test {
   virtual void TearDown() OVERRIDE {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
-    Compositor::Terminate();
   }
 
   Compositor* compositor() { return compositor_host_->GetCompositor(); }

ui/compositor/test/in_process_context_factory.cc

@@ -4,8 +4,11 @@
 
 #include "ui/compositor/test/in_process_context_factory.h"
 
+#include "base/command_line.h"
+#include "base/threading/thread.h"
 #include "cc/output/output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
+#include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/reflector.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
@@ -18,6 +21,16 @@ namespace ui {
 InProcessContextFactory::InProcessContextFactory()
     : shared_bitmap_manager_(new cc::TestSharedBitmapManager()) {
   DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone);
+#if defined(OS_CHROMEOS)
+  bool use_thread = !CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUIDisableThreadedCompositing);
+#else
+  bool use_thread = false;
+#endif
+  if (use_thread) {
+    compositor_thread_.reset(new base::Thread("Browser Compositor"));
+    compositor_thread_->Start();
+  }
 }
 
 InProcessContextFactory::~InProcessContextFactory() {}
@@ -80,4 +93,10 @@ cc::SharedBitmapManager* InProcessContextFactory::GetSharedBitmapManager() {
   return shared_bitmap_manager_.get();
 }
 
+base::MessageLoopProxy* InProcessContextFactory::GetCompositorMessageLoop() {
+  if (!compositor_thread_)
+    return NULL;
+  return compositor_thread_->message_loop_proxy();
+}
+
 }  // namespace ui

ui/compositor/test/in_process_context_factory.h

@@ -7,6 +7,10 @@
 
 #include "ui/compositor/compositor.h"
 
+namespace base {
+class Thread;
+}
+
 namespace webkit {
 namespace gpu {
 class ContextProviderInProcess;
@@ -35,8 +39,10 @@ class InProcessContextFactory : public ContextFactory {
   virtual void RemoveCompositor(Compositor* compositor) OVERRIDE;
   virtual bool DoesCreateTestContexts() OVERRIDE;
   virtual cc::SharedBitmapManager* GetSharedBitmapManager() OVERRIDE;
+  virtual base::MessageLoopProxy* GetCompositorMessageLoop() OVERRIDE;
 
  private:
+  scoped_ptr<base::Thread> compositor_thread_;
   scoped_refptr<webkit::gpu::ContextProviderInProcess>
       shared_main_thread_contexts_;
   scoped_ptr<cc::SharedBitmapManager> shared_bitmap_manager_;