Revert of RenderWidgetCompositor should be decoupled from RenderWidget.

content/renderer/gpu/render_widget_compositor.cc

Index: content/renderer/gpu/render_widget_compositor.cc
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index db54a510ce0e1674709443e4a4823a30cce8cae8..4048e3b6ffddd6a697ba655bed0f423f2a982f92 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -45,7 +45,6 @@
 #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"
@@ -55,6 +54,7 @@
 #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"
 
@@ -135,7 +135,7 @@
   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
@@ -180,7 +180,7 @@
   }
 #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
 
@@ -205,27 +205,27 @@
 
 // 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) {}
-
-void RenderWidgetCompositor::Initialize(float device_scale_factor) {
+      weak_factory_(this) {
+}
+
+void RenderWidgetCompositor::Initialize() {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
@@ -257,7 +257,7 @@
   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,
@@ -456,7 +456,7 @@
   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;
@@ -489,7 +489,8 @@
 
   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;
@@ -864,7 +865,7 @@
 }
 
 void RenderWidgetCompositor::WillBeginMainFrame() {
-  delegate_->WillBeginCompositorFrame();
+  widget_->WillBeginCompositorFrame();
 }
 
 void RenderWidgetCompositor::DidBeginMainFrame() {
@@ -873,7 +874,7 @@
 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() {
@@ -881,7 +882,8 @@
 }
 
 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.
@@ -901,16 +903,24 @@
     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();
@@ -944,35 +954,35 @@
 
 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) {
@@ -985,14 +995,39 @@
   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(