Move //components/test_runner back into //content/shell

content/shell/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 "content/shell/test_runner/event_sender.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "components/test_runner/mock_spell_check.h"
-#include "components/test_runner/test_interfaces.h"
-#include "components/test_runner/web_test_delegate.h"
-#include "components/test_runner/web_view_test_proxy.h"
-#include "components/test_runner/web_widget_test_proxy.h"
+#include "content/shell/test_runner/mock_spell_check.h"
+#include "content/shell/test_runner/test_interfaces.h"
+#include "content/shell/test_runner/web_test_delegate.h"
+#include "content/shell/test_runner/web_view_test_proxy.h"
+#include "content/shell/test_runner/web_widget_test_proxy.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
 #include "net/base/filename_util.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h"
 #include "third_party/WebKit/public/platform/WebGestureEvent.h"
 #include "third_party/WebKit/public/platform/WebKeyboardEvent.h"
 #include "third_party/WebKit/public/platform/WebPointerProperties.h"
 #include "third_party/WebKit/public/platform/WebString.h"
@@ skipping 148 matching lines @@
       return 0;
     case WebMouseEvent::Button::Left:
       return WebMouseEvent::LeftButtonDown;
     case WebMouseEvent::Button::Middle:
       return WebMouseEvent::MiddleButtonDown;
     case WebMouseEvent::Button::Right:
       return WebMouseEvent::RightButtonDown;
     case WebPointerProperties::Button::X1:
     case WebPointerProperties::Button::X2:
     case WebPointerProperties::Button::Eraser:
-      return 0; // Not implemented yet
+      return 0;  // Not implemented yet
   }
   NOTREACHED();
   return 0;
 }
 
-const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown
-    | WebMouseEvent::MiddleButtonDown | WebMouseEvent::RightButtonDown;
+const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown |
+                                WebMouseEvent::MiddleButtonDown |
+                                WebMouseEvent::RightButtonDown;
 
 int modifiersWithButtons(int modifiers, int buttons) {
-  return (modifiers & ~kButtonsInModifiers)
-      | (buttons & kButtonsInModifiers);
+  return (modifiers & ~kButtonsInModifiers) | (buttons & kButtonsInModifiers);
 }
 
 void InitMouseEventGeneric(WebMouseEvent::Button b,
                            int current_buttons,
                            const WebPoint& pos,
                            int click_count,
                            WebPointerProperties::PointerType pointerType,
                            int pointerId,
                            float pressure,
                            int tiltX,
@@ skipping 30 matching lines @@
   gesture_event->globalX = wheel_event.globalX;
   gesture_event->globalY = wheel_event.globalY;
 }
 
 int GetKeyModifier(const std::string& modifier_name) {
   const char* characters = modifier_name.c_str();
   if (!strcmp(characters, "ctrlKey")
 #ifndef __APPLE__
       || !strcmp(characters, "addSelectionKey")
 #endif
-      ) {
+          ) {
     return WebInputEvent::ControlKey;
   } else if (!strcmp(characters, "shiftKey") ||
              !strcmp(characters, "rangeSelectionKey")) {
     return WebInputEvent::ShiftKey;
   } else if (!strcmp(characters, "altKey")) {
     return WebInputEvent::AltKey;
 #ifdef __APPLE__
   } else if (!strcmp(characters, "metaKey") ||
              !strcmp(characters, "addSelectionKey")) {
     return WebInputEvent::MetaKey;
@@ skipping 53 matching lines @@
     modifiers |= GetKeyModifier(*it);
   }
   return modifiers;
 }
 
 int GetKeyModifiersFromV8(v8::Isolate* isolate, v8::Local<v8::Value> value) {
   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);
