Splits SmoothGestureController from RenderWidgetHostImpl

content/browser/renderer_host/render_widget_host_impl.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/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 11 matching lines @@
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
+#include "content/browser/renderer_host/smooth_scroll_gesture_controller.h"
 #include "content/browser/renderer_host/tap_suppression_controller.h"
 #include "content/browser/renderer_host/touch_event_queue.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
-#include "content/port/browser/smooth_scroll_gesture.h"
 #include "content/public/browser/compositor_util.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 30 matching lines @@
 
 namespace content {
 namespace {
 
 // How long to (synchronously) wait for the renderer to respond with a
 // PaintRect message, when our backing-store is invalid, before giving up and
 // returning a null or incorrectly sized backing-store from GetBackingStore.
 // This timeout impacts the "choppiness" of our window resize perf.
 const int kPaintMsgTimeoutMS = 50;
 
-// How many milliseconds apart synthetic scroll messages should be sent.
-static const int kSyntheticScrollMessageIntervalMs = 8;
-
 // Returns |true| if the two wheel events should be coalesced.
 bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
                                     const WebMouseWheelEvent& new_event) {
   return last_event.modifiers == new_event.modifiers &&
          last_event.scrollByPage == new_event.scrollByPage &&
          last_event.hasPreciseScrollingDeltas
              == new_event.hasPreciseScrollingDeltas &&
          last_event.phase == new_event.phase &&
          last_event.momentumPhase == new_event.momentumPhase;
 }
@@ skipping 44 matching lines @@
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
-      tick_active_smooth_scroll_gestures_task_posted_(false),
+      smooth_scroll_gesture_controller_(new SmoothScrollGestureController()),
       touch_event_queue_(new TouchEventQueue(this)),
       gesture_event_filter_(new GestureEventFilter(this)) {
   CHECK(delegate_);
   if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
     surface_id_ = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
         process_->GetID(),
         routing_id_);
   } else {
     // TODO(piman): This is a O(N) lookup, where we could forward the
@@ skipping 106 matching lines @@
   if (!view_)
     return;
 
   last_view_screen_rect_ = view_->GetViewBounds();
   last_window_screen_rect_ = view_->GetBoundsInRootWindow();
   Send(new ViewMsg_UpdateScreenRects(
       GetRoutingID(), last_view_screen_rect_, last_window_screen_rect_));
   waiting_for_screen_rects_ack_ = true;
 }
 
 int RenderWidgetHostImpl::SyntheticScrollMessageInterval() const {

[rjkroege, 2013/02/11 22:47:27]

who accesses this? perhaps they could speak to the SSGC directly?

-  return kSyntheticScrollMessageIntervalMs;
+  return smooth_scroll_gesture_controller_->SyntheticScrollMessageInterval();
 }
 
 void RenderWidgetHostImpl::Init() {
   DCHECK(process_->HasConnection());
 
   renderer_initialized_ = true;
 
   GpuSurfaceTracker::Get()->SetSurfaceHandle(
       surface_id_, GetCompositingSurface());
 
@@ skipping 839 matching lines @@
       // However, the touch-events are not sent to the renderer. So send and ACK
       // to the touch-event queue immediately. Mark the event as not processed,
       // to make sure that the touch-scroll gesture that initiated the
       // overscroll is updated properly.
       touch_event_queue_->ProcessTouchAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     }
     return;
   }
 
   in_process_event_types_.push(input_event.type);
