RenderWidgetCompositor should be decoupled from RenderWidget.

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 <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 27 matching lines @@
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/latency_info_swap_promise_monitor.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/remote_proto_channel.h"
 #include "components/scheduler/renderer/renderer_scheduler.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/render_widget_compositor_delegate.h"
 #include "content/renderer/input/input_handler_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebLayoutAndPaintAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebSelection.h"
-#include "third_party/WebKit/public/web/WebWidget.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/native_theme/native_theme_switches.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "content/renderer/android/synchronous_compositor_factory.h"
 #include "ui/gfx/android/device_display_info.h"
 #endif
 
 namespace base {
@@ skipping 60 matching lines @@
 cc::LayerSelection ConvertWebSelection(const WebSelection& web_selection) {
   cc::LayerSelection cc_selection;
   cc_selection.start = ConvertWebSelectionBound(web_selection, true);
   cc_selection.end = ConvertWebSelectionBound(web_selection, false);
   cc_selection.is_editable = web_selection.isEditable();
   cc_selection.is_empty_text_form_control =
       web_selection.isEmptyTextFormControl();
   return cc_selection;
 }
 
-gfx::Size CalculateDefaultTileSize(RenderWidget* widget) {
+gfx::Size CalculateDefaultTileSize(float device_scale_factor) {
   int default_tile_size = 256;
 #if defined(OS_ANDROID)
   // TODO(epenner): unify this for all platforms if it
   // makes sense (http://crbug.com/159524)
 
   gfx::DeviceDisplayInfo info;
   bool real_size_supported = true;
   int display_width = info.GetPhysicalDisplayWidth();
   int display_height = info.GetPhysicalDisplayHeight();
   if (display_width == 0 || display_height == 0) {
@@ skipping 24 matching lines @@
     // We don't know the exact resolution due to screen controls etc.
     // So this just estimates the values above using tile counts.
     int numTiles = (display_width * display_height) / (256 * 256);
     if (numTiles > 16)
       default_tile_size = 384;
     if (numTiles >= 40)
       default_tile_size = 512;
   }
 #elif defined(OS_CHROMEOS)
   // Use 512 for high DPI (dsf=2.0f) devices.
-  if (widget->screen_info().deviceScaleFactor >= 2.0f)
+  if (device_scale_factor >= 2.0f)
     default_tile_size = 512;
 #endif
 
   return gfx::Size(default_tile_size, default_tile_size);
 }
 
 // Check cc::TopControlsState, and blink::WebTopControlsState
 // are kept in sync.
 static_assert(int(blink::WebTopControlsBoth) == int(cc::BOTH),
               "mismatching enums: BOTH");
 static_assert(int(blink::WebTopControlsHidden) == int(cc::HIDDEN),
               "mismatching enums: HIDDEN");
 static_assert(int(blink::WebTopControlsShown) == int(cc::SHOWN),
               "mismatching enums: SHOWN");
 
 static cc::TopControlsState ConvertTopControlsState(
     WebTopControlsState state) {
   return static_cast<cc::TopControlsState>(state);
 }
 
 }  // namespace
 
 // static
 scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
-    RenderWidget* widget,
+    RenderWidgetCompositorDelegate* delegate,
+    float device_scale_factor,

[piman, 2016/01/13 22:09:30]

Minor nit, this makes it sound like the device_scale_factor is fixed in time,
whereas in truth it can change if a tab is moved to a different screen. I guess
we're only using the initial DSF for the tile size computation, maybe that one
should move to RenderWidget, and explicitly pass the default tile size here?
(dunno if mus would use different heuristics there)

[Fady Samuel, 2016/01/13 23:48:13]

Hmm, tile size seems like a compositor detail. I'd prefer not to put it in
RenderWidget. Perhaps I can add a GetDeviceScaleFactor() to the delegate?

[piman, 2016/01/14 00:13:23]

There's already RWC::setDeviceScaleFactor, I wouldn't want 3 ways of passing the
same info.
Maybe simply naming it initial_device_scale_factor to make it clear that it's
not set in stone?

     CompositorDependencies* compositor_deps) {
   scoped_ptr<RenderWidgetCompositor> compositor(
-      new RenderWidgetCompositor(widget, compositor_deps));
-  compositor->Initialize();
+      new RenderWidgetCompositor(delegate, compositor_deps));
+  compositor->Initialize(device_scale_factor);
   return compositor;
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
-    RenderWidget* widget,
+    RenderWidgetCompositorDelegate* delegate,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
-      widget_(widget),
+      delegate_(delegate),
       compositor_deps_(compositor_deps),
       never_visible_(false),
       layout_and_paint_async_callback_(nullptr),
       remote_proto_channel_receiver_(nullptr),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
