Introduce CompositorDependencies for RenderWidgetCompositor.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 <limits>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "cc/base/latency_info_swap_promise.h"
 #include "cc/base/latency_info_swap_promise_monitor.h"
 #include "cc/base/swap_promise.h"
 #include "cc/base/switches.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/resources/single_release_callback.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/layer_tree_host.h"
-#include "content/child/child_gpu_memory_buffer_manager.h"
-#include "content/child/child_shared_bitmap_manager.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/public/common/content_switches.h"
-#include "content/renderer/gpu/compositor_external_begin_frame_source.h"
 #include "content/renderer/input/input_handler_manager.h"
-#include "content/renderer/render_thread_impl.h"
 #include "content/renderer/scheduler/renderer_scheduler.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebSelectionBound.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/native_theme/native_theme_switches.h"
@@ skipping 106 matching lines @@
   }
 #endif
   return gfx::Size(default_tile_size, default_tile_size);
 }
 
 }  // namespace
 
 // static
 scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
     RenderWidget* widget,
-    bool threaded) {
+    CompositorDependencies* compositor_deps) {
   scoped_ptr<RenderWidgetCompositor> compositor(
-      new RenderWidgetCompositor(widget, threaded));
+      new RenderWidgetCompositor(widget, compositor_deps));
+  compositor->Initialize();
+  return compositor;
+}
 
+RenderWidgetCompositor::RenderWidgetCompositor(
+    RenderWidget* widget,
+    CompositorDependencies* compositor_deps)
+    : num_failed_recreate_attempts_(0),
+      widget_(widget),
+      compositor_deps_(compositor_deps),
+      send_v8_idle_notification_after_commit_(true),
+      weak_factory_(this) {
+  CommandLine* cmd = CommandLine::ForCurrentProcess();
+
+  if (cmd->HasSwitch(switches::kEnableV8IdleNotificationAfterCommit))
+    send_v8_idle_notification_after_commit_ = true;
+  if (cmd->HasSwitch(switches::kDisableV8IdleNotificationAfterCommit))
+    send_v8_idle_notification_after_commit_ = false;
+}
+
+void RenderWidgetCompositor::Initialize() {
   CommandLine* cmd = CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // For web contents, layer transforms should scale up the contents of layers
   // to keep content always crisp when possible.
   settings.layer_transforms_should_scale_layer_contents = true;
 
   settings.throttle_frame_production =
       !cmd->HasSwitch(switches::kDisableGpuVsync);
@@ skipping 36 matching lines @@
   int max_untiled_layer_height = settings.max_untiled_layer_size.height();
   if (cmd->HasSwitch(switches::kMaxUntiledLayerHeight)) {
     GetSwitchValueAsInt(*cmd, switches::kMaxUntiledLayerHeight, 1,
                         std::numeric_limits<int>::max(),
                         &max_untiled_layer_height);
   }
 
   settings.max_untiled_layer_size = gfx::Size(max_untiled_layer_width,
                                            max_untiled_layer_height);
 
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  // render_thread may be NULL in tests.
-  if (render_thread) {
-    settings.impl_side_painting =
-        render_thread->is_impl_side_painting_enabled();
-    settings.gpu_rasterization_forced =
-        render_thread->is_gpu_rasterization_forced();
-    settings.gpu_rasterization_enabled =
-        render_thread->is_gpu_rasterization_enabled();
-    settings.can_use_lcd_text = render_thread->is_lcd_text_enabled();
-    settings.use_distance_field_text =
-        render_thread->is_distance_field_text_enabled();
-    settings.use_zero_copy = render_thread->is_zero_copy_enabled();
-    settings.use_one_copy = render_thread->is_one_copy_enabled();
-    settings.use_image_texture_target =
-        render_thread->use_image_texture_target();
-  }
+  settings.impl_side_painting = compositor_deps_->IsImplSidePaintingEnabled();
+  settings.gpu_rasterization_forced =
+      compositor_deps_->IsGpuRasterizationForced();
+  settings.gpu_rasterization_enabled =
+      compositor_deps_->IsGpuRasterizationEnabled();
+  settings.can_use_lcd_text = compositor_deps_->IsLcdTextEnabled();
+  settings.use_distance_field_text =
+      compositor_deps_->IsDistanceFieldTextEnabled();
+  settings.use_zero_copy = compositor_deps_->IsZeroCopyEnabled();
+  settings.use_one_copy = compositor_deps_->IsOneCopyEnabled();
+  settings.use_image_texture_target = compositor_deps_->GetImageTextureTarget();
 
   settings.calculate_top_controls_position =
       cmd->HasSwitch(cc::switches::kEnableTopControlsPositionCalculation);
   if (cmd->HasSwitch(cc::switches::kTopControlsShowThreshold)) {
       std::string top_threshold_str =
           cmd->GetSwitchValueASCII(cc::switches::kTopControlsShowThreshold);
       double show_threshold;
       if (base::StringToDouble(top_threshold_str, &show_threshold) &&
           show_threshold >= 0.f && show_threshold <= 1.f)
         settings.top_controls_show_threshold = show_threshold;
@@ skipping 78 matching lines @@
 #if defined(OS_ANDROID)
   SynchronousCompositorFactory* synchronous_compositor_factory =
       SynchronousCompositorFactory::GetInstance();
 
   // We can't use GPU rasterization on low-end devices, because the Ganesh
   // cache would consume too much memory.
   if (base::SysInfo::IsLowEndDevice())
     settings.gpu_rasterization_enabled = false;
   settings.using_synchronous_renderer_compositor =
       synchronous_compositor_factory;
-  settings.record_full_layer = widget->DoesRecordFullLayer();
+  settings.record_full_layer = widget_->DoesRecordFullLayer();
   settings.report_overscroll_only_for_scrollable_axes =
       !synchronous_compositor_factory;
   settings.max_partial_texture_updates = 0;
   if (synchronous_compositor_factory) {
     // Android WebView uses system scrollbars, so make ours invisible.
     settings.scrollbar_animator = cc::LayerTreeSettings::NoAnimator;
     settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
   } else {
     settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
     settings.scrollbar_fade_delay_ms = 300;
@@ skipping 44 matching lines @@
   settings.scrollbar_fade_delay_ms = 500;
   settings.scrollbar_fade_resize_delay_ms = 500;
   settings.scrollbar_fade_duration_ms = 300;
 #endif
 
   if (cmd->HasSwitch(switches::kEnableLowResTiling))
     settings.create_low_res_tiling = true;
   if (cmd->HasSwitch(switches::kDisableLowResTiling))
     settings.create_low_res_tiling = false;
 
-  compositor->Initialize(settings);
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
+      compositor_deps_->GetCompositorImplThreadTaskRunner();
+  scoped_refptr<base::SingleThreadTaskRunner>
+      main_thread_compositor_task_runner =
+          compositor_deps_->GetCompositorMainThreadTaskRunner();
+  cc::SharedBitmapManager* shared_bitmap_manager =
+      compositor_deps_->GetSharedBitmapManager();
+  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
+      compositor_deps_->GetGpuMemoryBufferManager();
 
-  return compositor.Pass();
-}
+  scoped_ptr<cc::BeginFrameSource> external_begin_frame_source;
+  if (settings.use_external_begin_frame_source) {
+    external_begin_frame_source =
+        compositor_deps_->CreateExternalBeginFrameSource(widget_->routing_id());
+  }
 
-RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
-                                               bool threaded)
-    : num_failed_recreate_attempts_(0),
-      threaded_(threaded),
-      widget_(widget),
-      send_v8_idle_notification_after_commit_(true),
-      weak_factory_(this) {
-  CommandLine* cmd = CommandLine::ForCurrentProcess();
-
-  if (cmd->HasSwitch(switches::kEnableV8IdleNotificationAfterCommit))
-    send_v8_idle_notification_after_commit_ = true;
-  if (cmd->HasSwitch(switches::kDisableV8IdleNotificationAfterCommit))
-    send_v8_idle_notification_after_commit_ = false;
+  if (compositor_thread_task_runner.get()) {
+    layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
+        this, shared_bitmap_manager, gpu_memory_buffer_manager, settings,
+        main_thread_compositor_task_runner, compositor_thread_task_runner,
+        external_begin_frame_source.Pass());
+  } else {
+    layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
+        this, this, shared_bitmap_manager, gpu_memory_buffer_manager, settings,
+        main_thread_compositor_task_runner, external_begin_frame_source.Pass());
+  }
+  DCHECK(layer_tree_host_);
 }
 
 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 
 const base::WeakPtr<cc::InputHandler>&
 RenderWidgetCompositor::GetInputHandler() {
   return layer_tree_host_->GetInputHandler();
 }
 
 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
