Update EventSender::GestureTap to return a bool (if handled).

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 343 matching lines @@
   void TouchEnd();
   void LeapForward(int milliseconds);
   void BeginDragWithFiles(const std::vector<std::string>& files);
   void AddTouchPoint(gin::Arguments* args);
   void MouseDragBegin();
   void MouseDragEnd();
   void GestureScrollBegin(gin::Arguments* args);
   void GestureScrollEnd(gin::Arguments* args);
   void GestureScrollUpdate(gin::Arguments* args);
   void GestureScrollUpdateWithoutPropagation(gin::Arguments* args);
-  void GestureTap(gin::Arguments* args);
+  bool GestureTap(gin::Arguments* args);
   void GestureTapDown(gin::Arguments* args);
   void GestureShowPress(gin::Arguments* args);
   void GestureTapCancel(gin::Arguments* args);
   void GestureLongPress(gin::Arguments* args);
   void GestureLongTap(gin::Arguments* args);
   void GestureTwoFingerTap(gin::Arguments* args);
   void ContinuousMouseScrollBy(gin::Arguments* args);
   void MouseMoveTo(gin::Arguments* args);
   void TrackpadScrollBegin();
   void TrackpadScroll(gin::Arguments* args);
@@ skipping 360 matching lines @@
   if (sender_)
     sender_->GestureScrollUpdate(args);
 }
 
 void EventSenderBindings::GestureScrollUpdateWithoutPropagation(
     gin::Arguments* args) {
   if (sender_)
     sender_->GestureScrollUpdateWithoutPropagation(args);
 }
 
-void EventSenderBindings::GestureTap(gin::Arguments* args) {
+bool EventSenderBindings::GestureTap(gin::Arguments* args) {
   if (sender_)
-    sender_->GestureTap(args);
+    return sender_->GestureTap(args);
+  return false; // TODO(donnd): true?

[Rick Byers, 2014/05/29 20:57:47]

yeah this is goofy (should probably throw instead of silently return), but don't
worry about it - just returning false is fine.

[donnd, 2014/05/31 03:14:57]

Done.

 }
 
 void EventSenderBindings::GestureTapDown(gin::Arguments* args) {
   if (sender_)
     sender_->GestureTapDown(args);
 }
 
 void EventSenderBindings::GestureShowPress(gin::Arguments* args) {
   if (sender_)
     sender_->GestureShowPress(args);
@@ skipping 926 matching lines @@
 }
 
 void EventSender::GestureScrollUpdate(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollUpdate, args);
 }
 
 void EventSender::GestureScrollUpdateWithoutPropagation(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollUpdateWithoutPropagation, args);
 }
 
-void EventSender::GestureTap(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureTap, args);
+bool EventSender::GestureTap(gin::Arguments* args) {

[Rick Byers, 2014/05/29 20:57:47]

I'm new to gin (gin is a new lightweight javascript<->C++ bindings system) but
it looks like the right way to set a return value to JS in this case is probably
with args->Return.  Maybe your direct way will automatically work too, and if so
that's fine but you'll need to test.  If not then try args->Return(...) to set
the return value.

[donnd, 2014/05/31 03:14:57]

Done.

+  return GestureEvent(WebInputEvent::GestureTap, args);
 }
 
 void EventSender::GestureTapDown(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureTapDown, args);
 }
 
 void EventSender::GestureShowPress(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureShowPress, args);
 }
 
@@ skipping 177 matching lines @@
   for (size_t i = 0; i < touch_points_.size(); ++i) {
     WebTouchPoint* touch_point = &touch_points_[i];
     if (touch_point->state == WebTouchPoint::StateReleased) {
       touch_points_.erase(touch_points_.begin() + i);
       --i;
     } else
       touch_point->state = WebTouchPoint::StateStationary;
   }
 }
 
