Use new WebTouchPoint field names.

content/common/input/web_input_event_traits.cc

 // Copyright 2013 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/common/input/web_input_event_traits.h"
 
 #include <bitset>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 76 matching lines @@
                 event.data.scrollUpdate.deltaY,
                 event.data.scrollUpdate.velocityX,
                 event.data.scrollUpdate.velocityY,
                 event.data.scrollUpdate.previousUpdateInSequencePrevented);
 }
 
 void ApppendTouchPointDetails(const WebTouchPoint& point, std::string* result) {
   StringAppendF(result,
                  "  (ID: %d, State: %d, ScreenPos: (%f, %f), Pos: (%f, %f),"
                      " Radius: (%f, %f), Rot: %f, Force: %f),\n",
-  point.id,
+  point.pointerId,
   point.state,
   point.screenPosition.x,
   point.screenPosition.y,
   point.position.x,
   point.position.y,
-  point.radiusX,
-  point.radiusY,
+  point.width,
+  point.height,
   point.rotationAngle,
-  point.force);
+  point.pressure);
 }
 
 void ApppendEventDetails(const WebTouchEvent& event, std::string* result) {
   StringAppendF(result,
                 "{\n Touches: %u, Cancelable: %d, CausesScrolling: %d,"
                 " uniqueTouchEventId: %u\n[\n",
                 event.touchesLength, event.cancelable,
                 event.causesScrollingIfUncanceled, event.uniqueTouchEventId);
   for (unsigned i = 0; i < event.touchesLength; ++i)
     ApppendTouchPointDetails(event.touches[i], result);
@@ skipping 68 matching lines @@
       GetAccelerationRatio(event->deltaX, unaccelerated_x);
   event->accelerationRatioY =
       GetAccelerationRatio(event->deltaY, unaccelerated_y);
   DCHECK_GE(event_to_coalesce.timeStampSeconds, event->timeStampSeconds);
   event->timeStampSeconds = event_to_coalesce.timeStampSeconds;
 }
 
 // Returns |kInvalidTouchIndex| iff |event| lacks a touch with an ID of |id|.
 int GetIndexOfTouchID(const WebTouchEvent& event, int id) {
   for (unsigned i = 0; i < event.touchesLength; ++i) {
-    if (event.touches[i].id == id)
+    if (event.touches[i].pointerId == id)
       return i;
   }
   return kInvalidTouchIndex;
 }
 
 bool CanCoalesce(const WebTouchEvent& event_to_coalesce,
                  const WebTouchEvent& event) {
   if (event.type != event_to_coalesce.type ||
       event.type != WebInputEvent::TouchMove ||
       event.modifiers != event_to_coalesce.modifiers ||
       event.touchesLength != event_to_coalesce.touchesLength ||
       event.touchesLength > WebTouchEvent::touchesLengthCap)
     return false;
 
   static_assert(WebTouchEvent::touchesLengthCap <= sizeof(int32_t) * 8U,
                 "suboptimal touchesLengthCap size");
   // Ensure that we have a 1-to-1 mapping of pointer ids between touches.
   std::bitset<WebTouchEvent::touchesLengthCap> unmatched_event_touches(
       (1 << event.touchesLength) - 1);
   for (unsigned i = 0; i < event_to_coalesce.touchesLength; ++i) {
     int event_touch_index =
-        GetIndexOfTouchID(event, event_to_coalesce.touches[i].id);
+        GetIndexOfTouchID(event, event_to_coalesce.touches[i].pointerId);
     if (event_touch_index == kInvalidTouchIndex)
       return false;
     if (!unmatched_event_touches[event_touch_index])
       return false;
     unmatched_event_touches[event_touch_index] = false;
   }
   return unmatched_event_touches.none();
 }
 
 void Coalesce(const WebTouchEvent& event_to_coalesce, WebTouchEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
   // The WebTouchPoints include absolute position information. So it is
   // sufficient to simply replace the previous event with the new event->
   // However, it is necessary to make sure that all the points have the
   // correct state, i.e. the touch-points that moved in the last event, but
   // didn't change in the current event, will have Stationary state. It is
   // necessary to change them back to Moved state.
   WebTouchEvent old_event = *event;
   *event = event_to_coalesce;
   for (unsigned i = 0; i < event->touchesLength; ++i) {
-    int i_old = GetIndexOfTouchID(old_event, event->touches[i].id);
+    int i_old = GetIndexOfTouchID(old_event, event->touches[i].pointerId);
     if (old_event.touches[i_old].state == blink::WebTouchPoint::StateMoved)
       event->touches[i].state = blink::WebTouchPoint::StateMoved;
   }
   event->causesScrollingIfUncanceled |= old_event.causesScrollingIfUncanceled;
 }
 
 bool CanCoalesce(const WebGestureEvent& event_to_coalesce,
                  const WebGestureEvent& event) {
   if (event.type != event_to_coalesce.type ||
       event.sourceDevice != event_to_coalesce.sourceDevice ||
@@ skipping 239 matching lines @@
 }
 
 uint32 WebInputEventTraits::GetUniqueTouchEventId(const WebInputEvent& event) {
   if (WebInputEvent::isTouchEventType(event.type)) {
     return static_cast<const WebTouchEvent&>(event).uniqueTouchEventId;
   }
   return 0U;
 }
 
 }  // namespace content