Add constructors to WebInputEvents and setters so we can work at cleaning up these public structs.

content/browser/devtools/protocol/input_handler.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/browser/devtools/protocol/input_handler.h"
 
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 37 matching lines @@
     out = SyntheticGestureParams::GestureSourceType::TOUCH_INPUT;
     return true;
   }
   if (in.fromJust() == Input::GestureSourceTypeEnum::Mouse) {
     out = SyntheticGestureParams::GestureSourceType::MOUSE_INPUT;
     return true;
   }
   return false;
 }
 
-void SetEventModifiers(blink::WebInputEvent* event, int modifiers) {
+int GetEventModifiers(int modifiers, bool auto_repeat, bool is_keypad) {
+  int result = 0;
+  if (auto_repeat)
+    result |= blink::WebInputEvent::IsAutoRepeat;
+  if (is_keypad)
+    result |= blink::WebInputEvent::IsKeyPad;
+
   if (modifiers & 1)
-    event->modifiers |= blink::WebInputEvent::AltKey;
+    result |= blink::WebInputEvent::AltKey;
   if (modifiers & 2)
-    event->modifiers |= blink::WebInputEvent::ControlKey;
+    result |= blink::WebInputEvent::ControlKey;
   if (modifiers & 4)
-    event->modifiers |= blink::WebInputEvent::MetaKey;
+    result |= blink::WebInputEvent::MetaKey;
   if (modifiers & 8)
-    event->modifiers |= blink::WebInputEvent::ShiftKey;
+    result |= blink::WebInputEvent::ShiftKey;
+  return result;
 }
 
-void SetEventTimestamp(blink::WebInputEvent* event, Maybe<double> timestamp) {
+base::TimeTicks GetEventTimeTicks(Maybe<double> timestamp) {
   // Convert timestamp, in seconds since unix epoch, to an event timestamp
   // which is time ticks since platform start time.
-  base::TimeTicks ticks = timestamp.isJust()
-      ? base::TimeDelta::FromSecondsD(timestamp.fromJust()) +
-          base::TimeTicks::UnixEpoch()
-      : base::TimeTicks::Now();
-  event->timeStampSeconds = (ticks - base::TimeTicks()).InSecondsF();
+  return timestamp.isJust()
+             ? base::TimeDelta::FromSecondsD(timestamp.fromJust()) +
+                   base::TimeTicks::UnixEpoch()
+             : base::TimeTicks::Now();
+}
+
+double GetEventTimestamp(Maybe<double> timestamp) {
+  return (GetEventTimeTicks(std::move(timestamp)) - base::TimeTicks())
+      .InSecondsF();
 }
 
 bool SetKeyboardEventText(blink::WebUChar* to, Maybe<std::string> from) {
   if (!from.isJust())
     return true;
 
   base::string16 text16 = base::UTF8ToUTF16(from.fromJust());
   if (text16.size() > blink::WebKeyboardEvent::textLengthCap)
     return false;
 
   for (size_t i = 0; i < text16.size(); ++i)
     to[i] = text16[i];
   return true;
 }
 
-bool SetMouseEventButton(blink::WebMouseEvent* event,
-                         const std::string& button) {
+bool GetMouseEventButton(const std::string& button,
+                         blink::WebPointerProperties::Button* event_button,
+                         int* event_modifiers) {
   if (button.empty())
     return true;
 
   if (button == Input::DispatchMouseEvent::ButtonEnum::None) {
-    event->button = blink::WebMouseEvent::Button::NoButton;
+    *event_button = blink::WebMouseEvent::Button::NoButton;
   } else if (button == Input::DispatchMouseEvent::ButtonEnum::Left) {
-    event->button = blink::WebMouseEvent::Button::Left;
-    event->modifiers |= blink::WebInputEvent::LeftButtonDown;
+    *event_button = blink::WebMouseEvent::Button::Left;
+    *event_modifiers = blink::WebInputEvent::LeftButtonDown;
   } else if (button == Input::DispatchMouseEvent::ButtonEnum::Middle) {
-    event->button = blink::WebMouseEvent::Button::Middle;
-    event->modifiers |= blink::WebInputEvent::MiddleButtonDown;
+    *event_button = blink::WebMouseEvent::Button::Middle;
+    *event_modifiers = blink::WebInputEvent::MiddleButtonDown;
   } else if (button == Input::DispatchMouseEvent::ButtonEnum::Right) {
-    event->button = blink::WebMouseEvent::Button::Right;
-    event->modifiers |= blink::WebInputEvent::RightButtonDown;
+    *event_button = blink::WebMouseEvent::Button::Right;
+    *event_modifiers = blink::WebInputEvent::RightButtonDown;
   } else {
     return false;
   }
   return true;
 }
 
-bool SetMouseEventType(blink::WebMouseEvent* event, const std::string& type) {
-  if (type == Input::DispatchMouseEvent::TypeEnum::MousePressed) {
-    event->type = blink::WebInputEvent::MouseDown;
-  } else if (type == Input::DispatchMouseEvent::TypeEnum::MouseReleased) {
-    event->type = blink::WebInputEvent::MouseUp;
-  } else if (type == Input::DispatchMouseEvent::TypeEnum::MouseMoved) {
-    event->type = blink::WebInputEvent::MouseMove;
-  } else {
-    return false;
-  }
-  return true;
+blink::WebInputEvent::Type GetMouseEventType(const std::string& type) {
+  if (type == Input::DispatchMouseEvent::TypeEnum::MousePressed)
+    return blink::WebInputEvent::MouseDown;
+  if (type == Input::DispatchMouseEvent::TypeEnum::MouseReleased)
+    return blink::WebInputEvent::MouseUp;
+  if (type == Input::DispatchMouseEvent::TypeEnum::MouseMoved)
+    return blink::WebInputEvent::MouseMove;
+  return blink::WebInputEvent::Undefined;
 }
 
 void SendSynthesizePinchGestureResponse(
     std::unique_ptr<Input::Backend::SynthesizePinchGestureCallback> callback,
     SyntheticGesture::Result result) {
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     callback->sendSuccess();
   } else {
     callback->sendFailure(Response::Error(
         base::StringPrintf("Synthetic pinch failed, result was %d", result)));
@@ skipping 87 matching lines @@
     Maybe<std::string> text,
     Maybe<std::string> unmodified_text,
     Maybe<std::string> key_identifier,
     Maybe<std::string> code,
     Maybe<std::string> key,
     Maybe<int> windows_virtual_key_code,
     Maybe<int> native_virtual_key_code,
     Maybe<bool> auto_repeat,
     Maybe<bool> is_keypad,
     Maybe<bool> is_system_key) {
-  NativeWebKeyboardEvent event;
-  event.skip_in_browser = true;
+  blink::WebInputEvent::Type web_event_type;
 
   if (type == Input::DispatchKeyEvent::TypeEnum::KeyDown) {
-    event.type = blink::WebInputEvent::KeyDown;
+    web_event_type = blink::WebInputEvent::KeyDown;
   } else if (type == Input::DispatchKeyEvent::TypeEnum::KeyUp) {
-    event.type = blink::WebInputEvent::KeyUp;
+    web_event_type = blink::WebInputEvent::KeyUp;
   } else if (type == Input::DispatchKeyEvent::TypeEnum::Char) {
-    event.type = blink::WebInputEvent::Char;
+    web_event_type = blink::WebInputEvent::Char;
   } else if (type == Input::DispatchKeyEvent::TypeEnum::RawKeyDown) {
-    event.type = blink::WebInputEvent::RawKeyDown;
+    web_event_type = blink::WebInputEvent::RawKeyDown;
   } else {
     return Response::InvalidParams(
         base::StringPrintf("Unexpected event type '%s'", type.c_str()));
   }
 
-  SetEventModifiers(&event, modifiers.fromMaybe(0));
-  SetEventTimestamp(&event, std::move(timestamp));
+  NativeWebKeyboardEvent event(
+      web_event_type,
+      GetEventModifiers(modifiers.fromMaybe(blink::WebInputEvent::NoModifiers),
+                        auto_repeat.fromMaybe(false),
+                        is_keypad.fromMaybe(false)),
+      GetEventTimeTicks(std::move(timestamp)));
+  event.skip_in_browser = true;
   if (!SetKeyboardEventText(event.text, std::move(text)))
     return Response::InvalidParams("Invalid 'text' parameter");
   if (!SetKeyboardEventText(event.unmodifiedText, std::move(unmodified_text)))
     return Response::InvalidParams("Invalid 'unmodifiedText' parameter");
 
   if (windows_virtual_key_code.isJust())
     event.windowsKeyCode = windows_virtual_key_code.fromJust();
   if (native_virtual_key_code.isJust())
     event.nativeKeyCode = native_virtual_key_code.fromJust();
-  if (auto_repeat.fromMaybe(false))
-    event.modifiers |= blink::WebInputEvent::IsAutoRepeat;
-  if (is_keypad.fromMaybe(false))
-    event.modifiers |= blink::WebInputEvent::IsKeyPad;
   if (is_system_key.isJust())
     event.isSystemKey = is_system_key.fromJust();
 
   if (code.isJust()) {
     event.domCode = static_cast<int>(
         ui::KeycodeConverter::CodeStringToDomCode(code.fromJust()));
   }
 
   if (key.isJust()) {
     event.domKey = static_cast<int>(
         ui::KeycodeConverter::KeyStringToDomKey(key.fromJust()));
   }
 
   if (!host_ || !host_->GetRenderWidgetHost())
     return Response::InternalError();
 
   host_->GetRenderWidgetHost()->Focus();
   host_->GetRenderWidgetHost()->ForwardKeyboardEvent(event);
   return Response::OK();
 }
 
 Response InputHandler::DispatchMouseEvent(
     const std::string& type,
     int x,
     int y,
     Maybe<int> modifiers,
     Maybe<double> timestamp,
     Maybe<std::string> button,
     Maybe<int> click_count) {
-  blink::WebMouseEvent event;
-
-  if (!SetMouseEventType(&event, type)) {
+  blink::WebInputEvent::Type event_type = GetMouseEventType(type);
+  if (event_type == blink::WebInputEvent::Undefined) {
     return Response::InvalidParams(
         base::StringPrintf("Unexpected event type '%s'", type.c_str()));
   }
-  SetEventModifiers(&event, modifiers.fromMaybe(0));
-  SetEventTimestamp(&event, std::move(timestamp));
-  if (!SetMouseEventButton(&event, button.fromMaybe("")))
+  blink::WebPointerProperties::Button event_button =
+      blink::WebPointerProperties::Button::NoButton;
+  int button_modifiers = 0;
+  if (!GetMouseEventButton(button.fromMaybe(""), &event_button,
+                           &button_modifiers))
     return Response::InvalidParams("Invalid mouse button");
 
+  blink::WebMouseEvent event(
+      event_type,
+      GetEventModifiers(modifiers.fromMaybe(blink::WebInputEvent::NoModifiers),
+                        false, false) |
+          button_modifiers,
+      GetEventTimestamp(std::move(timestamp)));
+
+  event.button = event_button;
   event.x = x * page_scale_factor_;
   event.y = y * page_scale_factor_;
   event.windowX = x * page_scale_factor_;
   event.windowY = y * page_scale_factor_;
   event.globalX = x * page_scale_factor_;
   event.globalY = y * page_scale_factor_;
   event.clickCount = click_count.fromMaybe(0);
   event.pointerType = blink::WebPointerProperties::PointerType::Mouse;
 
   if (!host_ || !host_->GetRenderWidgetHost())
     return Response::InternalError();
 
   host_->GetRenderWidgetHost()->Focus();
   host_->GetRenderWidgetHost()->ForwardMouseEvent(event);
   return Response::OK();
 }
 
 Response InputHandler::EmulateTouchFromMouseEvent(const std::string& type,
                                                   int x,
                                                   int y,
                                                   double timestamp,
                                                   const std::string& button,
                                                   Maybe<double> delta_x,
                                                   Maybe<double> delta_y,
                                                   Maybe<int> modifiers,
                                                   Maybe<int> click_count) {
-  blink::WebMouseWheelEvent wheel_event;
-  blink::WebMouseEvent mouse_event;
-  blink::WebMouseEvent* event = &mouse_event;
-
+  blink::WebInputEvent::Type event_type;
   if (type == Input::EmulateTouchFromMouseEvent::TypeEnum::MouseWheel) {
+    event_type = blink::WebInputEvent::MouseWheel;
     if (!delta_x.isJust() || !delta_y.isJust()) {
       return Response::InvalidParams(
           "'deltaX' and 'deltaY' are expected for mouseWheel event");
     }
-    wheel_event.deltaX = static_cast<float>(delta_x.fromJust());
-    wheel_event.deltaY = static_cast<float>(delta_y.fromJust());
-    event = &wheel_event;
-    event->type = blink::WebInputEvent::MouseWheel;
-  } else if (!SetMouseEventType(event, type)) {
-    return Response::InvalidParams(
-        base::StringPrintf("Unexpected event type '%s'", type.c_str()));
+  } else {
+    event_type = GetMouseEventType(type);
+    if (event_type == blink::WebInputEvent::Undefined) {
+      return Response::InvalidParams(
+          base::StringPrintf("Unexpected event type '%s'", type.c_str()));
+    }
   }
 
-  SetEventModifiers(event, modifiers.fromMaybe(0));
-  SetEventTimestamp(event, Maybe<double>(timestamp));
-  if (!SetMouseEventButton(event, button))
+  blink::WebPointerProperties::Button event_button =
+      blink::WebPointerProperties::Button::NoButton;
+  int button_modifiers = 0;
+  if (!GetMouseEventButton(button, &event_button, &button_modifiers))
     return Response::InvalidParams("Invalid mouse button");
 
-  event->x = x;
-  event->y = y;
-  event->windowX = x;
-  event->windowY = y;
-  event->globalX = x;
-  event->globalY = y;
-  event->clickCount = click_count.fromMaybe(0);
-  event->pointerType = blink::WebPointerProperties::PointerType::Touch;
+  ui::ScopedWebInputEvent event;
+  blink::WebMouseWheelEvent* wheel_event = nullptr;
+  blink::WebMouseEvent* mouse_event = nullptr;
+  if (type == Input::EmulateTouchFromMouseEvent::TypeEnum::MouseWheel) {
+    wheel_event = new blink::WebMouseWheelEvent(
+        event_type, GetEventModifiers(
+                        modifiers.fromMaybe(blink::WebInputEvent::NoModifiers),
+                        false, false) |
+                        button_modifiers,
+        GetEventTimestamp(timestamp));
+    mouse_event = wheel_event;
+    event.reset(wheel_event);
+    wheel_event->deltaX = static_cast<float>(delta_x.fromJust());
+    wheel_event->deltaY = static_cast<float>(delta_y.fromJust());
+  } else {
+    mouse_event = new blink::WebMouseEvent(
+        event_type, GetEventModifiers(
+                        modifiers.fromMaybe(blink::WebInputEvent::NoModifiers),
+                        false, false) |
+                        button_modifiers,
+        GetEventTimestamp(timestamp));
+    event.reset(mouse_event);
+  }
+
+  mouse_event->x = x;
+  mouse_event->y = y;
+  mouse_event->button = event_button;
+  mouse_event->windowX = x;
+  mouse_event->windowY = y;
+  mouse_event->globalX = x;
+  mouse_event->globalY = y;
+  mouse_event->clickCount = click_count.fromMaybe(0);
+  mouse_event->pointerType = blink::WebPointerProperties::PointerType::Touch;
 
   if (!host_ || !host_->GetRenderWidgetHost())
     return Response::InternalError();
 
-  if (event->type == blink::WebInputEvent::MouseWheel)
-    host_->GetRenderWidgetHost()->ForwardWheelEvent(wheel_event);
+  if (wheel_event)
+    host_->GetRenderWidgetHost()->ForwardWheelEvent(*wheel_event);
   else
-    host_->GetRenderWidgetHost()->ForwardMouseEvent(mouse_event);
+    host_->GetRenderWidgetHost()->ForwardMouseEvent(*mouse_event);
   return Response::OK();
 }
 
 void InputHandler::SynthesizePinchGesture(
     int x,
     int y,
     double scale_factor,
     Maybe<int> relative_speed,
     Maybe<std::string> gesture_source_type,
     std::unique_ptr<SynthesizePinchGestureCallback> callback) {
@@ skipping 163 matching lines @@
   for (int i = 0; i < count; i++) {
     host_->GetRenderWidgetHost()->QueueSyntheticGesture(
         SyntheticGesture::Create(gesture_params),
         base::Bind(&TapGestureResponse::OnGestureResult,
                    base::Unretained(response)));
   }
 }
 
 }  // namespace protocol
 }  // namespace content