aura: Clean up compositor initialization/destruction.

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"
@@ skipping 32 matching lines @@
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 200.0;
 
 enum SwapType {
   DRAW_SWAP,
   READPIXELS_SWAP,
 };
 
+bool g_compositor_initialized = false;
 base::Thread* g_compositor_thread = NULL;
 
-bool g_test_compositor_enabled = false;
-
 ui::ContextFactory* g_implicit_factory = NULL;
 ui::ContextFactory* g_context_factory = NULL;
 
 const int kCompositorLockTimeoutMs = 67;
 
 class PendingSwap {
  public:
   PendingSwap(SwapType type, ui::PostedSwapQueue* posted_swaps);
   ~PendingSwap();
 
   SwapType type() const { return type_; }
   bool posted() const { return posted_; }
 
  private:
   friend class ui::PostedSwapQueue;
 
   SwapType type_;
   bool posted_;
   ui::PostedSwapQueue* posted_swaps_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingSwap);
 };
 
-void SetupImplicitFactory() {
-  // We leak the implicit factory so that we don't race with the tear down of
-  // the gl_bindings.
-  DCHECK(!g_context_factory);
-  DCHECK(!g_implicit_factory);
-  if (g_test_compositor_enabled) {
-    g_implicit_factory = new ui::TestContextFactory;
-  } else {
-    DVLOG(1) << "Using DefaultContextFactory";
-    scoped_ptr<ui::DefaultContextFactory> instance(
-        new ui::DefaultContextFactory());
-    if (instance->Initialize())
-      g_implicit_factory = instance.release();
-  }
-  g_context_factory = g_implicit_factory;
-}
-
-void ResetImplicitFactory() {
-  if (!g_implicit_factory || g_context_factory != g_implicit_factory)
-    return;
-  delete g_implicit_factory;
-  g_implicit_factory = NULL;
-  g_context_factory = NULL;
-}
-
 }  // namespace
 
 namespace ui {
 
 // static
 ContextFactory* ContextFactory::GetInstance() {
-  if (!g_context_factory)
-    SetupImplicitFactory();
+  DCHECK(g_context_factory);
   return g_context_factory;
 }
 
 // static
 void ContextFactory::SetInstance(ContextFactory* instance) {
   g_context_factory = instance;
 }
 
 DefaultContextFactory::DefaultContextFactory() {
 }
@@ skipping 50 matching lines @@
       !offscreen_contexts_compositor_thread_->DestroyedOnMainThread()) {
     offscreen_contexts_compositor_thread_ =
         ContextProviderFromContextFactory::CreateForOffscreen(this);
   }
   return offscreen_contexts_compositor_thread_;
 }
 
 void DefaultContextFactory::RemoveCompositor(Compositor* compositor) {
 }
 
+bool DefaultContextFactory::UsesTestContexts() { return false; }
+
 scoped_ptr<WebKit::WebGraphicsContext3D>
 DefaultContextFactory::CreateContextCommon(Compositor* compositor,
                                            bool offscreen) {
   DCHECK(offscreen || compositor);
   WebKit::WebGraphicsContext3D::Attributes attrs;
   attrs.depth = false;
   attrs.stencil = false;
   attrs.antialias = false;
   attrs.shareResources = true;
   using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
@@ skipping 48 matching lines @@
       offscreen_contexts_compositor_thread_->DestroyedOnMainThread()) {
     offscreen_contexts_compositor_thread_ =
         ContextProviderFromContextFactory::CreateForOffscreen(this);
   }
   return offscreen_contexts_compositor_thread_;
 }
 
 void TestContextFactory::RemoveCompositor(Compositor* compositor) {
 }
 
+bool TestContextFactory::UsesTestContexts() { return true; }
+
 Texture::Texture(bool flipped, const gfx::Size& size, float device_scale_factor)
     : size_(size),
       flipped_(flipped),
       device_scale_factor_(device_scale_factor) {
 }
 
 Texture::~Texture() {
 }
 
 std::string Texture::Produce() {
@@ skipping 142 matching lines @@
     : delegate_(delegate),
       root_layer_(NULL),
       widget_(widget),
       posted_swaps_(new PostedSwapQueue()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       next_draw_is_resize_(false),
       disable_schedule_composite_(false),
       compositor_lock_(NULL) {
+  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));
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
-  settings.refresh_rate =
-      g_test_compositor_enabled ? kTestRefreshRate : kDefaultRefreshRate;
+  settings.refresh_rate = ContextFactory::GetInstance()->UsesTestContexts()
+                          ? kTestRefreshRate
+                          : kDefaultRefreshRate;
   settings.partial_swap_enabled =
       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
   settings.per_tile_painting_enabled =
       command_line->HasSwitch(cc::switches::kUIEnablePerTilePainting);
 
   // These flags should be mirrored by renderer versions in content/renderer/.
   settings.initial_debug_state.show_debug_borders =
       command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
   settings.initial_debug_state.show_fps_counter =
       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
@@ skipping 14 matching lines @@
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       g_compositor_thread ? g_compositor_thread->message_loop_proxy() : NULL;
 
   host_ = cc::LayerTreeHost::Create(this, settings, compositor_task_runner);
   host_->SetRootLayer(root_web_layer_);
   host_->SetLayerTreeHostClientReady();
 }
 
 Compositor::~Compositor() {
+  DCHECK(g_compositor_initialized);
+
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
   // Don't call |CompositorDelegate::ScheduleDraw| from this point.
   delegate_ = NULL;
   if (root_layer_)
     root_layer_->SetCompositor(NULL);
 
   // Stop all outstanding draws before telling the ContextFactory to tear
   // down any contexts that the |host_| may rely upon.
   host_.reset();
 
   ContextFactory::GetInstance()->RemoveCompositor(this);
 }
 
 // static
