Remove old Aura Gesture Detection Pipeline.

ui/events/gestures/gesture_recognizer_impl.cc

Index: ui/events/gestures/gesture_recognizer_impl.cc
diff --git a/ui/events/gestures/gesture_recognizer_impl.cc b/ui/events/gestures/gesture_recognizer_impl.cc
index 099d29f0112973af828b491cf255fe71110afd45..cfc3720d6c2483a31a110a6a5b9c403d4196d5d2 100644
--- a/ui/events/gestures/gesture_recognizer_impl.cc
+++ b/ui/events/gestures/gesture_recognizer_impl.cc
@@ -16,9 +16,7 @@
 #include "ui/events/event_switches.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gestures/gesture_configuration.h"
-#include "ui/events/gestures/gesture_sequence.h"
 #include "ui/events/gestures/gesture_types.h"
-#include "ui/events/gestures/unified_gesture_detector_enabled.h"
 
 namespace ui {
 
@@ -70,11 +68,9 @@ GestureProviderAura* CreateGestureProvider(GestureProviderAuraClient* client) {
 // GestureRecognizerImpl, public:
 
 GestureRecognizerImpl::GestureRecognizerImpl() {
-  use_unified_gesture_detector_ = IsUnifiedGestureDetectorEnabled();
 }
 
 GestureRecognizerImpl::~GestureRecognizerImpl() {
-  STLDeleteValues(&consumer_sequence_);
   STLDeleteValues(&consumer_gesture_provider_);
 }
 
@@ -98,62 +94,34 @@ GestureConsumer* GestureRecognizerImpl::GetTargetForLocation(
   const int max_distance =
       GestureConfiguration::max_separation_for_gesture_touches_in_pixels();
 
-  if (!use_unified_gesture_detector_) {
-    const GesturePoint* closest_point = NULL;
-    int64 closest_distance_squared = 0;
-    std::map<GestureConsumer*, GestureSequence*>::iterator i;
-    for (i = consumer_sequence_.begin(); i != consumer_sequence_.end(); ++i) {
-      const GesturePoint* points = i->second->points();
-      for (int j = 0; j < GestureSequence::kMaxGesturePoints; ++j) {
-        if (!points[j].in_use() ||
-            source_device_id != points[j].source_device_id()) {
-          continue;
-        }
-        gfx::Vector2dF delta = points[j].last_touch_position() - location;
-        // Relative distance is all we need here, so LengthSquared() is
-        // appropriate, and cheaper than Length().
-        int64 distance_squared = delta.LengthSquared();
-        if (!closest_point || distance_squared < closest_distance_squared) {
-          closest_point = &points[j];
-          closest_distance_squared = distance_squared;
-        }
+  gfx::PointF closest_point;
+  int closest_touch_id;
+  float closest_distance_squared = std::numeric_limits<float>::infinity();
+
+  std::map<GestureConsumer*, GestureProviderAura*>::iterator i;
+  for (i = consumer_gesture_provider_.begin();
+       i != consumer_gesture_provider_.end();
+       ++i) {
+    const MotionEventAura& pointer_state = i->second->pointer_state();
+    for (size_t j = 0; j < pointer_state.GetPointerCount(); ++j) {
+      if (source_device_id != pointer_state.GetSourceDeviceId(j))
+        continue;
+      gfx::PointF point(pointer_state.GetX(j), pointer_state.GetY(j));
+      // Relative distance is all we need here, so LengthSquared() is
+      // appropriate, and cheaper than Length().
+      float distance_squared = (point - location).LengthSquared();
+      if (distance_squared < closest_distance_squared) {
+        closest_point = point;
+        closest_touch_id = pointer_state.GetPointerId(j);
+        closest_distance_squared = distance_squared;
       }
     }
-
-    if (closest_distance_squared < max_distance * max_distance && closest_point)
-      return touch_id_target_[closest_point->touch_id()];
-    else
-      return NULL;
-  } else {
-    gfx::PointF closest_point;
-    int closest_touch_id;
-    float closest_distance_squared = std::numeric_limits<float>::infinity();
-
-    std::map<GestureConsumer*, GestureProviderAura*>::iterator i;
-    for (i = consumer_gesture_provider_.begin();
-         i != consumer_gesture_provider_.end();
-         ++i) {
-      const MotionEventAura& pointer_state = i->second->pointer_state();
-      for (size_t j = 0; j < pointer_state.GetPointerCount(); ++j) {
-        if (source_device_id != pointer_state.GetSourceDeviceId(j))
-          continue;
-        gfx::PointF point(pointer_state.GetX(j), pointer_state.GetY(j));
-        // Relative distance is all we need here, so LengthSquared() is
-        // appropriate, and cheaper than Length().
-        float distance_squared = (point - location).LengthSquared();
-        if (distance_squared < closest_distance_squared) {
-          closest_point = point;
-          closest_touch_id = pointer_state.GetPointerId(j);
-          closest_distance_squared = distance_squared;
-        }
-      }
-    }
-
-    if (closest_distance_squared < max_distance * max_distance)
-      return touch_id_target_[closest_touch_id];
-    else
-      return NULL;
   }
+
+  if (closest_distance_squared < max_distance * max_distance)
+    return touch_id_target_[closest_touch_id];
+  else
+    return NULL;

[sadrul, 2014/08/21 18:30:52]

Remove else. (or 'return <> ? <> : <>;')

[tdresser, 2014/08/21 20:27:35]

Done.

 }
 
 void GestureRecognizerImpl::TransferEventsTo(GestureConsumer* current_consumer,
@@ -183,30 +151,20 @@ void GestureRecognizerImpl::TransferEventsTo(GestureConsumer* current_consumer,
                                  &touch_id_target_);
     TransferTouchIdToConsumerMap(current_consumer, new_consumer,
                                  &touch_id_target_for_gestures_);
-    if (!use_unified_gesture_detector_)
-      TransferConsumer(current_consumer, new_consumer, &consumer_sequence_);
-    else
-      TransferConsumer(
-          current_consumer, new_consumer, &consumer_gesture_provider_);
+    TransferConsumer(
+        current_consumer, new_consumer, &consumer_gesture_provider_);
   }
 }
 
 bool GestureRecognizerImpl::GetLastTouchPointForTarget(
     GestureConsumer* consumer,
     gfx::PointF* point) {
-  if (!use_unified_gesture_detector_) {
-    if (consumer_sequence_.count(consumer) == 0)
-      return false;
-    *point = consumer_sequence_[consumer]->last_touch_location();
-    return true;
-  } else {
     if (consumer_gesture_provider_.count(consumer) == 0)
       return false;
     const MotionEvent& pointer_state =
         consumer_gesture_provider_[consumer]->pointer_state();
     *point = gfx::PointF(pointer_state.GetX(), pointer_state.GetY());
     return true;
-  }
 }
 
 bool GestureRecognizerImpl::CancelActiveTouches(GestureConsumer* consumer) {
@@ -222,26 +180,8 @@ bool GestureRecognizerImpl::CancelActiveTouches(GestureConsumer* consumer) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// GestureRecognizerImpl, protected:
-
-GestureSequence* GestureRecognizerImpl::CreateSequence(
-    GestureSequenceDelegate* delegate) {
-  return new GestureSequence(delegate);
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, private:
 
-GestureSequence* GestureRecognizerImpl::GetGestureSequenceForConsumer(
-    GestureConsumer* consumer) {
-  GestureSequence* gesture_sequence = consumer_sequence_[consumer];
-  if (!gesture_sequence) {
-    gesture_sequence = CreateSequence(this);
-    consumer_sequence_[consumer] = gesture_sequence;
-  }
-  return gesture_sequence;
-}
-
 GestureProviderAura* GestureRecognizerImpl::GetGestureProviderForConsumer(
     GestureConsumer* consumer) {
   GestureProviderAura* gesture_provider = consumer_gesture_provider_[consumer];
@@ -293,11 +233,6 @@ bool GestureRecognizerImpl::ProcessTouchEventPreDispatch(
     GestureConsumer* consumer) {
   SetupTargets(event, consumer);
 
-  // If we aren't using the unified GR, we definitely want to dispatch the
-  // event.
-  if (!ui::IsUnifiedGestureDetectorEnabled())
-    return true;
-
   if (event.result() & ER_CONSUMED)
     return false;
 
@@ -311,50 +246,32 @@ GestureRecognizerImpl::ProcessTouchEventPostDispatch(
     const TouchEvent& event,
     ui::EventResult result,
     GestureConsumer* consumer) {
-  if (ui::IsUnifiedGestureDetectorEnabled()) {
-    GestureProviderAura* gesture_provider =
-        GetGestureProviderForConsumer(consumer);
-    gesture_provider->OnTouchEventAck(result != ER_UNHANDLED);
-    return gesture_provider->GetAndResetPendingGestures();
-  } else {
-    GestureSequence* gesture_sequence = GetGestureSequenceForConsumer(consumer);
-    return gesture_sequence->ProcessTouchEventForGesture(event, result);
-  }
+  GestureProviderAura* gesture_provider =
+      GetGestureProviderForConsumer(consumer);
+  gesture_provider->OnTouchEventAck(result != ER_UNHANDLED);
+  return gesture_provider->GetAndResetPendingGestures();
 }
 
 GestureRecognizer::Gestures* GestureRecognizerImpl::ProcessTouchEventOnAsyncAck(
     const TouchEvent& event,
     ui::EventResult result,
     GestureConsumer* consumer) {
-  if (ui::IsUnifiedGestureDetectorEnabled()) {
-    if (result & ui::ER_CONSUMED)
-      return NULL;
-    GestureProviderAura* gesture_provider =
-        GetGestureProviderForConsumer(consumer);
-    gesture_provider->OnTouchEventAck(result != ER_UNHANDLED);
-    return gesture_provider->GetAndResetPendingGestures();
-  } else {
-    GestureSequence* gesture_sequence = GetGestureSequenceForConsumer(consumer);
-    return gesture_sequence->ProcessTouchEventForGesture(event, result);
-  }
+  if (result & ui::ER_CONSUMED)
+    return NULL;
+  GestureProviderAura* gesture_provider =
+      GetGestureProviderForConsumer(consumer);
+  gesture_provider->OnTouchEventAck(result != ER_UNHANDLED);
+  return gesture_provider->GetAndResetPendingGestures();
 }
 
 bool GestureRecognizerImpl::CleanupStateForConsumer(
     GestureConsumer* consumer) {
   bool state_cleaned_up = false;
 
-  if (!use_unified_gesture_detector_) {
-    if (consumer_sequence_.count(consumer)) {
-      state_cleaned_up = true;
-      delete consumer_sequence_[consumer];
-      consumer_sequence_.erase(consumer);
-    }
-  } else {
-    if (consumer_gesture_provider_.count(consumer)) {
-      state_cleaned_up = true;
-      delete consumer_gesture_provider_[consumer];
-      consumer_gesture_provider_.erase(consumer);
-    }
+  if (consumer_gesture_provider_.count(consumer)) {
+    state_cleaned_up = true;
+    delete consumer_gesture_provider_[consumer];
+    consumer_gesture_provider_.erase(consumer);
   }
 
   state_cleaned_up |= RemoveConsumerFromMap(consumer, &touch_id_target_);
@@ -375,10 +292,6 @@ void GestureRecognizerImpl::RemoveGestureEventHelper(
     helpers_.erase(it);
 }
 
-void GestureRecognizerImpl::DispatchPostponedGestureEvent(GestureEvent* event) {
-  DispatchGestureEvent(event);
-}
-
 void GestureRecognizerImpl::OnGestureEvent(GestureEvent* event) {
   DispatchGestureEvent(event);
 }