Add tilt_x and tilt_y to ppapi touchpoint.

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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 11 matching lines @@
 #include "device/gamepad/public/cpp/gamepads.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebKeyboardEvent.h"
 #include "third_party/WebKit/public/platform/WebMouseWheelEvent.h"
 #include "third_party/WebKit/public/platform/WebTouchEvent.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 using ppapi::InputEventData;
+using ppapi::TouchPointWithTilt;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using blink::WebUChar;
 
 namespace content {
 
@@ skipping 195 matching lines @@
 }
 
 enum IncludedTouchPointTypes {
   ALL,     // All pointers targetting the plugin.
   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) {
+                      std::vector<TouchPointWithTilt>* result) {
   for (uint32_t i = 0; i < touches_length; i++) {
     const WebTouchPoint& touch_point = touches[i];
     if (included_types == ACTIVE &&
         (touch_point.state == WebTouchPoint::kStateReleased ||
          touch_point.state == WebTouchPoint::kStateCancelled)) {
       continue;
     }
     if (included_types == CHANGED &&
         (touch_point.state == WebTouchPoint::kStateUndefined ||
          touch_point.state == WebTouchPoint::kStateStationary)) {
       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.radius_x;
     pp_pt.radius.y = touch_point.radius_y;
     pp_pt.rotation_angle = touch_point.rotation_angle;
     pp_pt.pressure = touch_point.force;
-    result->push_back(pp_pt);
+    PP_FloatPoint pp_ft;
+    pp_ft.x = touch_point.tilt_x;
+    pp_ft.y = touch_point.tilt_y;
+    TouchPointWithTilt touch_with_tilt{pp_pt, pp_ft};
+    result->push_back(touch_with_tilt);
   }
 }
 
 void AppendTouchEvent(const WebInputEvent& event,
                       std::vector<InputEventData>* result_events) {
   const WebTouchEvent& touch_event =
       reinterpret_cast<const WebTouchEvent&>(event);
 
   InputEventData result = GetEventWithCommonFieldsAndType(event);
 
@@ skipping 40 matching lines @@
                          uint32_t id) {
   // Note: A brute force search to find the (potentially) existing touch point
   // is cheap given the small bound on |WebTouchEvent::kTouchesLengthCap|.
   for (uint32_t i = 0; i < web_touches_length; ++i) {
     if (web_touches[i].id == static_cast<int>(id))
       return true;
   }
   return false;
 }
 
-void SetWebTouchPointsIfNotYetSet(const std::vector<PP_TouchPoint>& pp_touches,
-                                  WebTouchPoint::State state,
-                                  WebTouchPoint* web_touches,
-                                  uint32_t* web_touches_length) {
+void SetWebTouchPointsIfNotYetSet(
+    const std::vector<TouchPointWithTilt>& pp_touches,
+    WebTouchPoint::State state,
+    WebTouchPoint* web_touches,
+    uint32_t* web_touches_length) {
   const uint32_t initial_web_touches_length = *web_touches_length;
   const uint32_t touches_length =
       std::min(static_cast<uint32_t>(pp_touches.size()),
                static_cast<uint32_t>(WebTouchEvent::kTouchesLengthCap));
   for (uint32_t i = 0; i < touches_length; ++i) {
     const uint32_t touch_index = *web_touches_length;
     if (touch_index >= static_cast<uint32_t>(WebTouchEvent::kTouchesLengthCap))
       return;
 
-    const PP_TouchPoint& pp_pt = pp_touches[i];
+    const PP_TouchPoint& pp_pt = pp_touches[i].touch;
     if (HasTouchPointWithId(web_touches, initial_web_touches_length, pp_pt.id))
       continue;
 
     web_touches[touch_index] = CreateWebTouchPoint(pp_pt, state);
     ++(*web_touches_length);
   }
 }
 
 WebTouchEvent* BuildTouchEvent(const InputEventData& event) {
   WebTouchEvent* web_event = new WebTouchEvent();
@@ skipping 407 matching lines @@
       return PP_INPUTEVENT_CLASS_TOUCH;
     case WebInputEvent::kTouchScrollStarted:
       return PP_InputEvent_Class(0);
     default:
       CHECK(WebInputEvent::IsGestureEventType(event.GetType()));
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace content