Clean up GestureEventDetails constructors

ui/events/gesture_detection/gesture_provider.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 "ui/events/gesture_detection/gesture_provider.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 228 matching lines @@
       // diminish as the touch moves away from the original double-tap focus.
       // For historical reasons, Chrome has instead adopted a scale factor
       // computation that is invariant to the focal distance, where
       // the scale delta remains constant if the touch velocity is constant.
       float dy =
           (detector.GetCurrentSpanY() - detector.GetPreviousSpanY()) * 0.5f;
       scale = std::pow(scale > 1 ? 1.0f + kDoubleTapDragZoomSpeed
                                  : 1.0f - kDoubleTapDragZoomSpeed,
                        std::abs(dy));
     }
-    GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
+    GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE);
+    pinch_details.set_scale(scale);
     Send(CreateGesture(pinch_details,
                        e.GetId(),
                        e.GetToolType(),
                        detector.GetEventTime(),
                        detector.GetFocusX(),
                        detector.GetFocusY(),
                        detector.GetFocusX() + e.GetRawOffsetX(),
                        detector.GetFocusY() + e.GetRawOffsetY(),
                        e.GetPointerCount(),
                        GetBoundingBox(e, pinch_details.type()),
                        e.GetFlags()));
     return true;
   }
 
   // GestureDetector::GestureListener implementation.
   virtual bool OnDown(const MotionEvent& e) OVERRIDE {
-    GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN, 0, 0);
+    GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN);
     Send(CreateGesture(tap_details, e));
 
     // Return true to indicate that we want to handle touch.
     return true;
   }
 
   virtual bool OnScroll(const MotionEvent& e1,
                         const MotionEvent& e2,
                         float raw_distance_x,
                         float raw_distance_y) OVERRIDE {
@@ skipping 119 matching lines @@
                        e1.GetY(),
                        e1.GetRawX(),
                        e1.GetRawY(),
                        e2.GetPointerCount(),
                        GetBoundingBox(e2, two_finger_tap_details.type()),
                        e2.GetFlags()));
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
-    GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
+    GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS);
     show_press_event_sent_ = true;
     Send(CreateGesture(show_press_details, e));
   }
 
   virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
     // This is a hack to address the issue where user hovers
     // over a link for longer than double_tap_timeout_, then
     // OnSingleTapConfirmed() is not triggered. But we still
     // want to trigger the tap event at UP. So we override
     // OnSingleTapUp() in this case. This assumes singleTapUp
     // gets always called before singleTapConfirmed.
     if (!ignore_single_tap_) {
       if (e.GetEventTime() - current_down_time_ >
           config_.gesture_detector_config.double_tap_timeout) {
         return OnSingleTapConfirmed(e);
       } else if (!IsDoubleTapEnabled() || config_.disable_click_delay) {
         // If double-tap has been disabled, there is no need to wait
         // for the double-tap timeout.
         return OnSingleTapConfirmed(e);
       } else {
         // Notify Blink about this tapUp event anyway, when none of the above
         // conditions applied.
         Send(CreateTapGesture(ET_GESTURE_TAP_UNCONFIRMED, e));
       }
     }
 
     if (e.GetAction() == MotionEvent::ACTION_UP &&
         !current_longpress_time_.is_null() &&
         !IsScaleGestureDetectionInProgress()) {
-      GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP, 0, 0);
+      GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP);
       Send(CreateGesture(long_tap_details, e));
       return true;
     }
 
     return false;
   }
 
   // GestureDetector::DoubleTapListener implementation.
   virtual bool OnSingleTapConfirmed(const MotionEvent& e) OVERRIDE {
     // Long taps in the edges of the screen have their events delayed by
@@ skipping 28 matching lines @@
 
       default:
         break;
     }
     return false;
   }
 
   virtual void OnLongPress(const MotionEvent& e) OVERRIDE {
     DCHECK(!IsDoubleTapInProgress());
     SetIgnoreSingleTap(true);
-    GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS, 0, 0);
+    GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS);
     Send(CreateGesture(long_press_details, e));
   }
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
                                  int motion_event_id,
                                  MotionEvent::ToolType primary_tool_type,
                                  base::TimeTicks time,
                                  float x,
                                  float y,
                                  float raw_x,
@@ skipping 18 matching lines @@
                                  int motion_event_id,
                                  MotionEvent::ToolType primary_tool_type,
                                  base::TimeTicks time,
                                  float x,
                                  float y,
                                  float raw_x,
                                  float raw_y,
                                  size_t touch_point_count,
                                  const gfx::RectF& bounding_box,
                                  int flags) {
-    return GestureEventData(GestureEventDetails(type, 0, 0),
+    return GestureEventData(GestureEventDetails(type),
                             motion_event_id,
                             primary_tool_type,
                             time,
                             x,
                             y,
                             raw_x,
                             raw_y,
                             touch_point_count,
                             bounding_box,
                             flags);
   }
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
                                  const MotionEvent& event) {
     return GestureEventData(details,
                             event.GetId(),
                             event.GetToolType(),
                             event.GetEventTime(),
                             event.GetX(),
                             event.GetY(),
                             event.GetRawX(),
                             event.GetRawY(),
                             event.GetPointerCount(),
                             GetBoundingBox(event, details.type()),
                             event.GetFlags());
   }
 
   GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
-    return CreateGesture(GestureEventDetails(type, 0, 0), event);
+    return CreateGesture(GestureEventDetails(type), event);
   }
 
   GestureEventData CreateTapGesture(EventType type, const MotionEvent& event) {
     // Set the tap count to 1 even for ET_GESTURE_DOUBLE_TAP, in order to be
     // consistent with double tap behavior on a mobile viewport. See
     // crbug.com/234986 for context.
-    return CreateGesture(GestureEventDetails(type, 1, 0), event);
+    GestureEventDetails details(type);
+    details.set_tap_count(1);
+    return CreateGesture(details, event);
   }
 
   gfx::RectF GetBoundingBox(const MotionEvent& event, EventType type) {
     // Can't use gfx::RectF::Union, as it ignores touches with a radius of 0.
     float left = std::numeric_limits<float>::max();
     float top = std::numeric_limits<float>::max();
     float right = -std::numeric_limits<float>::max();
     float bottom = -std::numeric_limits<float>::max();
     for (size_t i = 0; i < event.GetPointerCount(); ++i) {
       float x, y, diameter;
@@ skipping 238 matching lines @@
   // null'ing of the listener until the sequence has ended.
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled =
       double_tap_support_for_page_ && double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui