Temporarily adds another constructor to Compositor

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 65 matching lines @@
 
 }  // namespace ui
 
 namespace {
 
 }  // namespace
 
 namespace ui {
 
 Compositor::Compositor(gfx::AcceleratedWidget widget)
-    : root_layer_(NULL),
+    : context_factory_(g_context_factory),
+      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),
       last_ended_frame_(0),
       disable_schedule_composite_(false),
       compositor_lock_(NULL),
       defer_draw_scheduling_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       swap_state_(SWAP_NONE),
       schedule_draw_factory_(this) {
+  Init();
+}
+
+Compositor::Compositor(gfx::AcceleratedWidget widget,
+                       ui::ContextFactory* context_factory)
+    : context_factory_(context_factory),
+      root_layer_(NULL),
+      widget_(widget),
+      compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
+      vsync_manager_(new CompositorVSyncManager()),
+      device_scale_factor_(0.0f),
+      last_started_frame_(0),
+      last_ended_frame_(0),
+      disable_schedule_composite_(false),
+      compositor_lock_(NULL),
+      defer_draw_scheduling_(false),
+      waiting_on_compositing_end_(false),
+      draw_on_compositing_end_(false),
+      swap_state_(SWAP_NONE),
+      schedule_draw_factory_(this) {
+  Init();
+}
+
+// Yes, this is the wrong place. I'm leaving here to minimize diffs since this
+// function will be nuked soonish.
+void Compositor::Init() {
   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()
+      context_factory_->DoesCreateTestContexts()
       ? kTestRefreshRate
       : kDefaultRefreshRate;
   settings.main_frame_before_draw_enabled = false;
   settings.main_frame_before_activation_enabled = false;
   settings.throttle_frame_production =
       !command_line->HasSwitch(switches::kDisableGpuVsync);
   settings.partial_swap_enabled =
       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
 #if defined(OS_CHROMEOS)
   settings.per_tile_painting_enabled = true;
@@ skipping 24 matching lines @@
   settings.initial_debug_state.SetRecordRenderingStats(
       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 
   settings.impl_side_painting = IsUIImplSidePaintingEnabled();
   settings.use_zero_copy = IsUIZeroCopyEnabled();
 
   base::TimeTicks before_create = base::TimeTicks::Now();
   if (compositor_thread_loop_) {
     host_ = cc::LayerTreeHost::CreateThreaded(
         this,
-        g_context_factory->GetSharedBitmapManager(),
+        context_factory_->GetSharedBitmapManager(),
         settings,
         compositor_thread_loop_);
   } else {
     host_ = cc::LayerTreeHost::CreateSingleThreaded(
-        this, this, g_context_factory->GetSharedBitmapManager(), settings);
+        this, this, context_factory_->GetSharedBitmapManager(), settings);
   }
   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
                       base::TimeTicks::Now() - before_create);
   host_->SetRootLayer(root_web_layer_);
   host_->SetLayerTreeHostClientReady();
 }
 
 Compositor::~Compositor() {
   TRACE_EVENT0("shutdown", "Compositor::destructor");
 
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
   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);
+  context_factory_->RemoveCompositor(this);
 }
 
 void Compositor::ScheduleDraw() {
   if (compositor_thread_loop_) {
     host_->Composite(gfx::FrameTime::Now());
   } else if (!defer_draw_scheduling_) {
     defer_draw_scheduling_ = true;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&Compositor::Draw, schedule_draw_factory_.GetWeakPtr()));
@@ skipping 104 matching lines @@
 void Compositor::Layout() {
   // We're sending damage that will be addressed during this composite
   // cycle, so we don't need to schedule another composite to address it.
   disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
   disable_schedule_composite_ = false;
 }
 
 scoped_ptr<cc::OutputSurface> Compositor::CreateOutputSurface(bool fallback) {
-  return ContextFactory::GetInstance()->CreateOutputSurface(this, fallback);
+  return context_factory_->CreateOutputSurface(this, fallback);
 }
 
 void Compositor::DidCommit() {
   DCHECK(!IsLocked());
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingDidCommit(this));
 }
 
 void Compositor::DidCommitAndDrawFrame() {
@@ skipping 88 matching lines @@
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
 }  // namespace ui