Initialize CompositorDependencies in RenderWidget's constructor.

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 "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/output/begin_frame_args.h"
@@ skipping 14 matching lines @@
 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,
+  explicit TestRenderWidget(CompositorDependencies* compositor_deps)
+      : RenderWidget(compositor_deps,
+                     blink::WebPopupTypeNone,
                      blink::WebScreenInfo(),
                      true,
                      false,
                      false) {
     webwidget_ = &mock_webwidget_;
   }
 
   MockWebWidget mock_webwidget_;
 
  protected:
   ~TestRenderWidget() override { webwidget_ = NULL; }
 
   DISALLOW_COPY_AND_ASSIGN(TestRenderWidget);
 };
 
 class RenderWidgetCompositorTest : public testing::Test {
  public:
   RenderWidgetCompositorTest()
-      : render_widget_(new TestRenderWidget()),
-        compositor_deps_(new FakeCompositorDependencies),
+      : compositor_deps_(new FakeCompositorDependencies),
+        render_widget_(new TestRenderWidget(compositor_deps_.get())),
         render_widget_compositor_(
             RenderWidgetCompositor::Create(render_widget_.get(),
                                            compositor_deps_.get())) {}
   ~RenderWidgetCompositorTest() override {}
 
  protected:
   base::MessageLoop loop_;
   MockRenderThread render_thread_;
+  scoped_ptr<FakeCompositorDependencies> compositor_deps_;
   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));
   base::TimeDelta interval(base::TimeDelta::FromSeconds(3));
   cc::BeginFrameArgs args(
       cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
                                  interval, cc::BeginFrameArgs::NORMAL));
 
   EXPECT_CALL(render_widget_->mock_webwidget_,
               beginFrame(AllOf(
                   Field(&blink::WebBeginFrameArgs::lastFrameTimeMonotonic, 1),
                   Field(&blink::WebBeginFrameArgs::deadline, 2),
                   Field(&blink::WebBeginFrameArgs::interval, 3))));
 
   render_widget_compositor_->BeginMainFrame(args);
 }
 
 class RenderWidgetCompositorOutputSurface;
 
 class RenderWidgetOutputSurface : public TestRenderWidget {
  public:
-  RenderWidgetOutputSurface() : compositor_(NULL) {}
+  explicit RenderWidgetOutputSurface(CompositorDependencies* compositor_deps)
+      : TestRenderWidget(compositor_deps), compositor_(NULL) {}
   void SetCompositor(RenderWidgetCompositorOutputSurface* compositor);
 
   scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) override;
 
  protected:
   ~RenderWidgetOutputSurface() override {}
 
  private:
   RenderWidgetCompositorOutputSurface* compositor_;
 
@@ skipping 121 matching lines @@
   int num_failures_;
   bool last_create_was_fallback_;
   bool use_null_output_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorOutputSurface);
 };
 
 class RenderWidgetCompositorOutputSurfaceTest : public testing::Test {
  public:
   RenderWidgetCompositorOutputSurfaceTest()
-      : render_widget_(new RenderWidgetOutputSurface),
-        compositor_deps_(new FakeCompositorDependencies) {
+      : compositor_deps_(new FakeCompositorDependencies),
+        render_widget_(new RenderWidgetOutputSurface(compositor_deps_.get())) {
     render_widget_compositor_.reset(new RenderWidgetCompositorOutputSurface(
         render_widget_.get(), 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);
     render_widget_compositor_->StartCompositor();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&RenderWidgetCompositorOutputSurface::SynchronousComposite,
                    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_ptr<FakeCompositorDependencies> compositor_deps_;
   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 36 matching lines @@
 }
 
 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