+    gin::Converter<std::vector<std::string>>::FromV8(isolate, value,
+                                                     &modifier_names);
   }
   return GetKeyModifiers(modifier_names);
 }
 
 WebMouseWheelEvent::Phase GetMouseWheelEventPhase(
     const std::string& phase_name) {
   if (phase_name == "phaseNone") {
     return WebMouseWheelEvent::PhaseNone;
   } else if (phase_name == "phaseBegan") {
     return WebMouseWheelEvent::PhaseBegan;
@@ skipping 28 matching lines @@
 const char kSeparatorIdentifier[] = "---------";
 const char kDisabledIdentifier[] = "#";
 const char kCheckedIdentifier[] = "*";
 
 bool OutsideMultiClickRadius(const WebPoint& a, const WebPoint& b) {
   return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) >
          kMultipleClickRadiusPixels * kMultipleClickRadiusPixels;
 }
 
 void PopulateCustomItems(const WebVector<WebMenuItemInfo>& customItems,
-    const std::string& prefix, std::vector<std::string>* strings) {
+                         const std::string& prefix,
+                         std::vector<std::string>* strings) {
   for (size_t i = 0; i < customItems.size(); ++i) {
     std::string prefixCopy = prefix;
     if (!customItems[i].enabled)
-        prefixCopy = kDisabledIdentifier + prefix;
+      prefixCopy = kDisabledIdentifier + prefix;
     if (customItems[i].checked)
-        prefixCopy = kCheckedIdentifier + prefix;
+      prefixCopy = kCheckedIdentifier + prefix;
     if (customItems[i].type == blink::WebMenuItemInfo::Separator) {
       strings->push_back(prefixCopy + kSeparatorIdentifier);
     } else if (customItems[i].type == blink::WebMenuItemInfo::SubMenu) {
       strings->push_back(prefixCopy + customItems[i].label.utf8() +
-          customItems[i].icon.utf8() + kSubMenuIdentifier);
-      PopulateCustomItems(customItems[i].subMenuItems, prefixCopy +
-          kSubMenuDepthIdentifier, strings);
+                         customItems[i].icon.utf8() + kSubMenuIdentifier);
+      PopulateCustomItems(customItems[i].subMenuItems,
+                          prefixCopy + kSubMenuDepthIdentifier, strings);
     } else {
       strings->push_back(prefixCopy + customItems[i].label.utf8() +
-          customItems[i].icon.utf8());
+                         customItems[i].icon.utf8());
     }
   }
 }
 
 // Because actual context menu is implemented by the browser side,
 // this function does only what LayoutTests are expecting:
 // - Many test checks the count of items. So returning non-zero value makes
 // sense.
 // - Some test compares the count before and after some action. So changing the
 // count based on flags also makes sense. This function is doing such for some
 // flags.
 // - Some test even checks actual string content. So providing it would be also
 // helpful.
 std::vector<std::string> MakeMenuItemStringsFor(
     WebContextMenuData* context_menu,
     WebTestDelegate* delegate) {
   // These constants are based on Safari's context menu because tests are made
   // for it.
   static const char* kNonEditableMenuStrings[] = {
-    "Back",
-    "Reload Page",
-    "Open in Dashbaord",
-    "<separator>",
-    "View Source",
-    "Save Page As",
-    "Print Page",
-    "Inspect Element",
-    0
-  };
-  static const char* kEditableMenuStrings[] = {
-    "Cut",
-    "Copy",
-    "<separator>",
-    "Paste",
-    "Spelling and Grammar",
-    "Substitutions, Transformations",
-    "Font",
-    "Speech",
-    "Paragraph Direction",
-    "<separator>",
-    0
-  };
+      "Back",        "Reload Page",     "Open in Dashbaord",
+      "<separator>", "View Source",     "Save Page As",
+      "Print Page",  "Inspect Element", 0};
+  static const char* kEditableMenuStrings[] = {"Cut",
+                                               "Copy",
+                                               "<separator>",
+                                               "Paste",
+                                               "Spelling and Grammar",
+                                               "Substitutions, Transformations",
+                                               "Font",
+                                               "Speech",
+                                               "Paragraph Direction",
+                                               "<separator>",
+                                               0};
 
   // This is possible because mouse events are cancelleable.
   if (!context_menu)
     return std::vector<std::string>();
 
   std::vector<std::string> strings;
 
   // Populate custom menu items if provided by blink.
   PopulateCustomItems(context_menu->customItems, "", &strings);
 
@@ skipping 18 matching lines @@
 
 // How much we should scroll per event - the value here is chosen to match the
 // WebKit impl and layout test results.
 const float kScrollbarPixelsPerTick = 40.0f;
 
 // Get the edit command corresponding to a keyboard event.
 // Returns true if the specified event corresponds to an edit command, the name
 // of the edit command will be stored in |*name|.
 bool GetEditCommand(const WebKeyboardEvent& event, std::string* name) {
 #if defined(OS_MACOSX)
-// We only cares about Left,Right,Up,Down keys with Command or Command+Shift
-// modifiers. These key events correspond to some special movement and
-// selection editor commands. These keys will be marked as system key, which
-// prevents them from being handled. Thus they must be handled specially.
+  // We only cares about Left,Right,Up,Down keys with Command or Command+Shift
+  // modifiers. These key events correspond to some special movement and
+  // selection editor commands. These keys will be marked as system key, which
+  // prevents them from being handled. Thus they must be handled specially.
   if ((event.modifiers() & ~WebKeyboardEvent::ShiftKey) !=
       WebKeyboardEvent::MetaKey)
     return false;
 
   switch (event.windowsKeyCode) {
     case ui::VKEY_LEFT:
       *name = "MoveToBeginningOfLine";
       break;
     case ui::VKEY_RIGHT:
       *name = "MoveToEndOfLine";
@@ skipping 165 matching lines @@
 #endif
 
   base::WeakPtr<EventSender> sender_;
 
   DISALLOW_COPY_AND_ASSIGN(EventSenderBindings);
 };
 
 gin::WrapperInfo EventSenderBindings::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 EventSenderBindings::EventSenderBindings(base::WeakPtr<EventSender> sender)
-    : sender_(sender) {
-}
+    : sender_(sender) {}
 
 EventSenderBindings::~EventSenderBindings() {}
 
 // static
 void EventSenderBindings::Install(base::WeakPtr<EventSender> sender,
                                   WebLocalFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
   gin::Handle<EventSenderBindings> bindings =
       gin::CreateHandle(isolate, new EventSenderBindings(sender));
   if (bindings.IsEmpty())
     return;
   v8::Local<v8::Object> global = context->Global();
   global->Set(gin::StringToV8(isolate, "eventSender"), bindings.ToV8());
 }
 
-gin::ObjectTemplateBuilder
-EventSenderBindings::GetObjectTemplateBuilder(v8::Isolate* isolate) {
+gin::ObjectTemplateBuilder EventSenderBindings::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
   return gin::Wrappable<EventSenderBindings>::GetObjectTemplateBuilder(isolate)
       .SetMethod("enableDOMUIEventLogging",
                  &EventSenderBindings::EnableDOMUIEventLogging)
       .SetMethod("fireKeyboardEventsToElement",
                  &EventSenderBindings::FireKeyboardEventsToElement)
       .SetMethod("clearKillRing", &EventSenderBindings::ClearKillRing)
       .SetMethod("contextClick", &EventSenderBindings::ContextClick)
       .SetMethod("textZoomIn", &EventSenderBindings::TextZoomIn)
       .SetMethod("textZoomOut", &EventSenderBindings::TextZoomOut)
       .SetMethod("zoomPageIn", &EventSenderBindings::ZoomPageIn)
@@ skipping 634 matching lines @@
   last_context_menu_data_.reset(new WebContextMenuData(data));
 }
 
 int EventSender::ModifiersForPointer(int pointer_id) {
   return modifiersWithButtons(
       current_pointer_state_[pointer_id].modifiers_,
       current_pointer_state_[pointer_id].current_buttons_);
 }
 
 void EventSender::DoDragDrop(const WebDragData& drag_data,
-                              WebDragOperationsMask mask) {
+                             WebDragOperationsMask mask) {
   WebMouseEvent raw_event(WebInputEvent::MouseDown,
                           ModifiersForPointer(kRawMousePointerId),
                           GetCurrentEventTimeSec());
   InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  click_count_, &raw_event);
 
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
@@ skipping 311 matching lines @@
   }
 
   // For one generated keyboard event, we need to generate a keyDown/keyUp
   // pair;
   // On Windows, we might also need to generate a char event to mimic the
   // Windows event flow; on other platforms we create a merged event and test
   // the event flow that that platform provides.
   WebKeyboardEvent event_down(WebInputEvent::RawKeyDown, modifiers,
                               GetCurrentEventTimeSec());
   event_down.windowsKeyCode = code;
-  event_down.domKey = static_cast<int>(
-      ui::KeycodeConverter::KeyStringToDomKey(domKeyString));
+  event_down.domKey =
+      static_cast<int>(ui::KeycodeConverter::KeyStringToDomKey(domKeyString));
   event_down.domCode = static_cast<int>(
       ui::KeycodeConverter::CodeStringToDomCode(domCodeString));
 
   if (generate_char) {
     event_down.text[0] = text;
     event_down.unmodifiedText[0] = text;
   }
 
   if (event_down.modifiers() != 0)
     event_down.isSystemKey = IsSystemKeyEvent(event_down);
@@ skipping 178 matching lines @@
 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::SetTouchModifier(const std::string& key_name,
-                                    bool set_mask) {
+void EventSender::SetTouchModifier(const std::string& key_name, bool set_mask) {
   int mask = GetKeyModifier(key_name);
 
   if (set_mask)
     touch_modifiers_ |= mask;
   else
     touch_modifiers_ &= ~mask;
 }
 
 void EventSender::SetTouchCancelable(bool cancelable) {
   touch_cancelable_ = cancelable;
@@ skipping 59 matching lines @@
     event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   } else {
     args->ThrowError();
     return;
   }
 
   float max_start_velocity = std::max(fabs(velocity_x), fabs(velocity_y));
   if (!max_start_velocity) {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     isolate->ThrowException(v8::Exception::TypeError(
-      gin::StringToV8(isolate, "Invalid max start velocity.")));
+        gin::StringToV8(isolate, "Invalid max start velocity.")));
     return;
   }
 
   event.x = x;
   event.y = y;
   event.globalX = event.x;
   event.globalY = event.y;
 
   event.data.flingStart.velocityX = velocity_x;
   event.data.flingStart.velocityY = velocity_y;
@@ skipping 47 matching lines @@
     DoLeapForward(milliseconds);
   }
 }
 
 void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) {
   if (!current_drag_data_.isNull()) {
     // Nested dragging not supported, fuzzer code a likely culprit.
     // Cancel the current drag operation and throw an error.
     KeyDown("Escape", 0, DOMKeyLocationStandard);
     v8::Isolate* isolate = blink::mainThreadIsolate();
-    isolate->ThrowException(v8::Exception::Error(
-        gin::StringToV8(isolate,
-                        "Nested beginDragWithFiles() not supported.")));
+    isolate->ThrowException(v8::Exception::Error(gin::StringToV8(
+        isolate, "Nested beginDragWithFiles() not supported.")));
     return;
   }
   current_drag_data_.initialize();
   WebVector<WebString> absolute_filenames(files.size());
   for (size_t i = 0; i < files.size(); ++i) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeFilename;
     item.filenameData = delegate()->GetAbsoluteWebStringFromUTF8Path(files[i]);
     current_drag_data_.addItem(item);
     absolute_filenames[i] = item.filenameData;
   }
   current_drag_data_.setFilesystemId(
       delegate()->RegisterIsolatedFileSystem(absolute_filenames));
   current_drag_effects_allowed_ = blink::WebDragOperationCopy;
 
   const WebPoint& last_pos =
       current_pointer_state_[kRawMousePointerId].last_pos_;
   float scale = delegate()->GetWindowToViewportScale();
   WebPoint scaled_last_pos(last_pos.x * scale, last_pos.y * scale);
 
   // Provide a drag source.
-  mainFrameWidget()->dragTargetDragEnter(
-      current_drag_data_, scaled_last_pos, scaled_last_pos,
-      current_drag_effects_allowed_, 0);
+  mainFrameWidget()->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::Button::Left;
   current_pointer_state_[kRawMousePointerId].current_buttons_ |=
       GetWebMouseEventModifierForButton(
           current_pointer_state_[kRawMousePointerId].pressed_button_);
@@ skipping 11 matching lines @@
     if (touch_points_[i].id > highest_id)
       highest_id = touch_points_[i].id;
   }
   touch_point.id = highest_id + 1;
 
   InitPointerProperties(args, &touch_point, &touch_point.radiusX,
                         &touch_point.radiusY);
 
   // Set the touch point pressure to zero if it was not set by the caller
   if (std::isnan(touch_point.force))
-      touch_point.force = 0.0;
+    touch_point.force = 0.0;
 
   touch_points_.push_back(touch_point);
 }
 
 void EventSender::GestureScrollBegin(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollBegin, args);
 }
 
 void EventSender::GestureScrollEnd(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollEnd, args);
@@ skipping 121 matching lines @@
 
   WebMouseEvent event(WebInputEvent::MouseLeave,
                       ModifiersForPointer(kRawMousePointerId),
                       GetCurrentEventTimeSec());
   InitMouseEvent(WebMouseEvent::Button::NoButton, 0,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
                  click_count_, &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
-
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate()->PostTask(base::Bind(&EventSender::MouseDown,
                                   weak_factory_.GetWeakPtr(), button_number,
                                   modifiers));
   delegate()->PostTask(base::Bind(&EventSender::MouseUp,
                                   weak_factory_.GetWeakPtr(), button_number,
                                   modifiers));
 }
 
 void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
                                               int modifiers,
                                               KeyLocationCode location) {
   delegate()->PostTask(base::Bind(&EventSender::KeyDown,
                                   weak_factory_.GetWeakPtr(), code_str,
                                   modifiers, location));
 }
 
 double EventSender::GetCurrentEventTimeSec() {
   return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF() +
          time_offset_ms_ / 1000.0;
 }
 
 void EventSender::DoLeapForward(int milliseconds) {
   time_offset_ms_ += milliseconds;
 }
 
 uint32_t EventSender::GetUniqueTouchEventId(gin::Arguments* args) {
   uint32_t unique_touch_event_id;
-  if(!args->PeekNext().IsEmpty() && args->GetNext(&unique_touch_event_id))
+  if (!args->PeekNext().IsEmpty() && args->GetNext(&unique_touch_event_id))
     return unique_touch_event_id;
 
   return 0;
 }
 
 void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
                                         gin::Arguments* args) {
   uint32_t unique_touch_event_id = GetUniqueTouchEventId(args);
 
   DCHECK_GT(static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap),
             touch_points_.size());
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   WebTouchEvent touch_event(type, touch_modifiers_, GetCurrentEventTimeSec());
   touch_event.dispatchType = touch_cancelable_
                                  ? WebInputEvent::Blocking
                                  : WebInputEvent::EventNonBlocking;
   touch_event.movedBeyondSlopRegion = true;
   touch_event.uniqueTouchEventId = unique_touch_event_id;
   touch_event.touchesLength = touch_points_.size();
   for (size_t i = 0; i < touch_points_.size(); ++i)
     touch_event.touches[i] = touch_points_[i];
   HandleInputEventOnViewOrPopup(touch_event);
 
   for (size_t i = 0; i < touch_points_.size(); ++i) {
     WebTouchPoint* touch_point = &touch_points_[i];
-    if (touch_point->state == WebTouchPoint::StateReleased
-        || touch_point->state == WebTouchPoint::StateCancelled) {
+    if (touch_point->state == WebTouchPoint::StateReleased ||
+        touch_point->state == WebTouchPoint::StateCancelled) {
       touch_points_.erase(touch_points_.begin() + i);
       --i;
     } else {
       touch_point->state = WebTouchPoint::StateStationary;
     }
   }
 }
 