-void EventSender::GestureEvent(WebInputEvent::Type type,
+bool EventSender::GestureEvent(WebInputEvent::Type type,
                                gin::Arguments* args) {
   double x;
   double y;
   args->GetNext(&x);
   args->GetNext(&y);
   WebPoint point(x, y);
 
   WebGestureEvent event;
   event.type = type;
 
@@ skipping 17 matching lines @@
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureFlingStart:
       event.x = current_gesture_location_.x;
       event.y = current_gesture_location_.y;
       break;
     case WebInputEvent::GestureTap:
       if (!args->PeekNext().IsEmpty()) {
         float tap_count;
         if (!args->GetNext(&tap_count)) {
           args->ThrowError();
-          return;
+          return false;

[Rick Byers, 2014/05/29 20:57:47]

If the right way to set a return value to JS is args->Return then all these
extra statements can go away...

[donnd, 2014/05/31 03:14:57]

Done.

         }
         event.data.tap.tapCount = tap_count;
       } else {
         event.data.tap.tapCount = 1;
       }
 
       event.x = point.x;
       event.y = point.y;
       break;
     case WebInputEvent::GestureTapUnconfirmed:
       if (!args->PeekNext().IsEmpty()) {
         float tap_count;
         if (!args->GetNext(&tap_count)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.tap.tapCount = tap_count;
       } else {
         event.data.tap.tapCount = 1;
       }
       event.x = point.x;
       event.y = point.y;
       break;
     case WebInputEvent::GestureTapDown:
       event.x = point.x;
       event.y = point.y;
       if (!args->PeekNext().IsEmpty()) {
         float width;
         if (!args->GetNext(&width)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.tapDown.width = width;
       }
       if (!args->PeekNext().IsEmpty()) {
         float height;
         if (!args->GetNext(&height)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.tapDown.height = height;
       }
       break;
     case WebInputEvent::GestureShowPress:
       event.x = point.x;
       event.y = point.y;
       if (!args->PeekNext().IsEmpty()) {
         float width;
         if (!args->GetNext(&width)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.showPress.width = width;
         if (!args->PeekNext().IsEmpty()) {
           float height;
           if (!args->GetNext(&height)) {
             args->ThrowError();
-            return;
+            return false;
           }
           event.data.showPress.height = height;
         }
       }
       break;
     case WebInputEvent::GestureTapCancel:
       event.x = point.x;
       event.y = point.y;
       break;
     case WebInputEvent::GestureLongPress:
       event.x = point.x;
       event.y = point.y;
       if (!args->PeekNext().IsEmpty()) {
         float width;
         if (!args->GetNext(&width)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.longPress.width = width;
         if (!args->PeekNext().IsEmpty()) {
           float height;
           if (!args->GetNext(&height)) {
             args->ThrowError();
-            return;
+            return false;
           }
           event.data.longPress.height = height;
         }
       }
       break;
     case WebInputEvent::GestureLongTap:
       event.x = point.x;
       event.y = point.y;
       if (!args->PeekNext().IsEmpty()) {
         float width;
         if (!args->GetNext(&width)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.longPress.width = width;
         if (!args->PeekNext().IsEmpty()) {
           float height;
           if (!args->GetNext(&height)) {
             args->ThrowError();
-            return;
+            return false;
           }
           event.data.longPress.height = height;
         }
       }
       break;
     case WebInputEvent::GestureTwoFingerTap:
       event.x = point.x;
       event.y = point.y;
       if (!args->PeekNext().IsEmpty()) {
         float first_finger_width;
         if (!args->GetNext(&first_finger_width)) {
           args->ThrowError();
-          return;
+          return false;
         }
         event.data.twoFingerTap.firstFingerWidth = first_finger_width;
         if (!args->PeekNext().IsEmpty()) {
           float first_finger_height;
           if (!args->GetNext(&first_finger_height)) {
             args->ThrowError();
-            return;
+            return false;
           }
           event.data.twoFingerTap.firstFingerHeight = first_finger_height;
         }
       }
       break;
     default:
       NOTREACHED();
   }
 
   event.globalX = event.x;
   event.globalY = event.y;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
     view_->layout();
 
-  view_->handleInputEvent(event);
+  bool result = view_->handleInputEvent(event);
 
   // Long press might start a drag drop session. Complete it if so.
   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
     WebMouseEvent mouse_event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    pressed_button_,
                    point,
                    GetCurrentEventTimeSec(),
                    click_count_,
                    0,
                    &mouse_event);
 
     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
+    result = true;
   }
+  return result;
 }
 
 void EventSender::UpdateClickCountForButton(
     WebMouseEvent::Button button_type) {
   if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
        kMultipleClickTimeSec) &&
       (!OutsideMultiClickRadius(last_mouse_pos_, last_click_pos_)) &&
       (button_type == last_button_type_)) {
     ++click_count_;
   } else {
@@ skipping 146 matching lines @@
       }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
 }
 
 }  // namespace content