+  smooth_scroll_gesture_controller_->OnForwardInputEvent();
 
   // Transmit any pending wheel events on a non-wheel event. This ensures that
   // the renderer receives the final PhaseEnded wheel event, which is necessary
   // to terminate rubber-banding, for example.
   if (input_event.type != WebInputEvent::MouseWheel) {
     for (size_t i = 0; i < coalesced_mouse_wheel_events_.size(); ++i) {
       SendInputEvent(coalesced_mouse_wheel_events_[i],
                      sizeof(WebMouseWheelEvent), false);
     }
     coalesced_mouse_wheel_events_.clear();
@@ skipping 551 matching lines @@
     in_process_event_types_.pop();
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_InputEventDelta", delta);
 
   // Cancel pending hung renderer checks since the renderer is responsive.
   if (decrement_in_flight_event_count() == 0)
     StopHangMonitorTimeout();
 
-  // If an input ack is pending, then hold off ticking the gesture
-  // until we get an input ack.
-  if (in_process_event_types_.empty() &&
-      !active_smooth_scroll_gestures_.empty())
-    TickActiveSmoothScrollGesture();
+  smooth_scroll_gesture_controller_->OnInputEventACK(this);
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
     process_->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
@@ skipping 19 matching lines @@
   // (OnInputEventAck) method, but not on other platforms; using
   // 'void' instead is just as safe (since NotificationSource
   // is not actually typesafe) and avoids this error.
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       Source<void>(this),
       Details<int>(&type));
 }
 
 void RenderWidgetHostImpl::OnBeginSmoothScroll(
-    int gesture_id, const ViewHostMsg_BeginSmoothScroll_Params &params) {
+    int gesture_id, const ViewHostMsg_BeginSmoothScroll_Params& params) {
   if (!view_)
     return;
-  active_smooth_scroll_gestures_.insert(
-      std::make_pair(gesture_id,
-                     view_->CreateSmoothScrollGesture(
-                         params.scroll_down, params.pixels_to_scroll,
-                         params.mouse_event_x, params.mouse_event_y)));
-
-  // If an input ack is pending, then hold off ticking the gesture
-  // until we get an input ack.
-  if (!in_process_event_types_.empty())
-    return;
-  if (tick_active_smooth_scroll_gestures_task_posted_)
-    return;
-  TickActiveSmoothScrollGesture();
-}
-
-void RenderWidgetHostImpl::TickActiveSmoothScrollGesture() {
-  TRACE_EVENT0("input", "RenderWidgetHostImpl::TickActiveSmoothScrollGesture");
-  tick_active_smooth_scroll_gestures_task_posted_ = false;
-  if (active_smooth_scroll_gestures_.empty()) {
-    TRACE_EVENT_INSTANT0("input", "EarlyOut_NoActiveScrollGesture");
-    return;
-  }
-
-  base::TimeTicks now = TimeTicks::HighResNow();
-  base::TimeDelta preferred_interval =
-      base::TimeDelta::FromMilliseconds(kSyntheticScrollMessageIntervalMs);
-  base::TimeDelta time_until_next_ideal_interval =
-      (last_smooth_scroll_gestures_tick_time_ + preferred_interval) -
-      now;
-  if (time_until_next_ideal_interval.InMilliseconds() > 0) {
-    TRACE_EVENT_INSTANT1(
-        "input", "EarlyOut_TickedTooRecently",
-        "delay", time_until_next_ideal_interval.InMilliseconds());
-    // Post a task.
-    tick_active_smooth_scroll_gestures_task_posted_ = true;
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&RenderWidgetHostImpl::TickActiveSmoothScrollGesture,
-                   weak_factory_.GetWeakPtr()),
-        time_until_next_ideal_interval);
-    return;
-  }
-
-  last_smooth_scroll_gestures_tick_time_ = now;
-
-  // Separate ticking of gestures from sending their completion messages.
-  std::vector<int> ids_that_are_done;
-  for (SmoothScrollGestureMap::iterator it =
-           active_smooth_scroll_gestures_.begin();
-       it != active_smooth_scroll_gestures_.end();
-       ++it) {
-
-    bool active = it->second->ForwardInputEvents(now, this);
-    if (!active)
-      ids_that_are_done.push_back(it->first);
-  }
-
-  // Delete completed gestures and send their completion event.
-  for(size_t i = 0; i < ids_that_are_done.size(); i++) {
-    int id = ids_that_are_done[i];
-    SmoothScrollGestureMap::iterator it =
-        active_smooth_scroll_gestures_.find(id);
-    DCHECK(it != active_smooth_scroll_gestures_.end());
-    active_smooth_scroll_gestures_.erase(it);
-
-    Send(new ViewMsg_SmoothScrollCompleted(routing_id_, id));
-  }
-
-  // No need to post the next tick if an input is in flight.
-  if (!in_process_event_types_.empty())
-    return;
-
-  TRACE_EVENT_INSTANT1("input", "PostTickTask",
-                       "delay", preferred_interval.InMilliseconds());
-  tick_active_smooth_scroll_gestures_task_posted_ = true;
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&RenderWidgetHostImpl::TickActiveSmoothScrollGesture,
-                 weak_factory_.GetWeakPtr()),
-      preferred_interval);
+  smooth_scroll_gesture_controller_->OnBeginSmoothScroll(
+      view_, gesture_id, params);
 }
 
 void RenderWidgetHostImpl::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_.get()) {
     scoped_ptr<SelectionRange> next(next_selection_range_.Pass());
     SelectRange(next->start, next->end);
   }
 }
 
@@ skipping 509 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content