Added experimental Touch.tilt, Touch.tiltDirection support for Android

content/shell/renderer/test_runner/event_sender.cc

 // Copyright 2014 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/shell/renderer/test_runner/event_sender.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/common/page_zoom.h"
@@ skipping 358 matching lines @@
   std::vector<std::string> ContextClick();
   void TextZoomIn();
   void TextZoomOut();
   void ZoomPageIn();
   void ZoomPageOut();
   void SetPageZoomFactor(double factor);
   void SetPageScaleFactor(gin::Arguments* args);
   void SetPageScaleFactorLimits(gin::Arguments* args);
   void ClearTouchPoints();
   void ReleaseTouchPoint(unsigned index);
-  void UpdateTouchPoint(unsigned index, double x, double y);
+  void UpdateTouchPoint(gin::Arguments* args);
   void CancelTouchPoint(unsigned index);
+  void SetTouchPointTilt(unsigned index, float tils, float tiltDirection);
   void SetTouchModifier(const std::string& key_name, bool set_mask);
   void SetTouchCancelable(bool cancelable);
   void DumpFilenameBeingDragged();
   void GestureFlingCancel();
   void GestureFlingStart(float x, float y, float velocity_x, float velocity_y);
   void GestureScrollFirstPoint(int x, int y);
   void TouchStart();
   void TouchMove();
   void TouchCancel();
   void TouchEnd();
@@ skipping 110 matching lines @@
       .SetMethod("zoomPageIn", &EventSenderBindings::ZoomPageIn)
       .SetMethod("zoomPageOut", &EventSenderBindings::ZoomPageOut)
       .SetMethod("setPageZoomFactor", &EventSenderBindings::SetPageZoomFactor)
       .SetMethod("setPageScaleFactor", &EventSenderBindings::SetPageScaleFactor)
       .SetMethod("setPageScaleFactorLimits",
                  &EventSenderBindings::SetPageScaleFactorLimits)
       .SetMethod("clearTouchPoints", &EventSenderBindings::ClearTouchPoints)
       .SetMethod("releaseTouchPoint", &EventSenderBindings::ReleaseTouchPoint)
       .SetMethod("updateTouchPoint", &EventSenderBindings::UpdateTouchPoint)
       .SetMethod("cancelTouchPoint", &EventSenderBindings::CancelTouchPoint)
+      .SetMethod("setTouchPointTilt", &EventSenderBindings::SetTouchPointTilt)
       .SetMethod("setTouchModifier", &EventSenderBindings::SetTouchModifier)
       .SetMethod("setTouchCancelable", &EventSenderBindings::SetTouchCancelable)
       .SetMethod("dumpFilenameBeingDragged",
                  &EventSenderBindings::DumpFilenameBeingDragged)
       .SetMethod("gestureFlingCancel", &EventSenderBindings::GestureFlingCancel)
       .SetMethod("gestureFlingStart", &EventSenderBindings::GestureFlingStart)
       .SetMethod("gestureScrollFirstPoint",
                  &EventSenderBindings::GestureScrollFirstPoint)
       .SetMethod("touchStart", &EventSenderBindings::TouchStart)
       .SetMethod("touchMove", &EventSenderBindings::TouchMove)
@@ skipping 158 matching lines @@
 void EventSenderBindings::ClearTouchPoints() {
   if (sender_)
     sender_->ClearTouchPoints();
 }
 
 void EventSenderBindings::ReleaseTouchPoint(unsigned index) {
   if (sender_)
     sender_->ReleaseTouchPoint(index);
 }
 
