Add modifier flags to MotionEvent

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 203 matching lines @@
     if (!pinch_event_sent_) {
       Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
                          e.GetId(),
                          e.GetToolType(),
                          detector.GetEventTime(),
                          detector.GetFocusX(),
                          detector.GetFocusY(),
                          detector.GetFocusX() + e.GetRawOffsetX(),
                          detector.GetFocusY() + e.GetRawOffsetY(),
                          e.GetPointerCount(),
-                         GetBoundingBox(e, ET_GESTURE_PINCH_BEGIN)));
+                         GetBoundingBox(e, ET_GESTURE_PINCH_BEGIN),
+                         e.GetFlags()));
     }
 
     if (std::abs(detector.GetCurrentSpan() - detector.GetPreviousSpan()) <
         config_.scale_gesture_detector_config.min_pinch_update_span_delta) {
       return false;
     }
 
     float scale = detector.GetScaleFactor();
     if (scale == 1)
       return true;
@@ skipping 13 matching lines @@
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
     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())));
+                       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);
     Send(CreateGesture(tap_details, e));
 
     // Return true to indicate that we want to handle touch.
     return true;
@@ skipping 29 matching lines @@
       // used to determine which layer the scroll should affect.
       Send(CreateGesture(scroll_details,
                          e2.GetId(),
                          e2.GetToolType(),
                          e2.GetEventTime(),
                          e1.GetX(),
                          e1.GetY(),
                          e1.GetRawX(),
                          e1.GetRawY(),
                          e2.GetPointerCount(),
-                         GetBoundingBox(e2, scroll_details.type())));
+                         GetBoundingBox(e2, scroll_details.type()),
+                         e2.GetFlags()));
       DCHECK(scroll_event_sent_);
     }
 
     snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal())
         distance_y = 0;
       else
         distance_x = 0;
     }
 
     if (distance_x || distance_y) {
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
       const gfx::RectF bounding_box = GetBoundingBox(e2, scroll_details.type());
       const gfx::PointF center = bounding_box.CenterPoint();
       const gfx::PointF raw_center =
           center + gfx::Vector2dF(e2.GetRawOffsetX(), e2.GetRawOffsetY());
       Send(CreateGesture(scroll_details,
                          e2.GetId(),
                          e2.GetToolType(),
                          e2.GetEventTime(),
                          center.x(),
                          center.y(),
                          raw_center.x(),
                          raw_center.y(),
                          e2.GetPointerCount(),
-                         bounding_box));
+                         bounding_box,
+                         e2.GetFlags()));
     }
 
     return true;
   }
 
   virtual bool OnFling(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
                        float velocity_y) OVERRIDE {
     if (snap_scroll_controller_.IsSnappingScrolls()) {
@@ skipping 39 matching lines @@
         ET_GESTURE_TWO_FINGER_TAP, e1.GetTouchMajor(), e1.GetTouchMajor());
     Send(CreateGesture(two_finger_tap_details,
                        e2.GetId(),
                        e2.GetToolType(),
                        e2.GetEventTime(),
                        e1.GetX(),
                        e1.GetY(),
                        e1.GetRawX(),
                        e1.GetRawY(),
                        e2.GetPointerCount(),
-                       GetBoundingBox(e2, two_finger_tap_details.type())));
+                       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);
     show_press_event_sent_ = true;
     Send(CreateGesture(show_press_details, e));
   }
 
   virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
@@ skipping 76 matching lines @@
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
                                  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) {
+                                 const gfx::RectF& bounding_box,
+                                 int flags) {
     return GestureEventData(details,
                             motion_event_id,
                             primary_tool_type,
                             time,
                             x,
                             y,
                             raw_x,
                             raw_y,
                             touch_point_count,
-                            bounding_box);
+                            bounding_box,
+                            flags);
   }
 
   GestureEventData CreateGesture(EventType type,
                                  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) {
+                                 const gfx::RectF& bounding_box,
+                                 int flags) {
     return GestureEventData(GestureEventDetails(type, 0, 0),
                             motion_event_id,
                             primary_tool_type,
                             time,
                             x,
                             y,
                             raw_x,
                             raw_y,
                             touch_point_count,
-                            bounding_box);
+                            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()));
+                            GetBoundingBox(event, details.type()),
+                            event.GetFlags());
   }
 
   GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
     return CreateGesture(GestureEventDetails(type, 0, 0), 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.
@@ skipping 199 matching lines @@
         gesture_listener_->Send(gesture_listener_->CreateGesture(
             ET_GESTURE_BEGIN,
             event.GetId(),
             event.GetToolType(),
             event.GetEventTime(),
             event.GetX(action_index),
             event.GetY(action_index),
             event.GetRawX(action_index),
             event.GetRawY(action_index),
             event.GetPointerCount(),
-            gesture_listener_->GetBoundingBox(event, ET_GESTURE_BEGIN)));
+            gesture_listener_->GetBoundingBox(event, ET_GESTURE_BEGIN),
+            event.GetFlags()));
       }
       break;
     case MotionEvent::ACTION_POINTER_UP:
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
@@ skipping 28 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