-void EventSender::GestureEvent(WebInputEvent::Type type,
-                               gin::Arguments* args) {
+void EventSender::GestureEvent(WebInputEvent::Type type, gin::Arguments* args) {
   WebGestureEvent event(type, WebInputEvent::NoModifiers,
                         GetCurrentEventTimeSec());
 
   // If the first argument is a string, it is to specify the device, otherwise
   // the device is assumed to be a touchscreen (since most tests were written
   // assuming this).
   event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) {
     std::string device_string;
     if (!args->GetNext(&device_string)) {
@@ skipping 11 matching lines @@
   }
 
   double x;
   double y;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
     args->ThrowError();
     return;
   }
 
   switch (type) {
-    case WebInputEvent::GestureScrollUpdate:
-    {
+    case WebInputEvent::GestureScrollUpdate: {
       bool preventPropagation = false;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&preventPropagation)) {
           args->ThrowError();
           return;
         }
       }
       if (!GetScrollUnits(args, &event.data.scrollUpdate.deltaUnits))
         return;
 
@@ skipping 17 matching lines @@
     case WebInputEvent::GestureFlingStart:
       event.x = current_gesture_location_.x;
       event.y = current_gesture_location_.y;
       break;
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
       current_gesture_location_ = WebPoint(x, y);
       event.x = current_gesture_location_.x;
       event.y = current_gesture_location_.y;
       break;
-    case WebInputEvent::GesturePinchUpdate:
-    {
+    case WebInputEvent::GesturePinchUpdate: {
       float scale = 1;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&scale)) {
           args->ThrowError();
           return;
         }
       }
       event.data.pinchUpdate.scale = scale;
       current_gesture_location_ = WebPoint(x, y);
       event.x = current_gesture_location_.x;
       event.y = current_gesture_location_.y;
       break;
     }
-    case WebInputEvent::GestureTap:
-    {
+    case WebInputEvent::GestureTap: {
       float tap_count = 1;
       float width = 30;
       float height = 30;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&tap_count)) {
           args->ThrowError();
           return;
         }
       }
       if (!args->PeekNext().IsEmpty()) {
@@ skipping 22 matching lines @@
           args->ThrowError();
           return;
         }
         event.data.tap.tapCount = tap_count;
       } else {
         event.data.tap.tapCount = 1;
       }
       event.x = x;
       event.y = y;
       break;
-    case WebInputEvent::GestureTapDown:
-    {
+    case WebInputEvent::GestureTapDown: {
       float width = 30;
       float height = 30;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&width)) {
           args->ThrowError();
           return;
         }
       }
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&height)) {
           args->ThrowError();
           return;
         }
       }
       event.x = x;
       event.y = y;
       event.data.tapDown.width = width;
       event.data.tapDown.height = height;
       break;
     }
-    case WebInputEvent::GestureShowPress:
-    {
+    case WebInputEvent::GestureShowPress: {
       float width = 30;
       float height = 30;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&width)) {
           args->ThrowError();
           return;
         }
         if (!args->PeekNext().IsEmpty()) {
           if (!args->GetNext(&height)) {
             args->ThrowError();
@@ skipping 74 matching lines @@
 
     InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
                    current_pointer_state_[kRawMousePointerId].current_buttons_,
                    WebPoint(x, y), click_count_, &mouse_event);
 
     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
   }
   args->Return(result != WebInputEventResult::NotHandled);
 }
 
-void EventSender::UpdateClickCountForButton(
-    WebMouseEvent::Button button_type) {
+void EventSender::UpdateClickCountForButton(WebMouseEvent::Button button_type) {
   if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
        kMultipleClickTimeSec) &&
       (!OutsideMultiClickRadius(
           current_pointer_state_[kRawMousePointerId].last_pos_,
           last_click_pos_)) &&
       (button_type == last_button_type_)) {
     ++click_count_;
   } else {
     click_count_ = 1;
     last_button_type_ = button_type;
@@ skipping 344 matching lines @@
   return view()->mainFrame()->toWebLocalFrame()->frameWidget();
 }
 
 std::unique_ptr<WebInputEvent> EventSender::TransformScreenToWidgetCoordinates(
     const WebInputEvent& event) {
   return delegate()->TransformScreenToWidgetCoordinates(
       web_widget_test_proxy_base_, event);
 }
 
 }  // namespace test_runner