@@ skipping 75 matching lines @@
     const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
   return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
 }
 
 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
     int id,
     scoped_ptr<base::Value> value) {
   return layer_tree_host_->SendMessageToMicroBenchmark(id, value.Pass());
 }
 
-void RenderWidgetCompositor::Initialize(const cc::LayerTreeSettings& settings) {
-  scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy;
-  scoped_refptr<base::SingleThreadTaskRunner>
-      main_thread_compositor_task_runner(base::MessageLoopProxy::current());
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  cc::SharedBitmapManager* shared_bitmap_manager = NULL;
-  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = NULL;
-  // render_thread may be NULL in tests.
-  if (render_thread) {
-    compositor_message_loop_proxy =
-        render_thread->compositor_message_loop_proxy();
-    shared_bitmap_manager = render_thread->shared_bitmap_manager();
-    gpu_memory_buffer_manager = render_thread->gpu_memory_buffer_manager();
-    main_thread_compositor_task_runner =
-        render_thread->main_thread_compositor_task_runner();
-  }
-  scoped_ptr<cc::BeginFrameSource> external_begin_frame_source;
-#if defined(OS_ANDROID)
-  if (SynchronousCompositorFactory* factory =
-      SynchronousCompositorFactory::GetInstance()) {
-    DCHECK(settings.use_external_begin_frame_source);
-    external_begin_frame_source =
-        factory->CreateExternalBeginFrameSource(widget_->routing_id());
-  }
-#endif
-  if (render_thread &&
-      !external_begin_frame_source.get() &&
-      settings.use_external_begin_frame_source) {
-    external_begin_frame_source.reset(new CompositorExternalBeginFrameSource(
-                                              widget_->routing_id()));
-  }
-  if (compositor_message_loop_proxy.get()) {
-    layer_tree_host_ =
-        cc::LayerTreeHost::CreateThreaded(this,
-                                          shared_bitmap_manager,
-                                          gpu_memory_buffer_manager,
-                                          settings,
-                                          main_thread_compositor_task_runner,
-                                          compositor_message_loop_proxy,
-                                          external_begin_frame_source.Pass());
-  } else {
-    layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
-                           this,
-                           this,
-                           shared_bitmap_manager,
-                           gpu_memory_buffer_manager,
-                           settings,
-                           main_thread_compositor_task_runner,
-                           external_begin_frame_source.Pass());
-  }
-  DCHECK(layer_tree_host_);
-}
-
 void RenderWidgetCompositor::setSurfaceReady() {
-  // In tests without a RenderThreadImpl, don't set ready as this kicks
-  // off creating output surfaces that the test can't create.
-  if (RenderThreadImpl::current())
-    layer_tree_host_->SetLayerTreeHostClientReady();
+  layer_tree_host_->SetLayerTreeHostClientReady();
 }
 
 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
   layer_tree_host_->SetRootLayer(
       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 }
