Remove references to WebTouchEvent.targetTouches

content/renderer/pepper/event_conversion.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/renderer/pepper/event_conversion.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/i18n/char_iterator.h"
@@ skipping 197 matching lines @@
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   result.event_modifiers = mouse_wheel_event.modifiers;
   result.wheel_delta.x = mouse_wheel_event.deltaX;
   result.wheel_delta.y = mouse_wheel_event.deltaY;
   result.wheel_ticks.x = mouse_wheel_event.wheelTicksX;
   result.wheel_ticks.y = mouse_wheel_event.wheelTicksY;
   result.wheel_scroll_by_page = !!mouse_wheel_event.scrollByPage;
   result_events->push_back(result);
 }
 
+enum IncludedTouchPointTypes {
+  ACTIVE,  // Only pointers that are currently down.
+  CHANGED  // Only pointers that have changed since the previous event.
+};
 void SetPPTouchPoints(const WebTouchPoint* touches,
                       uint32_t touches_length,
+                      IncludedTouchPointTypes included_types,
                       std::vector<PP_TouchPoint>* result) {
   for (uint32_t i = 0; i < touches_length; i++) {
     const WebTouchPoint& touch_point = touches[i];
+    if (included_types == ACTIVE &&
+        (touch_point.state == WebTouchPoint::StateReleased ||
+         touch_point.state == WebTouchPoint::StateCancelled)) {
+      continue;
+    }
+    if (included_types == CHANGED &&
+        (touch_point.state == WebTouchPoint::StateUndefined ||
+         touch_point.state == WebTouchPoint::StateStationary)) {
+      continue;
+    }
     PP_TouchPoint pp_pt;
     pp_pt.id = touch_point.id;
     pp_pt.position.x = touch_point.position.x;
     pp_pt.position.y = touch_point.position.y;
     pp_pt.radius.x = touch_point.radiusX;
     pp_pt.radius.y = touch_point.radiusY;
     pp_pt.rotation_angle = touch_point.rotationAngle;
     pp_pt.pressure = touch_point.force;
     result->push_back(pp_pt);
   }
 }
 
 void AppendTouchEvent(const WebInputEvent& event,
                       std::vector<InputEventData>* result_events) {
   const WebTouchEvent& touch_event =
       reinterpret_cast<const WebTouchEvent&>(event);
 
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   SetPPTouchPoints(
-      touch_event.touches, touch_event.touchesLength, &result.touches);
-  SetPPTouchPoints(touch_event.changedTouches,
-                   touch_event.changedTouchesLength,
+      touch_event.touches, touch_event.touchesLength, ACTIVE, &result.touches);
+  SetPPTouchPoints(touch_event.touches,
+                   touch_event.touchesLength,
+                   CHANGED,
                    &result.changed_touches);
-  SetPPTouchPoints(touch_event.targetTouches,
-                   touch_event.targetTouchesLength,
-                   &result.target_touches);
 
   result_events->push_back(result);
 }
 
 // Structure used to map touch point id's to touch states.  Since the pepper
 // touch event structure does not have states for individual touch points and
 // instead relies on the event type in combination with the set of touch lists,
 // we have to set the state for the changed touches to be the same as the event
 // type and all others to be 'stationary.'
 typedef std::map<uint32_t, WebTouchPoint::State> TouchStateMap;
@@ skipping 53 matching lines @@
     default:
       NOTREACHED();
   }
   WebTouchEventTraits::ResetType(
       type, PPTimeTicksToEventTime(event.event_time_stamp), web_event);
 
   TouchStateMap states_map;
   for (uint32_t i = 0; i < event.changed_touches.size(); i++)
     states_map[event.changed_touches[i].id] = state;
 
-  SetWebTouchPoints(event.changed_touches,
-                    states_map,
-                    web_event->changedTouches,
-                    &web_event->changedTouchesLength);
-
   SetWebTouchPoints(
       event.touches, states_map, web_event->touches, &web_event->touchesLength);

[bokan, 2014/09/09 20:17:38]

Where do the InputEventData events come from? Will they always be created in
AppendTouchEvent above? If not, are we sure that event.touches will include both
stationary and changed touches?

[jdduke (slow), 2014/09/09 20:52:24]

We're not sure, so we have the branch below. I think we can assume that touches
should include *active* touches, but not necessarily released touches.

 
-  SetWebTouchPoints(event.target_touches,
-                    states_map,
-                    web_event->targetTouches,
-                    &web_event->targetTouchesLength);
-
   if (web_event->type == WebInputEvent::TouchEnd ||
       web_event->type == WebInputEvent::TouchCancel) {
     SetWebTouchPoints(event.changed_touches,

[bokan, 2014/09/09 20:17:38]

Same question again, are we sure ToucheEnd/Cancel wont already be in the touches
list?

[jdduke (slow), 2014/09/09 20:52:24]

Ah, you're right, I thought SetWebTouchPoints checked for redundancy, I'll have
to adjust it.

                       states_map,
                       web_event->touches,
                       &web_event->touchesLength);
-    SetWebTouchPoints(event.changed_touches,
-                      states_map,
-                      web_event->targetTouches,
-                      &web_event->targetTouchesLength);
   }
 
   return web_event;
 }
 
 WebKeyboardEvent* BuildKeyEvent(const InputEventData& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   switch (event.event_type) {
     case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
       key_event->type = WebInputEvent::RawKeyDown;
@@ skipping 375 matching lines @@
     case WebInputEvent::TouchStart:
       return PP_INPUTEVENT_CLASS_TOUCH;
     case WebInputEvent::Undefined:
     default:
       CHECK(WebInputEvent::isGestureEventType(type));
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace content