Introduce CompositorDependencies for RenderWidgetCompositor.

content/renderer/gpu/render_widget_compositor_unittest.cc

 // Copyright 2014 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 "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"
 
 using testing::AllOf;
 using testing::Field;
 
 namespace content {
+namespace {
 
 class MockWebWidget : public blink::WebWidget {
  public:
   MOCK_METHOD1(beginFrame, void(const blink::WebBeginFrameArgs& args));
 };
 
 class TestRenderWidget : public RenderWidget {
  public:
   TestRenderWidget()
       : RenderWidget(blink::WebPopupTypeNone,
                      blink::WebScreenInfo(),
                      true,
                      false,
                      false) {
     webwidget_ = &mock_webwidget_;
   }
 
   MockWebWidget mock_webwidget_;
 
  protected:
   ~TestRenderWidget() override { webwidget_ = NULL; }
 
   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:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorTest);
 };
 
 TEST_F(RenderWidgetCompositorTest, BeginMainFrame) {
   base::TimeTicks frame_time(base::TimeTicks() +
                              base::TimeDelta::FromSeconds(1));
   base::TimeTicks deadline(base::TimeTicks() + base::TimeDelta::FromSeconds(2));
@@ skipping 30 matching lines @@
 };
 
 // Verify that failing to create an output surface will cause the compositor
 // to attempt to repeatedly create another output surface.  After enough
 // failures, verify that it attempts to create a fallback output surface.
 // The use null output surface parameter allows testing whether failures
 // from RenderWidget (couldn't create an output surface) vs failures from
 // 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),
         expected_requests_(0),
         num_requests_(0),
         num_requests_since_last_success_(0),
         num_successes_(0),
         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_ >
                   OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
               fallback);
     last_create_was_fallback_ = fallback;
     bool success = num_failures_ >= num_failures_before_success_;
     if (success)
       return cc::FakeOutputSurface::Create3d();
     return use_null_output_surface_
@@ skipping 67 matching lines @@
   bool last_create_was_fallback_;
   bool use_null_output_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorOutputSurface);
 };
 
 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());
   }
 
   void RunTest(bool use_null_output_surface,
                int num_failures_before_success,
                int expected_successes,
                int expected_fallback_succeses) {
     render_widget_compositor_->SetUp(
         use_null_output_surface, num_failures_before_success,
         expected_successes, expected_fallback_succeses);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RenderWidgetCompositor::RequestNewOutputSurface,
                    base::Unretained(render_widget_compositor_.get())));
     base::MessageLoop::current()->Run();
     render_widget_compositor_->AfterTest();
   }
 
  protected:
   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:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorOutputSurfaceTest);
 };
 
 scoped_ptr<cc::OutputSurface> RenderWidgetOutputSurface::CreateOutputSurface(
     bool fallback) {
   return compositor_->CreateOutputSurface(fallback);
 }
@@ skipping 34 matching lines @@
   RunTest(false, RenderWidgetCompositor::OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
           0, 1);
 }
 
 TEST_F(RenderWidgetCompositorOutputSurfaceTest, FallbackSuccessNormalSuccess) {
   // The first success is a fallback, but the next should not be a fallback.
   RunTest(false, RenderWidgetCompositor::OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
           1, 1);
 }
 
+}  // namespace
 }  // namespace content