+void Compositor::InitializeContextFactoryForTests(bool allow_test_contexts) {
+  DCHECK(!g_context_factory) << "ContextFactory already initialized";
+  DCHECK(!g_implicit_factory) << "ContextFactory for tests already initialized";
+
+  bool use_test_contexts = true;
+
+  // Always use test contexts unless the disable command line flag is used.
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDisableTestCompositor))

[danakj, 2013/07/31 01:32:51]

I don't know if we really need to honor command line or IsRunningOnChromeOS here
anymore. Were those only for ImageTransportFactory::Initialize?

I'd kinda expect that in unit tests they should know what kind of contexts they
want, and we could just use the value passed into this method?

[piman, 2013/07/31 07:01:48]

The "test compositor" is an optimization for the bots, so that they run faster.
--disable-test-compositor is so that you can see what's happening when you need
to debug things, and that's definitely useful for UI people.
I forgot what led to the IsRunningOnChromeOS thing below, but on Chrome OS we
have a real GPU or at least a fast software implementation on VMs, so the
optimization doesn't bring us much. I suspect also it breaks some
ChromeOS-specific tests (e.g. login UI) because it disables accelerated
compositing in the renderer.

+    use_test_contexts = false;
+
+#if defined(OS_CHROMEOS)
+  // If the test is running on the chromeos envrionment (such as
+  // device or vm bots), always use real contexts.
+  if (base::chromeos::IsRunningOnChromeOS())
+    use_test_contexts = false;
+#endif
+
+  if (!allow_test_contexts)
+    use_test_contexts = false;
+
+  // We leak the implicit factory so that we don't race with the tear down of
+  // the gl_bindings.

[piman, 2013/07/31 07:01:48]

nit: I guess we don't leak it any more...

+  if (use_test_contexts) {
+    g_implicit_factory = new ui::TestContextFactory;
+  } else {
+    DVLOG(1) << "Using DefaultContextFactory";
+    scoped_ptr<ui::DefaultContextFactory> instance(
+        new ui::DefaultContextFactory());
+    if (instance->Initialize())
+      g_implicit_factory = instance.release();
+  }
+  g_context_factory = g_implicit_factory;
+}
+
+// static
 void Compositor::Initialize() {
 #if defined(OS_CHROMEOS)
   bool use_thread = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUIDisableThreadedCompositing);
 #else
   bool use_thread =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUIEnableThreadedCompositing) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUIDisableThreadedCompositing);
 #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() {
   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_context_factory) {
+    if (g_implicit_factory) {
+      delete g_implicit_factory;
+      g_implicit_factory = NULL;
+    }
+    g_context_factory = NULL;
+  }
+
   if (g_compositor_thread) {
+    DCHECK(!g_context_factory)
+        << "The ContextFactory should not outlive the 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)
     host_->Composite(base::TimeTicks::Now());
   else if (delegate_)
     delegate_->ScheduleDraw();
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
@@ skipping 226 matching lines @@
     compositor_lock_->CancelLock();
 }
 
 void Compositor::NotifyEnd() {
   last_ended_frame_++;
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
-COMPOSITOR_EXPORT void SetupTestCompositor() {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableTestCompositor)) {
-    g_test_compositor_enabled = true;
-  }
-#if defined(OS_CHROMEOS)
-  // If the test is running on the chromeos envrionment (such as
-  // device or vm bots), use the real compositor.
-  if (base::chromeos::IsRunningOnChromeOS())
-    g_test_compositor_enabled = false;
-#endif
-  ResetImplicitFactory();
-}
-
-COMPOSITOR_EXPORT void DisableTestCompositor() {
-  ResetImplicitFactory();
-  g_test_compositor_enabled = false;
-}
-
-COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
-  return g_test_compositor_enabled;
-}
-
 }  // namespace ui