beginSmoothScroll should send wheel ticks at constant velocity.

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 129 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),
       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
     // information from the RenderWidgetHelper. The problem is that doing so
@@ skipping 1425 matching lines @@
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardEventAck(type, processed);
   } else if (type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(processed);
   } else if (WebInputEvent::isTouchEventType(type)) {
     ProcessTouchAck(event_type, processed);
   } else if (WebInputEvent::isGestureEventType(type)) {
     ProcessGestureAck(processed, type);
   }
 
+  // If an input ack is pending, then hold off ticking the gesture
+  // until we get an input ack.
+  if (in_process_event_types_.size() == 0 &&
+      !active_smooth_scroll_gestures_.empty())
+    TickActiveSmoothScrollGesture();
+
   // This is used only for testing, and the other end does not use the
   // source object.  On linux, specifying
   // Source<RenderWidgetHost> results in a very strange
   // runtime error in the epilogue of the enclosing
   // (OnMsgInputEventAck) 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::OnMsgBeginSmoothScroll(
     int gesture_id, bool scroll_down, bool scroll_far, int mouse_event_x,
     int mouse_event_y) {
   if (!view_)
     return;
   active_smooth_scroll_gestures_.insert(
       std::make_pair(gesture_id,
                      view_->CreateSmoothScrollGesture(
                          scroll_down, scroll_far, mouse_event_x,
                          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() {
-  if (active_smooth_scroll_gestures_.size() == 0)
+  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;
+  }
 
-  TimeTicks now = TimeTicks::HighResNow();
+  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;
+  }
 
-  // Post the next tick right away so it is regular.
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&RenderWidgetHostImpl::TickActiveSmoothScrollGesture,
-                 weak_factory_.GetWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kSyntheticScrollMessageIntervalMs));
+  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);
 }
 
 void RenderWidgetHostImpl::OnMsgSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_.get()) {
     scoped_ptr<SelectionRange> next(next_selection_range_.Pass());
     SelectRange(next->start, next->end);
   }
 }
 
@@ skipping 409 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content