Revert of 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(float initial_device_scale_factor) {
+gfx::Size CalculateDefaultTileSize(RenderWidget* widget) {
   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 (initial_device_scale_factor >= 2.0f)
+  if (widget->screen_info().deviceScaleFactor >= 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(
-    RenderWidgetCompositorDelegate* delegate,
-    float device_scale_factor,
+    RenderWidget* widget,
     CompositorDependencies* compositor_deps) {
   scoped_ptr<RenderWidgetCompositor> compositor(
-      new RenderWidgetCompositor(delegate, compositor_deps));
-  compositor->Initialize(device_scale_factor);
+      new RenderWidgetCompositor(widget, compositor_deps));
+  compositor->Initialize();
   return compositor;
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
-    RenderWidgetCompositorDelegate* delegate,
+    RenderWidget* widget,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
-      delegate_(delegate),
+      widget_(widget),
       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(float device_scale_factor) {
+void RenderWidgetCompositor::Initialize() {
   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(device_scale_factor);
+  settings.default_tile_size = CalculateDefaultTileSize(widget_);
   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 (delegate_->ForOOPIF()) {
+  if (widget_->for_oopif()) {
     // 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 = delegate_->CreateExternalBeginFrameSource();
+    external_begin_frame_source =
+        compositor_deps_->CreateExternalBeginFrameSource(widget_->routing_id());
   }
 
   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() {
-  delegate_->WillBeginCompositorFrame();
+  widget_->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();
-  delegate_->BeginMainFrame(frame_time_sec);
+  widget_->webwidget()->beginFrame(frame_time_sec);
 }
 
 void RenderWidgetCompositor::BeginMainFrameNotExpectedSoon() {
   compositor_deps_->GetRendererScheduler()->BeginFrameNotExpectedSoon();
 }
 
 void RenderWidgetCompositor::UpdateLayerTreeHost() {
-  delegate_->UpdateVisualState();
+  widget_->webwidget()->updateAllLifecyclePhases();
+
   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) {
-  delegate_->ApplyViewportDeltas(inner_delta, outer_delta,
-                                 elastic_overscroll_delta, page_scale,
-                                 top_controls_delta);
+  widget_->webwidget()->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(
-      delegate_->CreateOutputSurface(fallback));
+  scoped_ptr<cc::OutputSurface> surface(widget_->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_);
-  delegate_->DidCommitCompositorFrame();
+  widget_->DidCommitCompositorFrame();
   compositor_deps_->GetRendererScheduler()->DidCommitFrameToCompositor();
 }
 
 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
-  delegate_->DidCommitAndDrawCompositorFrame();
+  widget_->DidCommitAndDrawCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
-  delegate_->DidCompleteSwapBuffers();
+  widget_->DidCompleteSwapBuffers();
   bool threaded = !!compositor_deps_->GetCompositorImplThreadTaskRunner().get();
   if (!threaded)
-    delegate_->OnSwapBuffersComplete();
+    widget_->OnSwapBuffersComplete();
 }
 
 void RenderWidgetCompositor::DidCompletePageScaleAnimation() {
-  delegate_->DidCompletePageScaleAnimation();
+  widget_->DidCompletePageScaleAnimation();
 }
 
 void RenderWidgetCompositor::ScheduleAnimation() {
-  delegate_->ScheduleAnimation();
+  widget_->scheduleAnimation();
 }
 
 void RenderWidgetCompositor::DidPostSwapBuffers() {
-  delegate_->OnSwapBuffersPosted();
+  widget_->OnSwapBuffersPosted();
 }
 
 void RenderWidgetCompositor::DidAbortSwapBuffers() {
-  delegate_->OnSwapBuffersAborted();
+  widget_->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);
-  delegate_->ForwardCompositorProto(serialized);
+  widget_->ForwardCompositorProto(serialized);
 }
 
 void RenderWidgetCompositor::RecordFrameTimingEvents(
     scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
-  delegate_->RecordFrameTimingEvents(std::move(composite_events),
-                                     std::move(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);
+  }
 }
 
 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