Revert 216780 "Clean up compositor initialization/destruction."

trunk/src/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() {
-  DCHECK(g_context_factory);
+  if (!g_context_factory)
+    SetupImplicitFactory();
   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::DoesCreateTestContexts() { 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::DoesCreateTestContexts() { 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 =
-      ContextFactory::GetInstance()->DoesCreateTestContexts()
-      ? kTestRefreshRate
-      : kDefaultRefreshRate;
+      g_test_compositor_enabled ? 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))
-    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;
-
-  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