Refactoring button field and its type (2nd try)

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 135 matching lines @@
       }
     }
   }
 
   return true;
 }
 
 WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) {
   switch (button_code) {
     case -1:
-      return WebMouseEvent::ButtonNone;
+      return WebMouseEvent::Button::NoButton;
     case 0:
-      return WebMouseEvent::ButtonLeft;
+      return WebMouseEvent::Button::Left;
     case 1:
-      return WebMouseEvent::ButtonMiddle;
+      return WebMouseEvent::Button::Middle;
     case 2:
-      return WebMouseEvent::ButtonRight;
+      return WebMouseEvent::Button::Right;
   }
   NOTREACHED();
-  return WebMouseEvent::ButtonNone;
+  return WebMouseEvent::Button::NoButton;
 }
 
 int GetWebMouseEventModifierForButton(WebMouseEvent::Button button) {
   switch (button) {
-    case WebMouseEvent::ButtonNone:
+    case WebMouseEvent::Button::NoButton:
       return 0;
-    case WebMouseEvent::ButtonLeft:
+    case WebMouseEvent::Button::Left:
       return WebMouseEvent::LeftButtonDown;
-    case WebMouseEvent::ButtonMiddle:
+    case WebMouseEvent::Button::Middle:
       return WebMouseEvent::MiddleButtonDown;
-    case WebMouseEvent::ButtonRight:
+    case WebMouseEvent::Button::Right:
       return WebMouseEvent::RightButtonDown;
   }
   NOTREACHED();
   return 0;
 }
 
 const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown
     | WebMouseEvent::MiddleButtonDown | WebMouseEvent::RightButtonDown;
 
 int modifiersWithButtons(int modifiers, int buttons) {
@@ skipping 1072 matching lines @@
 
 void EventSenderBindings::SetWmSysDeadChar(int sys_dead_char) {
   if (sender_)
     sender_->set_wm_sys_dead_char(sys_dead_char);
 }
 #endif
 
 // EventSender -----------------------------------------------------------------
 
 WebMouseEvent::Button EventSender::last_button_type_ =
-    WebMouseEvent::ButtonNone;
+    WebMouseEvent::Button::NoButton;
 
 EventSender::SavedEvent::SavedEvent()
     : type(TYPE_UNSPECIFIED),
-      button_type(WebMouseEvent::ButtonNone),
+      button_type(WebMouseEvent::Button::NoButton),
       milliseconds(0),
       modifiers(0) {}
 
 EventSender::EventSender(WebViewTestProxyBase* web_view_test_proxy_base)
     : web_view_test_proxy_base_(web_view_test_proxy_base),
       replaying_saved_events_(false),
       weak_factory_(this) {
   Reset();
 }
 
 EventSender::~EventSender() {}
 
 void EventSender::Reset() {
   DCHECK(current_drag_data_.isNull());
   current_drag_data_.reset();
   current_drag_effect_ = blink::WebDragOperationNone;
   current_drag_effects_allowed_ = blink::WebDragOperationNone;
   if (view() &&
       current_pointer_state_[kRawMousePointerId].pressed_button_ !=
-          WebMouseEvent::ButtonNone)
+          WebMouseEvent::Button::NoButton)
     view()->mouseCaptureLost();
   current_pointer_state_.clear();
   is_drag_mode_ = true;
   force_layout_on_events_ = true;
 
 #if defined(OS_WIN)
   wm_key_down_ = WM_KEYDOWN;
   wm_key_up_ = WM_KEYUP;
   wm_char_ = WM_CHAR;
   wm_dead_char_ = WM_DEADCHAR;
   wm_sys_key_down_ = WM_SYSKEYDOWN;
   wm_sys_key_up_ = WM_SYSKEYUP;
   wm_sys_char_ = WM_SYSCHAR;
   wm_sys_dead_char_ = WM_SYSDEADCHAR;
 #endif
 
   last_click_time_sec_ = 0;
   last_click_pos_ = WebPoint(0, 0);
-  last_button_type_ = WebMouseEvent::ButtonNone;
+  last_button_type_ = WebMouseEvent::Button::NoButton;
   touch_points_.clear();
   last_context_menu_data_.reset();
   weak_factory_.InvalidateWeakPtrs();
   current_gesture_location_ = WebPoint(0, 0);
   mouse_event_queue_.clear();
 
   time_offset_ms_ = 0;
   click_count_ = 0;
 
   touch_modifiers_ = 0;
@@ skipping 107 matching lines @@
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_MOUSE_UP;
     saved_event.button_type = button_type;
     saved_event.modifiers = modifiers;
     mouse_event_queue_.push_back(saved_event);
     ReplaySavedEvents();
   } else {
     current_pointer_state_[pointerId].current_buttons_ &=
         ~GetWebMouseEventModifierForButton(button_type);
     current_pointer_state_[pointerId].pressed_button_ =
-        WebMouseEvent::ButtonNone;
+        WebMouseEvent::Button::NoButton;
 
     WebMouseEvent event;
     int click_count = pointerType == WebPointerProperties::PointerType::Mouse
                           ? click_count_
                           : 0;
     InitMouseEventGeneric(WebInputEvent::MouseUp, button_type,
                           current_pointer_state_[pointerId].current_buttons_,
                           current_pointer_state_[pointerId].last_pos_,
                           GetCurrentEventTimeSec(), click_count, modifiers,
                           pointerType, pointerId, pressure, tiltX, tiltY,
@@ skipping 274 matching lines @@
 
 void EventSender::FireKeyboardEventsToElement() {}
 
 void EventSender::ClearKillRing() {}
 
 std::vector<std::string> EventSender::ContextClick() {
   if (force_layout_on_events_) {
     view()->updateAllLifecyclePhases();
   }
 
-  UpdateClickCountForButton(WebMouseEvent::ButtonRight);
+  UpdateClickCountForButton(WebMouseEvent::Button::Right);
 
   // Clears last context menu data because we need to know if the context menu
   // be requested after following mouse events.
   last_context_menu_data_.reset();
 
   // Generate right mouse down and up.
   WebMouseEvent event;
   // This is a hack to work around only allowing a single pressed button since
   // we want to test the case where both the left and right mouse buttons are
   // pressed.
   // TODO(mustaq): This hack seems unused here! But do we need this hack at all
   //   after adding current_buttons_.
   if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
-      WebMouseEvent::ButtonNone) {
+      WebMouseEvent::Button::NoButton) {
     current_pointer_state_[kRawMousePointerId].pressed_button_ =
-        WebMouseEvent::ButtonRight;
+        WebMouseEvent::Button::Right;
     current_pointer_state_[kRawMousePointerId].current_buttons_ |=
         GetWebMouseEventModifierForButton(
             current_pointer_state_[kRawMousePointerId].pressed_button_);
   }
-  InitMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::ButtonRight,
+  InitMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::Button::Right,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 
 #if defined(OS_WIN)
   current_pointer_state_[kRawMousePointerId].current_buttons_ &=
-      ~GetWebMouseEventModifierForButton(WebMouseEvent::ButtonRight);
+      ~GetWebMouseEventModifierForButton(WebMouseEvent::Button::Right);
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
-      WebMouseEvent::ButtonNone;
+      WebMouseEvent::Button::NoButton;
 
-  InitMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::ButtonRight,
+  InitMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::Button::Right,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 #endif
 
   std::vector<std::string> menu_items =
       MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate());
   last_context_menu_data_.reset();
   return menu_items;
@@ skipping 200 matching lines @@
 
 void EventSender::NotifyStartOfTouchScroll() {
   WebTouchEvent event;
   event.type = WebInputEvent::TouchScrollStarted;
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::LeapForward(int milliseconds) {
   if (is_drag_mode_ &&
       current_pointer_state_[kRawMousePointerId].pressed_button_ ==
-          WebMouseEvent::ButtonLeft &&
+          WebMouseEvent::Button::Left &&
       !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_LEAP_FORWARD;
     saved_event.milliseconds = milliseconds;
     mouse_event_queue_.push_back(saved_event);
   } else {
     DoLeapForward(milliseconds);
   }
 }
 
@@ skipping 29 matching lines @@
   // Provide a drag source.
   view()->dragTargetDragEnter(
       current_drag_data_, scaled_last_pos, scaled_last_pos,
       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.
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
-      WebMouseEvent::ButtonLeft;
+      WebMouseEvent::Button::Left;
   current_pointer_state_[kRawMousePointerId].current_buttons_ |=
       GetWebMouseEventModifierForButton(
           current_pointer_state_[kRawMousePointerId].pressed_button_);
 }
 
 void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
   WebTouchPoint touch_point;
   touch_point.pointerType = WebPointerProperties::PointerType::Touch;
   touch_point.state = WebTouchPoint::StatePressed;
   touch_point.position = WebFloatPoint(x, y);
@@ skipping 107 matching lines @@
   float pressure = 0;
   int tiltX = 0;
   int tiltY = 0;
   if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
                                     tiltX, tiltY))
     return;
 
   if (pointerType == WebPointerProperties::PointerType::Mouse &&
       is_drag_mode_ && !replaying_saved_events_ &&
       current_pointer_state_[kRawMousePointerId].pressed_button_ ==
-          WebMouseEvent::ButtonLeft) {
+          WebMouseEvent::Button::Left) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_MOUSE_MOVE;
     saved_event.pos = mouse_pos;
     saved_event.modifiers = modifiers;
     mouse_event_queue_.push_back(saved_event);
   } else {
     current_pointer_state_[pointerId].last_pos_ = mouse_pos;
     WebMouseEvent event;
     int click_count = pointerType == WebPointerProperties::PointerType::Mouse
                           ? click_count_
                           : 0;
     InitMouseEventGeneric(
         WebInputEvent::MouseMove,
         current_pointer_state_[kRawMousePointerId].pressed_button_,
         current_pointer_state_[kRawMousePointerId].current_buttons_, mouse_pos,
         GetCurrentEventTimeSec(), click_count, modifiers, pointerType,
         pointerId, pressure, tiltX, tiltY, &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseMove(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   WebMouseEvent event;
-  InitMouseEvent(WebInputEvent::MouseLeave, WebMouseEvent::ButtonNone, 0,
+  InitMouseEvent(WebInputEvent::MouseLeave, WebMouseEvent::Button::NoButton, 0,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseDown, weak_factory_.GetWeakPtr(),
                  button_number, modifiers)));
@@ skipping 504 matching lines @@
 
   // Bail if dragover caused cancellation.
   if (current_drag_data_.isNull())
     return;
 
   FinishDragAndDrop(unscaled_event, drag_effect);
 }
 
 void EventSender::DoDragAfterMouseMove(const WebMouseEvent& unscaled_event) {
   if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
-          WebMouseEvent::ButtonNone ||
+          WebMouseEvent::Button::NoButton ||
       current_drag_data_.isNull()) {
     return;
   }
 
   std::unique_ptr<WebInputEvent> scaled_event = ScaleEvent(unscaled_event);
   const WebMouseEvent* event =
       scaled_event.get() ? static_cast<WebMouseEvent*>(scaled_event.get())
                          : &unscaled_event;
 
   WebPoint client_point(event->x, event->y);
@@ skipping 23 matching lines @@
         DoDragAfterMouseMove(event);
         break;
       }
       case SavedEvent::TYPE_LEAP_FORWARD:
         DoLeapForward(e.milliseconds);
         break;
       case SavedEvent::TYPE_MOUSE_UP: {
         current_pointer_state_[kRawMousePointerId].current_buttons_ &=
             ~GetWebMouseEventModifierForButton(e.button_type);
         current_pointer_state_[kRawMousePointerId].pressed_button_ =
-            WebMouseEvent::ButtonNone;
+            WebMouseEvent::Button::NoButton;
 
         WebMouseEvent event;
         InitMouseEvent(
             WebInputEvent::MouseUp, e.button_type,
             current_pointer_state_[kRawMousePointerId].current_buttons_,
             current_pointer_state_[kRawMousePointerId].last_pos_,
             GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseUp(event);
         break;
@@ skipping 95 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