Add eventSender support for web pointer properties in touch points.

components/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 "components/test_runner/event_sender.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 331 matching lines @@
       event.windowsKeyCode != ui::VKEY_B &&
       event.windowsKeyCode != ui::VKEY_I;
 #else
   return !!(event.modifiers & WebInputEvent::AltKey);
 #endif
 }
 
 const char* kSourceDeviceStringTouchpad = "touchpad";
 const char* kSourceDeviceStringTouchscreen = "touchscreen";
 
+const char* kPointerTypeStringUnknown = "";
+const char* kPointerTypeStringMouse = "mouse";
+const char* kPointerTypeStringPen = "pen";
+const char* kPointerTypeStringTouch = "touch";
+
 }  // namespace
 
 class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<EventSender> sender,
                       blink::WebFrame* frame);
 
  private:
   explicit EventSenderBindings(base::WeakPtr<EventSender> sender);
   ~EventSenderBindings() override;
 
   // gin::Wrappable:
   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
 
   // Bound methods:
   void EnableDOMUIEventLogging();
   void FireKeyboardEventsToElement();
   void ClearKillRing();
   std::vector<std::string> ContextClick();
   void TextZoomIn();
   void TextZoomOut();
   void ZoomPageIn();
   void ZoomPageOut();
   void SetPageZoomFactor(double factor);
   void ClearTouchPoints();
   void ReleaseTouchPoint(unsigned index);
-  void UpdateTouchPoint(unsigned index, double x, double y);
+  void UpdateTouchPoint(unsigned index,
+                        double x,
+                        double y,
+                        gin::Arguments* args);
   void CancelTouchPoint(unsigned index);
   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,
                          gin::Arguments* args);
   void GestureScrollFirstPoint(int x, int y);
   void TouchStart();
   void TouchMove();
   void TouchMoveCausingScrollIfUncanceled();
   void TouchCancel();
   void TouchEnd();
   void LeapForward(int milliseconds);
   void BeginDragWithFiles(const std::vector<std::string>& files);
-  void AddTouchPoint(gin::Arguments* args);
+  void AddTouchPoint(double x, double y, gin::Arguments* args);
   void MouseDragBegin();
   void MouseDragEnd();
   void GestureScrollBegin(gin::Arguments* args);
   void GestureScrollEnd(gin::Arguments* args);
   void GestureScrollUpdate(gin::Arguments* args);
   void GesturePinchBegin(gin::Arguments* args);
   void GesturePinchEnd(gin::Arguments* args);
   void GesturePinchUpdate(gin::Arguments* args);
   void GestureTap(gin::Arguments* args);
   void GestureTapDown(gin::Arguments* args);
@@ skipping 234 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(unsigned index,
+                                           double x,
+                                           double y,
+                                           gin::Arguments* args) {
   if (sender_) {
     sender_->UpdateTouchPoint(index, static_cast<float>(x),
-                              static_cast<float>(y));
+                              static_cast<float>(y), args);
   }
 }
 
 void EventSenderBindings::CancelTouchPoint(unsigned index) {
   if (sender_)
     sender_->CancelTouchPoint(index);
 }
 
 void EventSenderBindings::SetTouchModifier(const std::string& key_name,
                                            bool set_mask) {
@@ skipping 59 matching lines @@
   if (sender_)
     sender_->LeapForward(milliseconds);
 }
 
 void EventSenderBindings::BeginDragWithFiles(
     const std::vector<std::string>& files) {
   if (sender_)
     sender_->BeginDragWithFiles(files);
 }
 
-void EventSenderBindings::AddTouchPoint(gin::Arguments* args) {
+void EventSenderBindings::AddTouchPoint(double x,
+                                        double y,
+                                        gin::Arguments* args) {
   if (sender_)
-    sender_->AddTouchPoint(args);
+    sender_->AddTouchPoint(static_cast<float>(x), static_cast<float>(y), args);
 }
 
 void EventSenderBindings::MouseDragBegin() {
   if (sender_)
     sender_->MouseDragBegin();
 }
 
 void EventSenderBindings::MouseDragEnd() {
   if (sender_)
     sender_->MouseDragEnd();
@@ skipping 799 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(unsigned index,
+                                   float x,
+                                   float y,
+                                   gin::Arguments* args) {
   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;
+
+  InitPointerProperties(args, touch_point, &touch_point->radiusX,
+                        &touch_point->radiusY);
 }
 
 void EventSender::CancelTouchPoint(unsigned index) {
   if (index >= touch_points_.size()) {
     ThrowTouchPointError();
     return;
   }
 
   WebTouchPoint* touch_point = &touch_points_[index];
   touch_point->state = WebTouchPoint::StateCancelled;
@@ skipping 141 matching lines @@
                              current_drag_effects_allowed_,
                              0);
   // |is_drag_mode_| saves events and then replays them later. We don't
   // need/want that.
   is_drag_mode_ = false;
 
   // Make the rest of eventSender think a drag is in progress.
   pressed_button_ = WebMouseEvent::ButtonLeft;
 }
 
-void EventSender::AddTouchPoint(gin::Arguments* args) {
-  double x;
-  double y;
-  if (!args->GetNext(&x) || !args->GetNext(&y)) {
-    args->ThrowError();
-    return;
-  }
-
+void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
   WebTouchPoint touch_point;
   touch_point.state = WebTouchPoint::StatePressed;
-  touch_point.position = WebFloatPoint(static_cast<float>(x),
-                                       static_cast<float>(y));
+  touch_point.position = WebFloatPoint(x, y);
   touch_point.screenPosition = touch_point.position;
 
-  if (!args->PeekNext().IsEmpty()) {
-    double radius_x;
-    if (!args->GetNext(&radius_x)) {
-      args->ThrowError();
-      return;
-    }
-
-    double radius_y = radius_x;
-    if (!args->PeekNext().IsEmpty()) {
-      if (!args->GetNext(&radius_y)) {
-        args->ThrowError();
-        return;
-      }
-    }
-
-    touch_point.radiusX = static_cast<float>(radius_x);
-    touch_point.radiusY = static_cast<float>(radius_y);
-  }
-
+  // TODO(e_hakkinen): Make this algorithm more robust so that it handles
+  // touch points which are not sorted by their ids, too.
   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;
+
+  InitPointerProperties(args, &touch_point, &touch_point.radiusX,
+                        &touch_point.radiusY);
+
   touch_points_.push_back(touch_point);
 }
 
 void EventSender::MouseDragBegin() {
   WebMouseWheelEvent event;
   InitMouseEvent(WebInputEvent::MouseWheel,
                  WebMouseEvent::ButtonNone,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
@@ skipping 594 matching lines @@
   event->canScroll = can_scroll;
   if (continuous) {
     event->wheelTicksX /= kScrollbarPixelsPerTick;
     event->wheelTicksY /= kScrollbarPixelsPerTick;
   } else {
     event->deltaX *= kScrollbarPixelsPerTick;
     event->deltaY *= kScrollbarPixelsPerTick;
   }
 }
 
+// Radius fields radius_x and radius_y should eventually be moved to
+// WebPointerProperties.
+// TODO(e_hakkinen): Drop radius_{x,y}_pointer parameters once that happens.
+void EventSender::InitPointerProperties(gin::Arguments* args,
+                                        blink::WebPointerProperties* e,
+                                        float* radius_x_pointer,
+                                        float* radius_y_pointer) {
+  if (!args->PeekNext().IsEmpty()) {
+    double radius_x;
+    if (!args->GetNext(&radius_x)) {
+      args->ThrowError();
+      return;
+    }
+
+    double radius_y = radius_x;
+    if (!args->PeekNext().IsEmpty()) {
+      if (!args->GetNext(&radius_y)) {
+        args->ThrowError();
+        return;
+      }
+    }
+
+    *radius_x_pointer = static_cast<float>(radius_x);
+    *radius_y_pointer = static_cast<float>(radius_y);
+  }
+
+  if (!args->PeekNext().IsEmpty()) {
+    double force;
+    if (!args->GetNext(&force)) {
+      args->ThrowError();
+      return;
+    }
+    e->force = static_cast<float>(force);
+  }
+
+  if (!args->PeekNext().IsEmpty()) {
+    int tiltX, tiltY;
+    if (!args->GetNext(&tiltX) || !args->GetNext(&tiltY)) {
+      args->ThrowError();
+      return;
+    }
+    e->tiltX = tiltX;
+    e->tiltY = tiltY;
+  }
+
+  if (!args->PeekNext().IsEmpty()) {
+    std::string pointer_type_string;
+    if (!args->GetNext(&pointer_type_string)) {
+      args->ThrowError();
+      return;
+    }
+    if (pointer_type_string == kPointerTypeStringUnknown) {
+      e->pointerType = WebMouseEvent::PointerTypeUnknown;
+    } else if (pointer_type_string == kPointerTypeStringMouse) {
+      e->pointerType = WebMouseEvent::PointerTypeMouse;
+    } else if (pointer_type_string == kPointerTypeStringPen) {
+      e->pointerType = WebMouseEvent::PointerTypePen;
+    } else if (pointer_type_string == kPointerTypeStringTouch) {
+      e->pointerType = WebMouseEvent::PointerTypeTouch;
+    } else {
+      args->ThrowError();
+      return;
+    }
+  }
+}
+
 void EventSender::FinishDragAndDrop(const WebMouseEvent& e,
                                      blink::WebDragOperation drag_effect) {
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
   current_drag_effect_ = drag_effect;
   if (current_drag_effect_) {
     // Specifically pass any keyboard modifiers to the drop method. This allows
     // tests to control the drop type (i.e. copy or move).
     view_->dragTargetDrop(client_point, screen_point, e.modifiers);
   } else {
@@ skipping 87 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 test_runner