Introduce CompositorDependencies for RenderWidgetCompositor.

content/renderer/gpu/render_widget_compositor_unittest.cc

Index: content/renderer/gpu/render_widget_compositor_unittest.cc
diff --git a/content/renderer/gpu/render_widget_compositor_unittest.cc b/content/renderer/gpu/render_widget_compositor_unittest.cc
index e14769a3f14383484d96b503ed06bdec2efff607..592cde87fcf877b3dd76067e88eb3184a8557307 100644
--- a/content/renderer/gpu/render_widget_compositor_unittest.cc
+++ b/content/renderer/gpu/render_widget_compositor_unittest.cc
@@ -5,10 +5,14 @@
 #include "content/renderer/gpu/render_widget_compositor.h"
 
 #include "cc/output/begin_frame_args.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "cc/test/failure_output_surface.h"
+#include "cc/test/test_gpu_memory_buffer_manager.h"
+#include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/public/test/mock_render_thread.h"
 #include "content/renderer/render_widget.h"
+#include "content/renderer/scheduler/renderer_scheduler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
@@ -17,6 +21,7 @@ using testing::AllOf;
 using testing::Field;
 
 namespace content {
+namespace {
 
 class MockWebWidget : public blink::WebWidget {
  public:
@@ -42,17 +47,88 @@ class TestRenderWidget : public RenderWidget {
   DISALLOW_COPY_AND_ASSIGN(TestRenderWidget);
 };
 
+class FakeRendererScheduler : public RendererScheduler {
+ public:
+  FakeRendererScheduler() {}
+  virtual ~FakeRendererScheduler() {}
+
+  // RendererScheduler implementation.
+  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override {
+    return nullptr;
+  }
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override {
+    return nullptr;
+  }
+  scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override {
+    return nullptr;
+  }
+  void WillBeginFrame(const cc::BeginFrameArgs& args) override {}
+  void DidCommitFrameToCompositor() override {}
+  void DidReceiveInputEventOnCompositorThread(
+      blink::WebInputEvent::Type type) override {}
+  void DidAnimateForInputOnCompositorThread() override {}
+  bool ShouldYieldForHighPriorityWork() override { return false; }
+  void Shutdown() override {}
+};
+
+class FakeCompositorDependencies : public CompositorDependencies {
+ public:
+  // CompositorDependencies implementation.
+  bool IsImplSidePaintingEnabled() override { return true; }
+  bool IsGpuRasterizationForced() override { return false; }
+  bool IsGpuRasterizationEnabled() override { return false; }
+  bool IsLcdTextEnabled() override { return false; }
+  bool IsDistanceFieldTextEnabled() override { return false; }
+  bool IsZeroCopyEnabled() override { return false; }
+  bool IsOneCopyEnabled() override { return true; }
+  uint32 GetImageTextureTarget() override { return GL_TEXTURE_2D; }
+  scoped_refptr<base::SingleThreadTaskRunner>
+  GetCompositorMainThreadTaskRunner() override {
+    return base::MessageLoopProxy::current();
+  }
+  scoped_refptr<base::SingleThreadTaskRunner>
+  GetCompositorImplThreadTaskRunner() override {
+    return nullptr;  // Currently never threaded compositing in unit tests.
+  }
+  cc::SharedBitmapManager* GetSharedBitmapManager() override {
+    return &shared_bitmap_manager_;
+  }
+  gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override {
+    return &gpu_memory_buffer_manager_;
+  }
+  RendererScheduler* GetRendererScheduler() override {
+    return &renderer_scheduler_;
+  }
+  cc::ContextProvider* GetSharedMainThreadContextProvider() override {
+    NOTREACHED();
+    return nullptr;
+  }
+  scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource(
+      int routing_id) override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+ private:
+  cc::TestSharedBitmapManager shared_bitmap_manager_;
+  cc::TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
+  FakeRendererScheduler renderer_scheduler_;
+};
+
 class RenderWidgetCompositorTest : public testing::Test {
  public:
   RenderWidgetCompositorTest()
       : render_widget_(make_scoped_refptr(new TestRenderWidget())),
+        compositor_deps_(make_scoped_ptr(new FakeCompositorDependencies)),
         render_widget_compositor_(
-            RenderWidgetCompositor::Create(render_widget_.get(), false)) {}
+            RenderWidgetCompositor::Create(render_widget_.get(),
+                                           compositor_deps_.get())) {}
   ~RenderWidgetCompositorTest() override {}
 
  protected:
   MockRenderThread render_thread_;
   scoped_refptr<TestRenderWidget> render_widget_;
+  scoped_ptr<FakeCompositorDependencies> compositor_deps_;
   scoped_ptr<RenderWidgetCompositor> render_widget_compositor_;
 
  private:
@@ -103,8 +179,9 @@ class RenderWidgetOutputSurface : public TestRenderWidget {
 // the compositor (couldn't bind the output surface) are handled identically.
 class RenderWidgetCompositorOutputSurface : public RenderWidgetCompositor {
  public:
-  RenderWidgetCompositorOutputSurface(RenderWidget* widget, bool threaded)
-      : RenderWidgetCompositor(widget, threaded),
+  RenderWidgetCompositorOutputSurface(RenderWidget* widget,
+                                      CompositorDependencies* compositor_deps)
+      : RenderWidgetCompositor(widget, compositor_deps),
         num_failures_before_success_(0),
         expected_successes_(0),
         expected_fallback_successes_(0),
@@ -115,10 +192,9 @@ class RenderWidgetCompositorOutputSurface : public RenderWidgetCompositor {
         num_fallback_successes_(0),
         num_failures_(0),
         last_create_was_fallback_(false),
-        use_null_output_surface_(true) {
-    cc::LayerTreeSettings settings;
-    Initialize(settings);
-  }
+        use_null_output_surface_(true) {}
+
+  using RenderWidgetCompositor::Initialize;
 
   scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) {
     EXPECT_EQ(num_requests_since_last_success_ >
@@ -206,9 +282,11 @@ class RenderWidgetCompositorOutputSurfaceTest : public testing::Test {
  public:
   RenderWidgetCompositorOutputSurfaceTest()
       : render_widget_(make_scoped_refptr(new RenderWidgetOutputSurface)),
+        compositor_deps_(make_scoped_ptr(new FakeCompositorDependencies)),
         render_widget_compositor_(make_scoped_ptr(
             new RenderWidgetCompositorOutputSurface(render_widget_.get(),
-                                                    false))) {
+                                                    compositor_deps_.get()))) {
+    render_widget_compositor_->Initialize();
     render_widget_->SetCompositor(render_widget_compositor_.get());
   }
 
@@ -231,6 +309,7 @@ class RenderWidgetCompositorOutputSurfaceTest : public testing::Test {
   base::MessageLoop ye_olde_message_loope_;
   MockRenderThread render_thread_;
   scoped_refptr<RenderWidgetOutputSurface> render_widget_;
+  scoped_ptr<FakeCompositorDependencies> compositor_deps_;
   scoped_ptr<RenderWidgetCompositorOutputSurface> render_widget_compositor_;
 
  private:
@@ -285,4 +364,5 @@ TEST_F(RenderWidgetCompositorOutputSurfaceTest, FallbackSuccessNormalSuccess) {
           1, 1);
 }
 
+}  // namespace
 }  // namespace content