[Mac] Don't dispatch wheel events for PhaseMayBegin|Cancelled|Ended

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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 311 matching lines @@
   std::vector<std::string> modifier_names;
   if (value->IsString()) {
     modifier_names.push_back(gin::V8ToString(value));
   } else if (value->IsArray()) {
     gin::Converter<std::vector<std::string> >::FromV8(
         isolate, value, &modifier_names);
   }
   return GetKeyModifiers(modifier_names);
 }
 
+WebMouseWheelEvent::Phase GetMouseWheelEventPhase(
+    const std::string& phase_name) {
+  const char* characters = phase_name.c_str();
+  if (!strcmp(characters, "phaseNone")) {

[dtapuska, 2016/07/04 14:15:40]

Why strcmps? and not just a == operator?

[chongz, 2016/07/04 17:58:43]

Sorry I was following existing code (GetKeyModifier()), changed to == operator.

+    return WebMouseWheelEvent::PhaseNone;
+  } else if (!strcmp(characters, "phaseBegan")) {
+    return WebMouseWheelEvent::PhaseBegan;
+  } else if (!strcmp(characters, "phaseStationary")) {
+    return WebMouseWheelEvent::PhaseStationary;
+  } else if (!strcmp(characters, "phaseChanged")) {
+    return WebMouseWheelEvent::PhaseChanged;
+  } else if (!strcmp(characters, "phaseEnded")) {
+    return WebMouseWheelEvent::PhaseEnded;
+  } else if (!strcmp(characters, "phaseCancelled")) {
+    return WebMouseWheelEvent::PhaseCancelled;
+  } else if (!strcmp(characters, "phaseMayBegin")) {
+    return WebMouseWheelEvent::PhaseMayBegin;
+  }
+
+  return WebMouseWheelEvent::PhaseNone;
+}
+
+WebMouseWheelEvent::Phase GetMouseWheelEventPhaseFromV8(
+    v8::Local<v8::Value> value) {
+  if (value->IsString())
+    return GetMouseWheelEventPhase(gin::V8ToString(value));
+  return WebMouseWheelEvent::PhaseNone;
+}
+
 // Maximum distance (in space and time) for a mouse click to register as a
 // double or triple click.
 const double kMultipleClickTimeSec = 1;
 const int kMultipleClickRadiusPixels = 5;
 const char kSubMenuDepthIdentifier[] = "_";
 const char kSubMenuIdentifier[] = " >";
 const char kSeparatorIdentifier[] = "---------";
 const char kDisabledIdentifier[] = "#";
 const char kCheckedIdentifier[] = "*";
 
@@ skipping 2191 matching lines @@
   }
   double vertical;
   if (!args->GetNext(&vertical)) {
     args->ThrowError();
     return;
   }
 
   bool paged = false;
   bool has_precise_scrolling_deltas = false;
   int modifiers = 0;
+  WebMouseWheelEvent::Phase phase = WebMouseWheelEvent::PhaseNone;
   if (!args->PeekNext().IsEmpty()) {
     args->GetNext(&paged);
     if (!args->PeekNext().IsEmpty()) {
       args->GetNext(&has_precise_scrolling_deltas);
       if (!args->PeekNext().IsEmpty()) {
         v8::Local<v8::Value> value;
         args->GetNext(&value);
         modifiers = GetKeyModifiersFromV8(args->isolate(), value);
         if (!args->PeekNext().IsEmpty()) {
           args->GetNext(send_gestures);
+          if (!args->PeekNext().IsEmpty()) {
+            v8::Local<v8::Value> phase_value;
+            args->GetNext(&phase_value);
+            phase = GetMouseWheelEventPhaseFromV8(phase_value);
+          }
         }
       }
     }
   }
 
   InitMouseEvent(WebInputEvent::MouseWheel,
                  current_pointer_state_[kRawMousePointerId].pressed_button_,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(), click_count_, modifiers, event);
   event->wheelTicksX = static_cast<float>(horizontal);
   event->wheelTicksY = static_cast<float>(vertical);
   event->deltaX = event->wheelTicksX;
   event->deltaY = event->wheelTicksY;
   event->scrollByPage = paged;
   event->hasPreciseScrollingDeltas = has_precise_scrolling_deltas;
+  event->phase = phase;
   if (scroll_type == MouseScrollType::PIXEL) {
     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
@@ skipping 250 matching lines @@
 }
 
 std::unique_ptr<WebInputEvent> EventSender::ScaleEvent(
     const WebInputEvent& event) {
   // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the event
   // does not have to be converted.
   return ui::ScaleWebInputEvent(event, delegate()->GetWindowToViewportScale());
 }
 
 }  // namespace test_runner