-void RenderWidgetCompositor::Initialize() {
+void RenderWidgetCompositor::Initialize(float device_scale_factor) {
   base::CommandLine* cmd = base::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;
 
   if (cmd->HasSwitch(switches::kDisableGpuVsync)) {
     std::string display_vsync_string =
@@ skipping 11 matching lines @@
       cmd->HasSwitch(cc::switches::kEnableMainFrameBeforeActivation) &&
       !cmd->HasSwitch(cc::switches::kDisableMainFrameBeforeActivation);
   settings.accelerated_animation_enabled =
       compositor_deps_->IsThreadedAnimationEnabled();
 
   settings.use_compositor_animation_timelines =
       !cmd->HasSwitch(switches::kDisableCompositorAnimationTimelines);
   blink::WebRuntimeFeatures::enableCompositorAnimationTimelines(
       settings.use_compositor_animation_timelines);
 
-  settings.default_tile_size = CalculateDefaultTileSize(widget_);
+  settings.default_tile_size = CalculateDefaultTileSize(device_scale_factor);
   if (cmd->HasSwitch(switches::kDefaultTileWidth)) {
     int tile_width = 0;
     GetSwitchValueAsInt(*cmd,
                         switches::kDefaultTileWidth,
                         1,
                         std::numeric_limits<int>::max(),
                         &tile_width);
     settings.default_tile_size.set_width(tile_width);
   }
   if (cmd->HasSwitch(switches::kDefaultTileHeight)) {
@@ skipping 178 matching lines @@
   if (cmd->HasSwitch(switches::kDisableLowResTiling))
     settings.create_low_res_tiling = false;
   if (cmd->HasSwitch(cc::switches::kEnableBeginFrameScheduling))
     settings.use_external_begin_frame_source = true;
 
   settings.renderer_settings.use_rgba_4444_textures |=
       cmd->HasSwitch(switches::kEnableRGBA4444Textures);
   settings.renderer_settings.use_rgba_4444_textures &=
       !cmd->HasSwitch(switches::kDisableRGBA4444Textures);
 
-  if (widget_->for_oopif()) {
+  if (delegate_->ForOOPIF()) {
     // TODO(simonhong): Apply BeginFrame scheduling for OOPIF.
     // See crbug.com/471411.
     settings.use_external_begin_frame_source = false;
   }
 
   settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024;  // 32MB
   // Use 1/4th of staging buffers on low-end devices.
   if (base::SysInfo::IsLowEndDevice())
     settings.max_staging_buffer_usage_in_bytes /= 4;
 
@@ skipping 12 matching lines @@
   cc::TaskGraphRunner* task_graph_runner =
       compositor_deps_->GetTaskGraphRunner();
 
   bool use_remote_compositing = cmd->HasSwitch(switches::kUseRemoteCompositing);
 
   if (use_remote_compositing)
     settings.use_external_begin_frame_source = false;
 
   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());
+    external_begin_frame_source = delegate_->CreateExternalBeginFrameSource();
   }
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = shared_bitmap_manager;
   params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
   params.settings = &settings;
   params.task_graph_runner = task_graph_runner;
   params.main_task_runner = main_thread_compositor_task_runner;
   params.external_begin_frame_source = std::move(external_begin_frame_source);
@@ skipping 354 matching lines @@
 
 void RenderWidgetCompositor::setTopControlsHeight(float height, bool shrink) {
     layer_tree_host_->SetTopControlsHeight(height, shrink);
 }
 
 void RenderWidgetCompositor::setTopControlsShownRatio(float ratio) {
   layer_tree_host_->SetTopControlsShownRatio(ratio);
 }
 
 void RenderWidgetCompositor::WillBeginMainFrame() {
-  widget_->WillBeginCompositorFrame();
+  delegate_->WillBeginCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidBeginMainFrame() {
 }
 
 void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
   compositor_deps_->GetRendererScheduler()->WillBeginFrame(args);
   double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
-  widget_->webwidget()->beginFrame(frame_time_sec);
+  delegate_->BeginMainFrame(frame_time_sec);
 }
 
 void RenderWidgetCompositor::BeginMainFrameNotExpectedSoon() {
   compositor_deps_->GetRendererScheduler()->BeginFrameNotExpectedSoon();
 }
 
 void RenderWidgetCompositor::UpdateLayerTreeHost() {
-  widget_->webwidget()->updateAllLifecyclePhases();

[piman, 2016/01/13 22:09:30]

So if I understand correctly, this moved from here to the end of BeginMainFrame.
Relative to the code in LayerTreeHost, it means it moves before AnimateLayers.
Not knowing the details of updateAllLifecyclePhases, I don't know if it's ok or
not. +danakj/chrishtr, do you know?

[danakj, 2016/01/13 22:24:33]

Take a look here, the time when things run matters:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/proxy_mai...

During the "animate step" requests for new frames will in fact cause another new
frame.

During the "update step" which is the UpdateLayerTreeHost() method here,
properties can be changed on layers without causing another frame to happen.

BeginMainFrame() happens before the animate and has properties more like the
animate step.

Also UpdateLayers does not always happen unless it's requested, so moving this
work out of this function changes it to run always instead of obeying the logic
in proxy_main there.

[Fady Samuel, 2016/01/13 23:48:13]

I don't want to change semantics in this CL so I've added a UpdateVisualState
call out.

-
   if (temporary_copy_output_request_) {
     // For WebViewImpl, this will always have a root layer.  For other widgets,
     // the widget may be closed before servicing this request, so ignore it.
     if (cc::Layer* root_layer = layer_tree_host_->root_layer()) {
       root_layer->RequestCopyOfOutput(
           std::move(temporary_copy_output_request_));
     } else {
       temporary_copy_output_request_->SendEmptyResult();
       temporary_copy_output_request_ = nullptr;
     }
   }
 }
 
 void RenderWidgetCompositor::ApplyViewportDeltas(
     const gfx::Vector2dF& inner_delta,
     const gfx::Vector2dF& outer_delta,
     const gfx::Vector2dF& elastic_overscroll_delta,
     float page_scale,
     float top_controls_delta) {
-  widget_->webwidget()->applyViewportDeltas(
-      inner_delta,
-      outer_delta,
-      elastic_overscroll_delta,
-      page_scale,
-      top_controls_delta);
+  delegate_->ApplyViewportDeltas(inner_delta, outer_delta,
+                                 elastic_overscroll_delta, page_scale,
+                                 top_controls_delta);
 }
 
 void RenderWidgetCompositor::RequestNewOutputSurface() {
-  // If the host is closing, then no more compositing is possible.  This
-  // prevents shutdown races between handling the close message and
-  // the CreateOutputSurface task.
-  if (widget_->host_closing())
-    return;
-
   bool fallback =
       num_failed_recreate_attempts_ >= OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK;
-  scoped_ptr<cc::OutputSurface> surface(widget_->CreateOutputSurface(fallback));
+  scoped_ptr<cc::OutputSurface> surface(
+      delegate_->CreateOutputSurface(fallback));
 
   if (!surface) {
     DidFailToInitializeOutputSurface();
     return;
   }
 
   DCHECK_EQ(surface->capabilities().max_frames_pending, 1);
 
   layer_tree_host_->SetOutputSurface(std::move(surface));
 }
@@ skipping 13 matching lines @@
       FROM_HERE, base::Bind(&RenderWidgetCompositor::RequestNewOutputSurface,
                             weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetCompositor::WillCommit() {
   InvokeLayoutAndPaintCallback();
 }
 
 void RenderWidgetCompositor::DidCommit() {
   DCHECK(!temporary_copy_output_request_);
-  widget_->DidCommitCompositorFrame();
+  delegate_->DidCommitCompositorFrame();
   compositor_deps_->GetRendererScheduler()->DidCommitFrameToCompositor();
 }
 
 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
-  widget_->DidCommitAndDrawCompositorFrame();
+  delegate_->DidCommitAndDrawCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
-  widget_->DidCompleteSwapBuffers();
+  delegate_->DidCompleteSwapBuffers();
   bool threaded = !!compositor_deps_->GetCompositorImplThreadTaskRunner().get();
   if (!threaded)
-    widget_->OnSwapBuffersComplete();
+    delegate_->OnSwapBuffersComplete();
 }
 
 void RenderWidgetCompositor::DidCompletePageScaleAnimation() {
-  widget_->DidCompletePageScaleAnimation();
+  delegate_->DidCompletePageScaleAnimation();
 }
 
 void RenderWidgetCompositor::ScheduleAnimation() {
-  widget_->scheduleAnimation();
+  delegate_->ScheduleAnimation();
 }
 
 void RenderWidgetCompositor::DidPostSwapBuffers() {
-  widget_->OnSwapBuffersPosted();
+  delegate_->OnSwapBuffersPosted();
 }
 
 void RenderWidgetCompositor::DidAbortSwapBuffers() {
-  widget_->OnSwapBuffersAborted();
+  delegate_->OnSwapBuffersAborted();
 }
 
 void RenderWidgetCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   remote_proto_channel_receiver_ = receiver;
 }
 
 void RenderWidgetCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
   int signed_size = proto.ByteSize();
   size_t unsigned_size = base::checked_cast<size_t>(signed_size);
   std::vector<uint8_t> serialized(unsigned_size);
   proto.SerializeToArray(serialized.data(), signed_size);
-  widget_->ForwardCompositorProto(serialized);
+  delegate_->ForwardCompositorProto(serialized);
 }
 
 void RenderWidgetCompositor::RecordFrameTimingEvents(
     scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
-  for (const auto& composite_event : *composite_events ) {
-    int64_t frameId = composite_event.first;
-    const std::vector<cc::FrameTimingTracker::CompositeTimingEvent>& events =
-        composite_event.second;
-    std::vector<blink::WebFrameTimingEvent> webEvents;
-    for (size_t i = 0; i < events.size(); ++i) {
-      webEvents.push_back(blink::WebFrameTimingEvent(
-          events[i].frame_id,
-          (events[i].timestamp - base::TimeTicks()).InSecondsF()));
-    }
-    widget_->webwidget()->recordFrameTimingEvent(
-        blink::WebWidget::CompositeEvent, frameId, webEvents);
-  }
-  for (const auto& main_frame_event : *main_frame_events ) {
-    int64_t frameId = main_frame_event.first;
-    const std::vector<cc::FrameTimingTracker::MainFrameTimingEvent>& events =
-        main_frame_event.second;
-    std::vector<blink::WebFrameTimingEvent> webEvents;
-    for (size_t i = 0; i < events.size(); ++i) {
-      webEvents.push_back(blink::WebFrameTimingEvent(
-          events[i].frame_id,
-          (events[i].timestamp - base::TimeTicks()).InSecondsF(),
-          (events[i].end_time - base::TimeTicks()).InSecondsF()));
-    }
-    widget_->webwidget()->recordFrameTimingEvent(
-        blink::WebWidget::RenderEvent, frameId, webEvents);
-  }
+  delegate_->RecordFrameTimingEvents(std::move(composite_events),
+                                     std::move(main_frame_events));
 }
 
 void RenderWidgetCompositor::SetSurfaceIdNamespace(
     uint32_t surface_id_namespace) {
   layer_tree_host_->set_surface_id_namespace(surface_id_namespace);
 }
 
 void RenderWidgetCompositor::OnHandleCompositorProto(
     const std::vector<uint8_t>& proto) {
   DCHECK(remote_proto_channel_receiver_);
@@ skipping 88 matching lines @@
 #endif
   return actual;
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content