Framelet Prototype 2016

content/public/common/input/web_input_event_traits.cc

 // Copyright 2013 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/common/input/web_input_event_traits.h"
+#include "content/public/common/input/web_input_event_traits.h"
 
 #include <bitset>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 
 using base::StringAppendF;
 using base::SStringPrintf;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using std::numeric_limits;
 
 namespace content {
 namespace {
 
 const int kInvalidTouchIndex = -1;
 
 void ApppendEventDetails(const WebKeyboardEvent& event, std::string* result) {
   StringAppendF(result,
                 "{\n WinCode: %d\n NativeCode: %d\n IsSystem: %d\n"
                 " Text: %s\n UnmodifiedText: %s\n KeyIdentifier: %s\n}",
-                event.windowsKeyCode,
-                event.nativeKeyCode,
-                event.isSystemKey,
+                event.windowsKeyCode, event.nativeKeyCode, event.isSystemKey,
                 reinterpret_cast<const char*>(event.text),
                 reinterpret_cast<const char*>(event.unmodifiedText),
                 reinterpret_cast<const char*>(event.keyIdentifier));
 }
 
 void ApppendEventDetails(const WebMouseEvent& event, std::string* result) {
   StringAppendF(result,
                 "{\n Button: %d\n Pos: (%d, %d)\n WindowPos: (%d, %d)\n"
                 " GlobalPos: (%d, %d)\n Movement: (%d, %d)\n Clicks: %d\n}",
-                event.button,
-                event.x,
-                event.y,
-                event.windowX,
-                event.windowY,
-                event.globalX,
-                event.globalY,
-                event.movementX,
-                event.movementY,
+                event.button, event.x, event.y, event.windowX, event.windowY,
+                event.globalX, event.globalY, event.movementX, event.movementY,
                 event.clickCount);
 }
 
 void ApppendEventDetails(const WebMouseWheelEvent& event, std::string* result) {
-  StringAppendF(result,
-                "{\n Delta: (%f, %f)\n WheelTicks: (%f, %f)\n Accel: (%f, %f)\n"
-                " ScrollByPage: %d\n HasPreciseScrollingDeltas: %d\n"
-                " Phase: (%d, %d)\n CanRubberband: (%d, %d)\n CanScroll: %d\n}",
-                event.deltaX,
-                event.deltaY,
-                event.wheelTicksX,
-                event.wheelTicksY,
-                event.accelerationRatioX,
-                event.accelerationRatioY,
-                event.scrollByPage,
-                event.hasPreciseScrollingDeltas,
-                event.phase,
-                event.momentumPhase,
-                event.canRubberbandLeft,
-                event.canRubberbandRight,
-                event.canScroll);
+  StringAppendF(
+      result,
+      "{\n Delta: (%f, %f)\n WheelTicks: (%f, %f)\n Accel: (%f, %f)\n"
+      " ScrollByPage: %d\n HasPreciseScrollingDeltas: %d\n"
+      " Phase: (%d, %d)\n CanRubberband: (%d, %d)\n CanScroll: %d\n}",
+      event.deltaX, event.deltaY, event.wheelTicksX, event.wheelTicksY,
+      event.accelerationRatioX, event.accelerationRatioY, event.scrollByPage,
+      event.hasPreciseScrollingDeltas, event.phase, event.momentumPhase,
+      event.canRubberbandLeft, event.canRubberbandRight, event.canScroll);
 }
 
 void ApppendEventDetails(const WebGestureEvent& event, std::string* result) {
-  StringAppendF(result,
-                "{\n Pos: (%d, %d)\n GlobalPos: (%d, %d)\n SourceDevice: %d\n"
-                " RawData: (%f, %f, %f, %f, %d)\n}",
-                event.x,
-                event.y,
-                event.globalX,
-                event.globalY,
-                event.sourceDevice,
-                event.data.scrollUpdate.deltaX,
-                event.data.scrollUpdate.deltaY,
-                event.data.scrollUpdate.velocityX,
-                event.data.scrollUpdate.velocityY,
-                event.data.scrollUpdate.previousUpdateInSequencePrevented);
+  StringAppendF(
+      result,
+      "{\n Pos: (%d, %d)\n GlobalPos: (%d, %d)\n SourceDevice: %d\n"
+      " RawData: (%f, %f, %f, %f, %d)\n}",
+      event.x, event.y, event.globalX, event.globalY, event.sourceDevice,
+      event.data.scrollUpdate.deltaX, event.data.scrollUpdate.deltaY,
+      event.data.scrollUpdate.velocityX, event.data.scrollUpdate.velocityY,
+      event.data.scrollUpdate.previousUpdateInSequencePrevented);
 }
 
 void ApppendTouchPointDetails(const WebTouchPoint& point, std::string* result) {
   StringAppendF(result,
-                 "  (ID: %d, State: %d, ScreenPos: (%f, %f), Pos: (%f, %f),"
-                     " Radius: (%f, %f), Rot: %f, Force: %f,"
-                     " Tilt: (%d, %d)),\n",
-  point.id,
-  point.state,
-  point.screenPosition.x,
-  point.screenPosition.y,
-  point.position.x,
-  point.position.y,
-  point.radiusX,
-  point.radiusY,
-  point.rotationAngle,
-  point.force,
-  point.tiltX,
-  point.tiltY);
+                "  (ID: %d, State: %d, ScreenPos: (%f, %f), Pos: (%f, %f),"
+                " Radius: (%f, %f), Rot: %f, Force: %f,"
+                " Tilt: (%d, %d)),\n",
+                point.id, point.state, point.screenPosition.x,
+                point.screenPosition.y, point.position.x, point.position.y,
+                point.radiusX, point.radiusY, point.rotationAngle, point.force,
+                point.tiltX, point.tiltY);
 }
 
 void ApppendEventDetails(const WebTouchEvent& event, std::string* result) {
   StringAppendF(result,
                 "{\n Touches: %u, Cancelable: %d, CausesScrolling: %d,"
                 " uniqueTouchEventId: %u\n[\n",
                 event.touchesLength, event.cancelable,
                 event.causesScrollingIfUncanceled, event.uniqueTouchEventId);
   for (unsigned i = 0; i < event.touchesLength; ++i)
     ApppendTouchPointDetails(event.touches[i], result);
@@ skipping 44 matching lines @@
 float GetAccelerationRatio(float accelerated_delta, float unaccelerated_delta) {
   if (unaccelerated_delta == 0.f || accelerated_delta == 0.f)
     return 1.f;
   return unaccelerated_delta / accelerated_delta;
 }
 
 void Coalesce(const WebMouseWheelEvent& event_to_coalesce,
               WebMouseWheelEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
   float unaccelerated_x =
-      GetUnacceleratedDelta(event->deltaX,
-                            event->accelerationRatioX) +
+      GetUnacceleratedDelta(event->deltaX, event->accelerationRatioX) +
       GetUnacceleratedDelta(event_to_coalesce.deltaX,
                             event_to_coalesce.accelerationRatioX);
   float unaccelerated_y =
-      GetUnacceleratedDelta(event->deltaY,
-                            event->accelerationRatioY) +
+      GetUnacceleratedDelta(event->deltaY, event->accelerationRatioY) +
       GetUnacceleratedDelta(event_to_coalesce.deltaY,
                             event_to_coalesce.accelerationRatioY);
   event->deltaX += event_to_coalesce.deltaX;
   event->deltaY += event_to_coalesce.deltaY;
   event->wheelTicksX += event_to_coalesce.wheelTicksX;
   event->wheelTicksY += event_to_coalesce.wheelTicksY;
   event->accelerationRatioX =
       GetAccelerationRatio(event->deltaX, unaccelerated_x);
   event->accelerationRatioY =
       GetAccelerationRatio(event->deltaY, unaccelerated_y);
@@ skipping 58 matching lines @@
       event.sourceDevice != event_to_coalesce.sourceDevice ||
       event.modifiers != event_to_coalesce.modifiers)
     return false;
 
   if (event.type == WebInputEvent::GestureScrollUpdate)
     return true;
 
   // GesturePinchUpdate scales can be combined only if they share a focal point,
   // e.g., with double-tap drag zoom.
   if (event.type == WebInputEvent::GesturePinchUpdate &&
-      event.x == event_to_coalesce.x &&
-      event.y == event_to_coalesce.y)
+      event.x == event_to_coalesce.x && event.y == event_to_coalesce.y)
     return true;
 
   return false;
 }
 
 void Coalesce(const WebGestureEvent& event_to_coalesce,
               WebGestureEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
   if (event->type == WebInputEvent::GestureScrollUpdate) {
     event->data.scrollUpdate.deltaX +=
@@ skipping 12 matching lines @@
     else if (event->data.pinchUpdate.scale > numeric_limits<float>::max())
       event->data.pinchUpdate.scale = numeric_limits<float>::max();
   }
 }
 
 struct WebInputEventToString {
   template <class EventType>
   bool Execute(const WebInputEvent& event, std::string* result) const {
     SStringPrintf(result, "%s (Time: %lf, Modifiers: %d)\n",
                   WebInputEventTraits::GetName(event.type),
-                  event.timeStampSeconds,
-                  event.modifiers);
+                  event.timeStampSeconds, event.modifiers);
     const EventType& typed_event = static_cast<const EventType&>(event);
     ApppendEventDetails(typed_event, result);
     return true;
   }
 };
 
 struct WebInputEventSize {
   template <class EventType>
   bool Execute(WebInputEvent::Type /* type */, size_t* type_size) const {
     *type_size = sizeof(EventType);
@@ skipping 66 matching lines @@
   else if (WebInputEvent::isGestureEventType(type))
     return op.template Execute<WebGestureEvent>(arg_in, arg_out);
 
   NOTREACHED() << "Unknown webkit event type " << type;
   return false;
 }
 
 }  // namespace
 
 const char* WebInputEventTraits::GetName(WebInputEvent::Type type) {
-#define CASE_TYPE(t) case WebInputEvent::t:  return #t
-  switch(type) {
+#define CASE_TYPE(t)     \
+  case WebInputEvent::t: \
+    return #t
+  switch (type) {
     CASE_TYPE(Undefined);
     CASE_TYPE(MouseDown);
     CASE_TYPE(MouseUp);
     CASE_TYPE(MouseMove);
     CASE_TYPE(MouseEnter);
     CASE_TYPE(MouseLeave);
     CASE_TYPE(ContextMenu);
     CASE_TYPE(MouseWheel);
     CASE_TYPE(RawKeyDown);
     CASE_TYPE(KeyDown);
@@ skipping 16 matching lines @@
     CASE_TYPE(GesturePinchBegin);
     CASE_TYPE(GesturePinchEnd);
     CASE_TYPE(GesturePinchUpdate);
     CASE_TYPE(TouchStart);
     CASE_TYPE(TouchMove);
     CASE_TYPE(TouchEnd);
     CASE_TYPE(TouchCancel);
     default:
       // Must include default to let blink::WebInputEvent add new event types
       // before they're added here.
-      DLOG(WARNING) <<
-          "Unhandled WebInputEvent type in WebInputEventTraits::GetName.\n";
+      DLOG(WARNING)
+          << "Unhandled WebInputEvent type in WebInputEventTraits::GetName.\n";
       break;
   }
 #undef CASE_TYPE
   return "";
 }
 
 std::string WebInputEventTraits::ToString(const WebInputEvent& event) {
   std::string result;
   Apply(WebInputEventToString(), event.type, event, &result);
   return result;
@@ skipping 16 matching lines @@
     return;
   bool dummy_var = false;
   Apply(WebInputEventDelete(), event->type, event, &dummy_var);
 }
 
 bool WebInputEventTraits::CanCoalesce(const WebInputEvent& event_to_coalesce,
                                       const WebInputEvent& event) {
   // Early out before casting.
   if (event_to_coalesce.type != event.type)
     return false;
-  return Apply(WebInputEventCanCoalesce(),
-               event.type,
-               event_to_coalesce,
+  return Apply(WebInputEventCanCoalesce(), event.type, event_to_coalesce,
                &event);
 }
 
 void WebInputEventTraits::Coalesce(const WebInputEvent& event_to_coalesce,
                                    WebInputEvent* event) {
   DCHECK(event);
   Apply(WebInputEventCoalesce(), event->type, event_to_coalesce, event);
 }
 
 bool WebInputEventTraits::WillReceiveAckFromRenderer(
@@ skipping 24 matching lines @@
 
 uint32_t WebInputEventTraits::GetUniqueTouchEventId(
     const WebInputEvent& event) {
   if (WebInputEvent::isTouchEventType(event.type)) {
     return static_cast<const WebTouchEvent&>(event).uniqueTouchEventId;
   }
   return 0U;
 }
 
 }  // namespace content