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 1121 matching lines @@
       // touch-events do not reset or contribute to the overscroll gesture.
       // 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);
+  in_process_event_types_.push_back(input_event.type);
 
   // 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 528 matching lines @@
   // MPArch.RWH_DidUpdateBackingStore, and the time spent asynchronously
   // waiting for the paint to complete.
   //
   // On other platforms, this will be equivalent to MPArch.RWH_OnMsgUpdateRect.
   delta = now - paint_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_TotalPaintTime", delta);
   UNSHIPPED_TRACE_EVENT_INSTANT1("test_latency", "UpdateRectComplete",
       "x+y", params.bitmap_rect.x() + params.bitmap_rect.y());
 }
 
 void RenderWidgetHostImpl::OnInputEventAck(

[darin (slow to review), 2013/01/15 19:19:53]

nit: This function is now too long.  You need to break it up.  Maybe your chunk
of new code could be a helper function instead.

     WebInputEvent::Type event_type, InputEventAckState ack_result) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnInputEventAck");
   bool processed = (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
 
-  if (!in_process_event_types_.empty() &&
-      in_process_event_types_.front() == event_type)
-    in_process_event_types_.pop();
+  if (!in_process_event_types_.empty()) {
+    bool found = false;
+    for (std::deque<WebKit::WebInputEvent::Type>::iterator i =
+         in_process_event_types_.begin();
+         i != in_process_event_types_.end(); ++i) {
+      if (*i == event_type) {
+        in_process_event_types_.erase(i);
+        found = true;
+        break;
+      } else {
+        // Ensure we're not ACK'ing out of |type| order. The reason is that
+        // we push the event stream in system order |in_process_event_types_|,
+        // however there are various internal queues for gesture / touch / etc
+        // that may ACK in their own internal order. When traversing

[jamesr, 2013/01/15 19:26:11]

what does this mean?  The render process should ACK input events in the order it
receives them in - why would other browser-process queues matter?

+        // |in_process_event_types_|, ensure we don't jump over an event of the
+        // the same category.
+        int ack_type = static_cast<int>(event_type);
+        int queue_type = static_cast<int>(*i);
+        bool out_of_order =
+            (WebInputEvent::isMouseEventType(ack_type) &&
+             WebInputEvent::isMouseEventType(queue_type)) ||
+            (WebInputEvent::isKeyboardEventType(ack_type) &&
+             WebInputEvent::isKeyboardEventType(queue_type)) ||
+            (WebInputEvent::isTouchEventType(ack_type) &&
+             WebInputEvent::isTouchEventType(queue_type)) ||
+            (WebInputEvent::isGestureEventType(ack_type) &&
+             WebInputEvent::isGestureEventType(queue_type));
+        if (out_of_order) {
+          DVLOG(1) << "OnInputEventAck out of order " << ack_type << " "
+              << queue_type;
+          break;
+        }
+      }
+    }
+    if (!found)
+      DVLOG(1) << "OnInputEventAck not found " << event_type;
+  }
 
   // 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
@@ skipping 627 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content