Make RenderWidget responsible for the composited view's lifetime

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "cc/layer_tree_host.h"
+#include "cc/thread.h"
+#include "cc/thread_impl.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
+#include "content/renderer/gpu/compositor_thread.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
 #include "ipc/ipc_sync_message.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebHelperPlugin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPagePopup.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenu.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenuInfo.h"
@@ skipping 209 matching lines @@
     return false;
   }
 }
 
 // This is used to complete pending inits and non-pending inits.
 void RenderWidget::CompleteInit() {
   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 
   init_complete_ = true;
 
-  if (webwidget_) {
-    webwidget_->setCompositorSurfaceReady();
-    if (is_threaded_compositing_enabled_)
-      webwidget_->enterForceCompositingMode(true);
+  if (webwidget_ && is_threaded_compositing_enabled_) {
+    webwidget_->enterForceCompositingMode(true);
+  }
+  if (web_layer_tree_view_) {
+    web_layer_tree_view_->setSurfaceReady();
   }
   DoDeferredUpdate();
 
   Send(new ViewHostMsg_RenderViewReady(routing_id_));
 }
 
 void RenderWidget::SetSwappedOut(bool is_swapped_out) {
   // We should only toggle between states.
   DCHECK(is_swapped_out_ != is_swapped_out);
   is_swapped_out_ = is_swapped_out;
@@ skipping 398 matching lines @@
         INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   }
 
   IPC::Message* response =
       new ViewHostMsg_HandleInputEvent_ACK(routing_id_, input_event->type,
                                            ack_result);
   bool event_type_gets_rate_limited =
       input_event->type == WebInputEvent::MouseMove ||
       input_event->type == WebInputEvent::MouseWheel ||
       WebInputEvent::isTouchEventType(input_event->type);
+
+  bool frame_pending = paint_aggregator_.HasPendingUpdate();
+  if (is_accelerated_compositing_active_) {
+    frame_pending = web_layer_tree_view_ &&
+                    web_layer_tree_view_->commitRequested();
+  }
+
   bool is_input_throttled =
       throttle_input_events_ &&
-      ((webwidget_ ? webwidget_->isInputThrottled() : false) ||
-      paint_aggregator_.HasPendingUpdate());
+      frame_pending;
 
   if (event_type_gets_rate_limited && is_input_throttled && !is_hidden_) {
     // We want to rate limit the input events in this case, so we'll wait for
     // painting to finish before ACKing this message.
     if (pending_input_event_ack_.get()) {
       // As two different kinds of events could cause us to postpone an ack
       // we send it now, if we have one pending. The Browser should never
       // send us the same kind of event we are delaying the ack for.
       Send(pending_input_event_ack_.release());
     }
@@ skipping 217 matching lines @@
   if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
     TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
     animation_floor_time_ = now + animationInterval;
     // Set a timer to call us back after animationInterval before
     // running animation callbacks so that if a callback requests another
     // we'll be sure to run it at the proper time.
     animation_timer_.Stop();
     animation_timer_.Start(FROM_HERE, animationInterval, this,
                            &RenderWidget::AnimationCallback);
     animation_update_pending_ = false;
-    webwidget_->animate(0.0);
+    if (is_accelerated_compositing_active_ && web_layer_tree_view_) {
+      web_layer_tree_view_->layer_tree_host()->updateAnimations(
+          base::TimeTicks::Now());
+    } else {
+      webwidget_->animate(0.0);
+    }
     return;
   }
   TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
   if (!animation_timer_.IsRunning()) {
     // This code uses base::Time::Now() to calculate the floor and next fire
     // time because javascript's Date object uses base::Time::Now().  The
     // message loop uses base::TimeTicks, which on windows can have a
     // different granularity than base::Time.
     // The upshot of all this is that this function might be called before
     // base::Time::Now() has advanced past the animation_floor_time_.  To
@@ skipping 366 matching lines @@
     using_asynchronous_swapbuffers_ = false;
 
   // In single-threaded mode, we exit force compositing mode and re-enter in
   // DoDeferredUpdate() if appropriate. In threaded compositing mode,
   // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
   // entering force compositing mode at the appropriate times.
   if (!is_threaded_compositing_enabled_)
     webwidget_->enterForceCompositingMode(false);
 }
 
+void RenderWidget::initializeLayerTreeView(
+    WebKit::WebLayerTreeViewClient* client,
+    const WebKit::WebLayer& root_layer,
+    const WebKit::WebLayerTreeView::Settings& settings) {
+  DCHECK(!web_layer_tree_view_);
+  web_layer_tree_view_.reset(new WebKit::WebLayerTreeViewImpl(client));
+
+  scoped_ptr<cc::Thread> impl_thread;
+  CompositorThread* compositor_thread =
+      RenderThreadImpl::current()->compositor_thread();
+  if (compositor_thread)
+    impl_thread = cc::ThreadImpl::createForDifferentThread(
+        compositor_thread->message_loop()->message_loop_proxy());
+  if (!web_layer_tree_view_->initialize(settings, impl_thread.Pass())) {
+    web_layer_tree_view_.reset();
+    return;
+  }
+  web_layer_tree_view_->setRootLayer(root_layer);
+  if (init_complete_) {
+    web_layer_tree_view_->setSurfaceReady();
+  }
+}
+
+WebKit::WebLayerTreeView* RenderWidget::layerTreeView() {
+  return web_layer_tree_view_.get();
+}
+
 void RenderWidget::willBeginCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
 
   DCHECK(RenderThreadImpl::current()->compositor_thread());
 
   // The following two can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateSelectionBounds();
 
@@ skipping 130 matching lines @@
   // in Javascript.  If we ask the RendwerWidgetHost to close now, the window
   // could be closed before the JS finishes executing.  So instead, post a
   // message back to the message loop, which won't run until the JS is
   // complete, and then the Close message can be sent.
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
 }
 
 void RenderWidget::Close() {
   if (webwidget_) {
+    webwidget_->willCloseLayerTreeView();
+    web_layer_tree_view_.reset();
     webwidget_->close();
     webwidget_ = NULL;
   }
 }
 
 WebRect RenderWidget::windowRect() {
   if (pending_window_rect_count_)
     return pending_window_rect_;
 
   return view_screen_rect_;
@@ skipping 194 matching lines @@
   Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, bounds.size()));
 }
 
 void RenderWidget::OnRepaint(const gfx::Size& size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   set_next_paint_is_repaint_ack();
   if (is_accelerated_compositing_active_) {
-    webwidget_->setNeedsRedraw();
+    if (web_layer_tree_view_)
+      web_layer_tree_view_->setNeedsRedraw();
     scheduleComposite();
   } else {
     gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
     didInvalidateRect(repaint_rect);
   }
 }
 
 void RenderWidget::OnSmoothScrollCompleted(int gesture_id) {
   PendingSmoothScrollGestureMap::iterator it =
       pending_smooth_scroll_gestures_.find(gesture_id);
@@ skipping 313 matching lines @@
        i != plugin_window_moves_.end(); ++i) {
     if (i->window == window) {
       plugin_window_moves_.erase(i);
       break;
     }
   }
 }
 
 void RenderWidget::GetRenderingStats(
     WebKit::WebRenderingStatsImpl& stats) const {
-  webwidget()->renderingStats(stats);
+  if (web_layer_tree_view_)
+    web_layer_tree_view_->renderingStats(stats);
 
   stats.rendering_stats.numAnimationFrames +=
       software_stats_.numAnimationFrames;
   stats.rendering_stats.numFramesSentToScreen +=
       software_stats_.numFramesSentToScreen;
   stats.rendering_stats.totalPaintTimeInSeconds +=
       software_stats_.totalPaintTimeInSeconds;
   stats.rendering_stats.totalPixelsPainted +=
       software_stats_.totalPixelsPainted;
   stats.rendering_stats.totalRasterizeTimeInSeconds +=
@@ skipping 40 matching lines @@
 
 bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
   return false;
 }
 
 bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
   return true;
 }
 
 }  // namespace content