-void EventSenderBindings::UpdateTouchPoint(unsigned index, double x, double y) {
+void EventSenderBindings::UpdateTouchPoint(gin::Arguments* args) {
   if (sender_)
-    sender_->UpdateTouchPoint(index, static_cast<float>(x), static_cast<float>(y));
+    sender_->UpdateTouchPoint(args);
 }
 
 void EventSenderBindings::CancelTouchPoint(unsigned index) {
   if (sender_)
     sender_->CancelTouchPoint(index);
 }
 
+void EventSenderBindings::SetTouchPointTilt(unsigned index,
+                                            float tilt,
+                                            float tiltDirection) {
+  if (sender_)
+    sender_->SetTouchPointTilt(index, tilt, tiltDirection);
+}
+
 void EventSenderBindings::SetTouchModifier(const std::string& key_name,
                                            bool set_mask) {
   if (sender_)
     sender_->SetTouchModifier(key_name, set_mask);
 }
 
 void EventSenderBindings::SetTouchCancelable(bool cancelable) {
   if (sender_)
     sender_->SetTouchCancelable(cancelable);
 }
@@ skipping 819 matching lines @@
 void EventSender::ReleaseTouchPoint(unsigned index) {
   if (index >= touch_points_.size()) {
     ThrowTouchPointError();
     return;
   }
 
   WebTouchPoint* touch_point = &touch_points_[index];
   touch_point->state = WebTouchPoint::StateReleased;
 }
 
-void EventSender::UpdateTouchPoint(unsigned index, float x, float y) {
+void EventSender::UpdateTouchPoint(gin::Arguments* args) {
+  unsigned index;
+  float x;
+  float y;
+
+  if (!args->GetNext(&index) || !args->GetNext(&x) || !args->GetNext(&y)) {
+    args->ThrowError();
+    return;
+  }
+
   if (index >= touch_points_.size()) {
     ThrowTouchPointError();
     return;
   }
 
   WebTouchPoint* touch_point = &touch_points_[index];
   touch_point->state = WebTouchPoint::StateMoved;
   touch_point->position = WebFloatPoint(x, y);
   touch_point->screenPosition = touch_point->position;
+
+  if (!args->PeekNext().IsEmpty()) {

[Rick Byers, 2015/03/05 15:01:02]

Is there a good reason to allow tilt to be set two different ways (via
updateTouchPoint and via setTouchTilt)?  It seems odd that we have this for tilt
but not radius.  Unless there's a good reason, I'd prefer we just have
setTouchPointTilt.

Ironically it looks like some tests are designed to support a
setTouchPointRadius method (basic-single-touch-events.js), but we don't actually
have such a method.  If you're interested, that would be a great thing to fix at
the same time as this (in another CL).  Ideally the pattern for radius and tilt
should be the same. 

[d.pikalov, 2015/03/09 13:39:50]

Done.
Please review
https://codereview.chromium.org/990193002
https://codereview.chromium.org/990183003

+    if (!args->GetNext(&touch_point->tilt)) {
+      args->ThrowError();
+      return;
+    }
+  }
+
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&touch_point->tiltDirection)) {
+      args->ThrowError();
+      return;
+    }
+  }
 }
 
 void EventSender::CancelTouchPoint(unsigned index) {
   if (index >= touch_points_.size()) {
     ThrowTouchPointError();
     return;
   }
 
   WebTouchPoint* touch_point = &touch_points_[index];
   touch_point->state = WebTouchPoint::StateCancelled;
 }
 
+void EventSender::SetTouchPointTilt(unsigned index,
+                                    float tilt,
+                                    float tiltDirection) {
+  if (index >= touch_points_.size()) {
+    ThrowTouchPointError();
+    return;
+  }
+
+  WebTouchPoint* touch_point = &touch_points_[index];
+  touch_point->tilt = tilt;
+  touch_point->tiltDirection = tiltDirection;
+  touch_point->state = WebTouchPoint::StateMoved;
+}
+
 void EventSender::SetTouchModifier(const std::string& key_name,
                                     bool set_mask) {
   int mask = 0;
   if (key_name == "shift")
     mask = WebInputEvent::ShiftKey;
   else if (key_name == "alt")
     mask = WebInputEvent::AltKey;
   else if (key_name == "ctrl")
     mask = WebInputEvent::ControlKey;
   else if (key_name == "meta")
@@ skipping 144 matching lines @@
       if (!args->GetNext(&radius_y)) {
         args->ThrowError();
         return;
       }
     }
 
     touch_point.radiusX = static_cast<float>(radius_x);
     touch_point.radiusY = static_cast<float>(radius_y);
   }
 
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&touch_point.tilt)) {
+      args->ThrowError();
+      return;
+    }
+  }
+
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&touch_point.tiltDirection)) {
+      args->ThrowError();
+      return;
+    }
+  }
+
   int lowest_id = 0;
   for (size_t i = 0; i < touch_points_.size(); i++) {
     if (touch_points_[i].id == lowest_id)
       lowest_id++;
   }
   touch_point.id = lowest_id;
   touch_points_.push_back(touch_point);
 }
 
 void EventSender::MouseDragBegin() {
@@ skipping 686 matching lines @@
 
 bool EventSender::HandleInputEventOnViewOrPopup(const WebInputEvent& event) {
   if (WebPagePopup* popup = view_->pagePopup()) {
     if (!WebInputEvent::isKeyboardEventType(event.type))
       return popup->handleInputEvent(event);
   }
   return view_->handleInputEvent(event);
 }
 
 }  // namespace content