Count Touch events via WebTouchPoint::State values instead.

content/browser/renderer_host/render_widget_host_input_event_router.cc

 // Copyright 2015 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_input_event_router.h"
 
+#include "base/metrics/histogram_macros.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/frame_messages.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace {
 
@@ skipping 164 matching lines @@
       break;
     case blink::WebGestureDeviceTouchpad:
       RouteTouchpadGestureEvent(root_view, event, latency);
       break;
     case blink::WebGestureDeviceTouchscreen:
       RouteTouchscreenGestureEvent(root_view, event, latency);
       break;
   };
 }
 
+namespace {
+
+unsigned CountChangedTouchPoints(const blink::WebTouchEvent& event) {
+  unsigned changed_count = 0;
+
+  blink::WebTouchPoint::State required_state =
+      blink::WebTouchPoint::StateUndefined;
+  switch (event.type) {
+    case blink::WebInputEvent::TouchStart:
+      required_state = blink::WebTouchPoint::StatePressed;
+      break;
+    case blink::WebInputEvent::TouchEnd:
+      required_state = blink::WebTouchPoint::StateReleased;
+      break;
+    case blink::WebInputEvent::TouchCancel:
+      required_state = blink::WebTouchPoint::StateCancelled;
+      break;
+    default:
+      // We'll only ever call this method for TouchStart, TouchEnd
+      // and TounchCancel events, so mark the rest as not-reached.
+      NOTREACHED();
+    }
+  for (unsigned i = 0; i < event.touchesLength; ++i) {
+    if (event.touches[i].state == required_state)
+      ++changed_count;
+  }
+
+  DCHECK(event.type == blink::WebInputEvent::TouchCancel || changed_count == 1);
+  return changed_count;
+}
+
+}  // namespace
+
 void RenderWidgetHostInputEventRouter::RouteTouchEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebTouchEvent* event,
     const ui::LatencyInfo& latency) {
   switch (event->type) {
     case blink::WebInputEvent::TouchStart: {
-      if (!active_touches_) {
+      active_touches_ += CountChangedTouchPoints(*event);
+      if (active_touches_ == 1) {
         // Since this is the first touch, it defines the target for the rest
         // of this sequence.
         DCHECK(!touch_target_.target);
         gfx::Point transformed_point;
         gfx::Point original_point(event->touches[0].position.x,
                                   event->touches[0].position.y);
         touch_target_.target =
             FindEventTarget(root_view, original_point, &transformed_point);
 
         // TODO(wjmaclean): Instead of just computing a delta, we should extract
         // the complete transform. We assume it doesn't change for the duration
         // of the touch sequence, though this could be wrong; a better approach
         // might be to always transform each point to the |touch_target_.target|
         // for the duration of the sequence.
         touch_target_.delta = transformed_point - original_point;
         touchscreen_gesture_target_queue_.push_back(touch_target_);
 
-        if (!touch_target_.target) {
+        if (!touch_target_.target)
           return;
-        } else if (touch_target_.target ==
-                   bubbling_gesture_scroll_target_.target) {
+
+        if (touch_target_.target == bubbling_gesture_scroll_target_.target) {
           SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
                                blink::WebGestureEvent());
           CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
         }
       }
 
-      ++active_touches_;
       if (touch_target_.target) {
         TransformEventTouchPositions(event, touch_target_.delta);
         touch_target_.target->ProcessTouchEvent(*event, latency);
       }
       break;
     }
     case blink::WebInputEvent::TouchMove:
       if (touch_target_.target) {
         TransformEventTouchPositions(event, touch_target_.delta);
         touch_target_.target->ProcessTouchEvent(*event, latency);
       }
       break;
     case blink::WebInputEvent::TouchEnd:
     case blink::WebInputEvent::TouchCancel:
+      DCHECK(active_touches_);
+      active_touches_ -= CountChangedTouchPoints(*event);
       if (!touch_target_.target)
-        break;
+        return;
 
-      DCHECK(active_touches_);
       TransformEventTouchPositions(event, touch_target_.delta);
       touch_target_.target->ProcessTouchEvent(*event, latency);
-      --active_touches_;
       if (!active_touches_)
         touch_target_.target = nullptr;
       break;
     default:
       NOTREACHED();
   }
 }
 
 void RenderWidgetHostInputEventRouter::BubbleScrollEvent(
     RenderWidgetHostViewBase* target_view,
@@ skipping 177 matching lines @@
     }
     return;
   }
 
   // We use GestureTapDown to detect the start of a gesture sequence since there
   // is no WebGestureEvent equivalent for ET_GESTURE_BEGIN. Note that this
   // means the GestureFlingCancel that always comes between ET_GESTURE_BEGIN and
   // GestureTapDown is sent to the previous target, in case it is still in a
   // fling.
   if (event->type == blink::WebInputEvent::GestureTapDown) {
-    if (touchscreen_gesture_target_queue_.empty()) {
+    bool no_target = touchscreen_gesture_target_queue_.empty();
+    // This UMA metric is temporary, and will be removed once it has fulfilled
+    // it's purpose, namely telling us when the incidents of empty
+    // gesture-queues has dropped to zero. https://crbug.com/642008
+    UMA_HISTOGRAM_BOOLEAN("Event.FrameEventRouting.NoGestureTarget", no_target);
+    if (no_target) {
       LOG(ERROR) << "Gesture sequence start detected with no target available.";
       // Ignore this gesture sequence as no target is available.
       // TODO(wjmaclean): this only happens on Windows, and should not happen.
       // https://crbug.com/595422
       touchscreen_gesture_target_.target = nullptr;
       return;
     }
 
     touchscreen_gesture_target_ = touchscreen_gesture_target_queue_.front();
     touchscreen_gesture_target_queue_.pop_front();
@@ skipping 49 matching lines @@
   if (!touchpad_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchpad_gesture_target_.delta.x();
   event->y += touchpad_gesture_target_.delta.y();
   touchpad_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 }  // namespace content