Introduce CompositorDependencies for RenderWidgetCompositor.

This interface provides whatever RenderWidgetCompositor requires
instead of going directly to RenderThreadImpl which may or may not
exist in tests.

R=piman@chromium.org
BUG=384381

Review URL: https://codereview.chromium.org/801973002

Cr-Commit-Position: refs/heads/master@{#308615}

cc/BUILD.gn

@@ -551,6 +551,8 @@ source_set("test_support") {
     "test/fake_delegated_renderer_layer.h",
     "test/fake_delegated_renderer_layer_impl.cc",
     "test/fake_delegated_renderer_layer_impl.h",
+    "test/fake_external_begin_frame_source.cc",
+    "test/fake_external_begin_frame_source.h",
     "test/fake_impl_proxy.h",
     "test/fake_layer_tree_host.cc",
     "test/fake_layer_tree_host.h",

cc/cc_tests.gyp

@@ -150,6 +150,8 @@
       'test/fake_delegated_renderer_layer.h',
       'test/fake_delegated_renderer_layer_impl.cc',
       'test/fake_delegated_renderer_layer_impl.h',
+      'test/fake_external_begin_frame_source.cc',
+      'test/fake_external_begin_frame_source.h',
       'test/fake_impl_proxy.h',
       'test/fake_layer_tree_host.cc',
       'test/fake_layer_tree_host.h',

cc/resources/resource_provider.cc

@@ -555,17 +555,9 @@ ResourceProvider::ResourceId ResourceProvider::CreateBitmap(
     const gfx::Size& size, GLint wrap_mode) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<SharedBitmap> bitmap;
-  if (shared_bitmap_manager_)
-    bitmap = shared_bitmap_manager_->AllocateSharedBitmap(size);
-
-  uint8_t* pixels;
-  if (bitmap) {
-    pixels = bitmap->pixels();
-  } else {
-    size_t bytes = SharedBitmap::CheckedSizeInBytes(size);
-    pixels = new uint8_t[bytes];
-  }
+  scoped_ptr<SharedBitmap> bitmap =
+      shared_bitmap_manager_->AllocateSharedBitmap(size);
+  uint8_t* pixels = bitmap->pixels();
   DCHECK(pixels);
 
   ResourceId id = next_id_++;

cc/test/fake_external_begin_frame_source.cc

@@ -0,0 +1,46 @@
+// 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 "cc/test/fake_external_begin_frame_source.h"
+
+#include "base/location.h"
+#include "base/message_loop/message_loop.h"
+#include "base/time/time.h"
+#include "cc/test/begin_frame_args_test.h"
+
+namespace cc {
+
+FakeExternalBeginFrameSource::FakeExternalBeginFrameSource(double refresh_rate)
+    : milliseconds_per_frame_(1000.0 / refresh_rate),
+      is_ready_(false),
+      weak_ptr_factory_(this) {
+  DetachFromThread();
+}
+
+FakeExternalBeginFrameSource::~FakeExternalBeginFrameSource() {
+  DCHECK(CalledOnValidThread());
+}
+
+void FakeExternalBeginFrameSource::SetClientReady() {
+  DCHECK(CalledOnValidThread());
+  is_ready_ = true;
+}
+
+void FakeExternalBeginFrameSource::OnNeedsBeginFramesChange(
+    bool needs_begin_frames) {
+  DCHECK(CalledOnValidThread());
+  if (needs_begin_frames) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&FakeExternalBeginFrameSource::TestOnBeginFrame,
+                              weak_ptr_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(milliseconds_per_frame_));
+  }
+}
+
+void FakeExternalBeginFrameSource::TestOnBeginFrame() {
+  DCHECK(CalledOnValidThread());
+  CallOnBeginFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+}
+
+}  // namespace cc

cc/test/fake_external_begin_frame_source.h

@@ -0,0 +1,38 @@
+// 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.
+
+#ifndef CC_TEST_FAKE_EXTERNAL_BEGIN_FRAME_SOURCE_H_
+#define CC_TEST_FAKE_EXTERNAL_BEGIN_FRAME_SOURCE_H_
+
+#include "base/memory/weak_ptr.h"
+#include "cc/scheduler/begin_frame_source.h"
+
+namespace cc {
+
+class FakeExternalBeginFrameSource
+    : public BeginFrameSourceMixIn,
+      public NON_EXPORTED_BASE(base::NonThreadSafe) {
+ public:
+  explicit FakeExternalBeginFrameSource(double refresh_rate);
+  virtual ~FakeExternalBeginFrameSource();
+
+  bool is_ready() const { return is_ready_; }
+
+  // BeginFrameSource implementation.
+  void SetClientReady() override;
+
+  // BeginFrameSourceMixIn overrides.
+  void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
+
+  void TestOnBeginFrame();
+
+ private:
+  double milliseconds_per_frame_;
+  bool is_ready_;
+  base::WeakPtrFactory<FakeExternalBeginFrameSource> weak_ptr_factory_;
+};
+
+}  // namespace cc
+
+#endif  // CC_TEST_FAKE_EXTERNAL_BEGIN_FRAME_SOURCE_H_

