Relands: Telemetry: hooks "chrome.gpuBenchmarking.smoothScrollBy" with java on android.

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 533 matching lines @@
   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(
     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;

[nduca, 2013/01/10 20:34:33]

Should we pull this edit out to its own cl? This seems like it should get
reviewed by the input-ack gods.

[bulach, 2013/01/11 10:42:07]

good idea! I split it into:
https://codereview.chromium.org/11858007/

+    for (std::deque<WebKit::WebInputEvent::Type>::iterator i =
+         in_process_event_types_.begin();
+         i != in_process_event_types_.end(); ++ i) {

[Sami, 2013/01/10 19:45:34]

Nit: no space between ++ and i.

[bulach, 2013/01/11 10:42:07]

Done.

+      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
+        // |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 =
+            ack_type == WebInputEvent::MouseMove ||

[Sami, 2013/01/10 19:45:34]

Why not use WebInputEvent::isMouseEventType? Because there's no separate queue
for mouse events?

[bulach, 2013/01/11 10:42:07]

Done.

+            ack_type == WebInputEvent::MouseWheel ||
+            (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 46 matching lines @@
   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");
@@ skipping 561 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content