@@ skipping 143 matching lines @@
 
 void RenderWidgetCompositor::compositeAndReadbackAsync(
     blink::WebCompositeAndReadbackAsyncCallback* callback) {
   DCHECK(!temporary_copy_output_request_);
   temporary_copy_output_request_ =
       cc::CopyOutputRequest::CreateBitmapRequest(
           base::Bind(&CompositeAndReadbackAsyncCallback, callback));
   // Force a commit to happen. The temporary copy output request will
   // be installed after layout which will happen as a part of the commit, when
   // there is guaranteed to be a root layer.
-  if (!threaded_ &&
+  bool threaded = !!compositor_deps_->GetCompositorImplThreadTaskRunner().get();
+  if (!threaded &&
       !layer_tree_host_->settings().single_thread_proxy_scheduler) {
     layer_tree_host_->Composite(gfx::FrameTime::Now());
   } else {
     layer_tree_host_->SetNeedsCommit();
   }
 }
 
 void RenderWidgetCompositor::finishAllRendering() {
   layer_tree_host_->FinishAllRendering();
 }
@@ skipping 48 matching lines @@
 }
 
 void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
   begin_main_frame_time_ = args.frame_time;
   begin_main_frame_interval_ = args.interval;
   double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
   double deadline_sec = (args.deadline - base::TimeTicks()).InSecondsF();
   double interval_sec = args.interval.InSecondsF();
   WebBeginFrameArgs web_begin_frame_args =
       WebBeginFrameArgs(frame_time_sec, deadline_sec, interval_sec);
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  if (render_thread)  // Can be null in tests.
-    render_thread->renderer_scheduler()->WillBeginFrame(args);
+  compositor_deps_->GetRendererScheduler()->WillBeginFrame(args);
   widget_->webwidget()->beginFrame(web_begin_frame_args);
 }
 
 void RenderWidgetCompositor::Layout() {
   widget_->webwidget()->layout();
 
   if (temporary_copy_output_request_) {
     DCHECK(layer_tree_host_->root_layer());
     layer_tree_host_->root_layer()->RequestCopyOfOutput(
         temporary_copy_output_request_.Pass());
@@ skipping 73 matching lines @@
       // Convert to 32-bit microseconds first to avoid costly 64-bit division.
       int32 idle_time_in_us = idle_time.InMicroseconds();
       int32 idle_time_in_ms = idle_time_in_us / 1000;
       if (idle_time_in_ms)
         blink::mainThreadIsolate()->IdleNotification(idle_time_in_ms);
     }
   }
 
   widget_->DidCommitCompositorFrame();
   widget_->didBecomeReadyForAdditionalInput();
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  if (render_thread)  // Can be null in tests.
-    render_thread->renderer_scheduler()->DidCommitFrameToCompositor();
+  compositor_deps_->GetRendererScheduler()->DidCommitFrameToCompositor();
 }
 
 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
   widget_->didCommitAndDrawCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
   widget_->didCompleteSwapBuffers();
-  if (!threaded_)
+  bool threaded = !!compositor_deps_->GetCompositorImplThreadTaskRunner().get();
+  if (!threaded)
     widget_->OnSwapBuffersComplete();
 }
 
 void RenderWidgetCompositor::ScheduleAnimation() {
   widget_->scheduleAnimation();
 }
 
 void RenderWidgetCompositor::DidPostSwapBuffers() {
   widget_->OnSwapBuffersPosted();
 }
 
 void RenderWidgetCompositor::DidAbortSwapBuffers() {
   widget_->OnSwapBuffersAborted();
 }
 
 void RenderWidgetCompositor::RateLimitSharedMainThreadContext() {
   cc::ContextProvider* provider =
-      RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
+      compositor_deps_->GetSharedMainThreadContextProvider();
   provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
 }
 
 }  // namespace content