cc/test/layer_tree_test.cc

@@ -16,6 +16,7 @@
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/begin_frame_args_test.h"
+#include "cc/test/fake_external_begin_frame_source.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/test_context_provider.h"
@@ -54,52 +55,6 @@ void TestHooks::CreateResourceAndTileTaskWorkerPool(
       tile_task_worker_pool, resource_pool, staging_resource_pool);
 }
 
-class ExternalBeginFrameSourceForTest
-    : public BeginFrameSourceMixIn,
-      public NON_EXPORTED_BASE(base::NonThreadSafe) {
- public:
-  explicit ExternalBeginFrameSourceForTest(double refresh_rate)
-      : milliseconds_per_frame_(1000.0 / refresh_rate),
-        is_ready_(false),
-        weak_ptr_factory_(this) {
-    DetachFromThread();
-  }
-
-  virtual ~ExternalBeginFrameSourceForTest() {
-    DCHECK(CalledOnValidThread());
-  }
-
-  void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
-    DCHECK(CalledOnValidThread());
-    if (needs_begin_frames) {
-      base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ExternalBeginFrameSourceForTest::TestOnBeginFrame,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(milliseconds_per_frame_));
-    }
-  }
-
-  void SetClientReady() override {
-    DCHECK(CalledOnValidThread());
-    is_ready_ = true;
-  }
-
-  bool is_ready() const {
-    return is_ready_;
-  }
-
-  void TestOnBeginFrame() {
-    DCHECK(CalledOnValidThread());
-    CallOnBeginFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
-  }
-
- private:
-  double milliseconds_per_frame_;
-  bool is_ready_;
-  base::WeakPtrFactory<ExternalBeginFrameSourceForTest> weak_ptr_factory_;
-};
-
 // Adapts ThreadProxy for test. Injects test hooks for testing.
 class ThreadProxyForTest : public ThreadProxy {
  public:
@@ -614,10 +569,10 @@ void LayerTreeTest::WillBeginTest() {
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
-  scoped_ptr<ExternalBeginFrameSourceForTest> external_begin_frame_source;
+  scoped_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
   if (settings_.use_external_begin_frame_source &&
       settings_.throttle_frame_production) {
-    external_begin_frame_source.reset(new ExternalBeginFrameSourceForTest(
+    external_begin_frame_source.reset(new FakeExternalBeginFrameSource(
         settings_.renderer_settings.refresh_rate));
     external_begin_frame_source_ = external_begin_frame_source.get();
   }

cc/test/layer_tree_test.h

@@ -17,7 +17,7 @@ class WebGraphicsContext3D;
 }
 
 namespace cc {
-class ExternalBeginFrameSourceForTest;
+class FakeExternalBeginFrameSource;
 class FakeLayerTreeHostClient;
 class FakeOutputSurface;
 class LayerImpl;
@@ -216,7 +216,7 @@ class LayerTreeTest : public testing::Test, public TestHooks {
   scoped_ptr<LayerTreeHostClientForTesting> client_;
   scoped_ptr<LayerTreeHost> layer_tree_host_;
   FakeOutputSurface* output_surface_;
-  ExternalBeginFrameSourceForTest* external_begin_frame_source_;
+  FakeExternalBeginFrameSource* external_begin_frame_source_;
 
   bool beginning_;
   bool end_when_begin_returns_;

content/content_renderer.gypi

@@ -159,6 +159,7 @@
       'renderer/gamepad_shared_memory_reader.h',
       'renderer/geolocation_dispatcher.cc',
       'renderer/geolocation_dispatcher.h',
+      'renderer/gpu/compositor_dependencies.h',
       'renderer/gpu/compositor_external_begin_frame_source.cc',
       'renderer/gpu/compositor_external_begin_frame_source.h',
       'renderer/gpu/compositor_forwarding_message_filter.cc',

content/content_tests.gypi

@@ -111,8 +111,12 @@
       'test/content_browser_test_utils_internal.h',
       'test/content_test_suite.cc',
       'test/content_test_suite.h',
+      'test/fake_compositor_dependencies.cc',
+      'test/fake_compositor_dependencies.h',
       'test/fake_plugin_service.cc',
       'test/fake_plugin_service.h',
+      'test/fake_renderer_scheduler.cc',
+      'test/fake_renderer_scheduler.h',
       'test/mock_google_streaming_server.cc',
       'test/mock_google_streaming_server.h',
       'test/mock_keyboard.cc',

content/public/test/render_view_test.cc

@@ -22,6 +22,7 @@
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/renderer_main_platform_delegate.h"
 #include "content/renderer/scheduler/renderer_scheduler.h"
+#include "content/test/fake_compositor_dependencies.h"
 #include "content/test/mock_render_process.h"
 #include "content/test/test_content_client.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
@@ -185,6 +186,7 @@ void RenderViewTest::SetUp() {
     ui::ResourceBundle::InitSharedInstanceWithLocale(
         "en-US", NULL, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
 
+  compositor_deps_.reset(new FakeCompositorDependencies);
   mock_process_.reset(new MockRenderProcess);
 
   ViewMsg_New_Params view_params;
@@ -209,7 +211,8 @@ void RenderViewTest::SetUp() {
   view_params.max_size = gfx::Size();
 
   // This needs to pass the mock render thread to the view.
-  RenderViewImpl* view = RenderViewImpl::Create(view_params, false);
+  RenderViewImpl* view =
+      RenderViewImpl::Create(view_params, compositor_deps_.get(), false);
   view->AddRef();
   view_ = view;
 }

content/public/test/render_view_test.h

@@ -33,6 +33,7 @@ namespace content {
 class ContentBrowserClient;
 class ContentClient;
 class ContentRendererClient;
+class FakeCompositorDependencies;
 class MockRenderProcess;
 class PageState;
 class RendererMainPlatformDelegate;
@@ -141,6 +142,7 @@ class RenderViewTest : public testing::Test {
   void TearDown() override;
 
   base::MessageLoop msg_loop_;
+  scoped_ptr<FakeCompositorDependencies> compositor_deps_;
   scoped_ptr<MockRenderProcess> mock_process_;
   // We use a naked pointer because we don't want to expose RenderViewImpl in
   // the embedder's namespace.

content/renderer/gpu/compositor_dependencies.h

@@ -0,0 +1,56 @@
+// 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.
+
+#ifndef CONTENT_RENDERER_GPU_COMPOSITOR_DEPENDENCIES_H_
+#define CONTENT_RENDERER_GPU_COMPOSITOR_DEPENDENCIES_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace cc {
+class BeginFrameSource;
+class ContextProvider;
+class SharedBitmapManager;
+}
+
+namespace gpu {
+class GpuMemoryBufferManager;
+}
+
+namespace content {
+class RendererScheduler;
+
+class CompositorDependencies {
+ public:
+  virtual bool IsImplSidePaintingEnabled() = 0;
+  virtual bool IsGpuRasterizationForced() = 0;
+  virtual bool IsGpuRasterizationEnabled() = 0;
+  virtual bool IsLcdTextEnabled() = 0;
+  virtual bool IsDistanceFieldTextEnabled() = 0;
+  virtual bool IsZeroCopyEnabled() = 0;
+  virtual bool IsOneCopyEnabled() = 0;
+  virtual uint32 GetImageTextureTarget() = 0;
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+  GetCompositorMainThreadTaskRunner() = 0;
+  // Returns null if the compositor is in single-threaded mode (ie. there is no
+  // compositor thread).
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+  GetCompositorImplThreadTaskRunner() = 0;
+  virtual cc::SharedBitmapManager* GetSharedBitmapManager() = 0;
+  virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
+  virtual RendererScheduler* GetRendererScheduler() = 0;
+  virtual cc::ContextProvider* GetSharedMainThreadContextProvider() = 0;
+  virtual scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource(
+      int routing_id) = 0;
+
+  virtual ~CompositorDependencies() {}
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_GPU_COMPOSITOR_DEPENDENCIES_H_

content/renderer/gpu/compositor_external_begin_frame_source.cc

@@ -5,17 +5,17 @@
 #include "content/renderer/gpu/compositor_external_begin_frame_source.h"
 
 #include "content/common/view_messages.h"
-#include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
 
 namespace content {
 
 CompositorExternalBeginFrameSource::CompositorExternalBeginFrameSource(
+    CompositorForwardingMessageFilter* filter,
+    IPC::SyncMessageFilter* sync_message_filter,
     int routing_id)
-    : begin_frame_source_filter_(
-          RenderThreadImpl::current()->compositor_message_filter()),
-      message_sender_(RenderThreadImpl::current()->sync_message_filter()),
+    : begin_frame_source_filter_(filter),
+      message_sender_(sync_message_filter),
       routing_id_(routing_id) {
   DCHECK(begin_frame_source_filter_.get());
   DCHECK(message_sender_.get());

content/renderer/gpu/compositor_external_begin_frame_source.h

@@ -24,7 +24,10 @@ class CompositorExternalBeginFrameSource
     : public cc::BeginFrameSourceMixIn,
       public NON_EXPORTED_BASE(base::NonThreadSafe) {
  public:
-  explicit CompositorExternalBeginFrameSource(int routing_id);
+  explicit CompositorExternalBeginFrameSource(
+      CompositorForwardingMessageFilter* filter,
+      IPC::SyncMessageFilter* sync_message_filter,
+      int routing_id);
   virtual ~CompositorExternalBeginFrameSource();
 
   // cc::BeginFrameSourceMixIn implementation.