WindowManagerApp should recognize gestures

ui/events/gestures/gesture_recognizer_impl.cc

 // Copyright (c) 2012 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/gestures/gesture_recognizer_impl.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 40 matching lines @@
     GestureConsumer* old_consumer,
     GestureConsumer* new_consumer,
     GestureRecognizerImpl::TouchIdToConsumerMap* map) {
   for (GestureRecognizerImpl::TouchIdToConsumerMap::iterator i = map->begin();
        i != map->end(); ++i) {
     if (i->second == old_consumer)
       i->second = new_consumer;
   }
 }
 
-GestureProviderAura* CreateGestureProvider(GestureProviderAuraClient* client) {
-  return new GestureProviderAura(client);
+GestureProviderImpl* CreateGestureProvider(GestureProviderImplClient* client) {
+  return new GestureProviderImpl(client);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, public:
 
 GestureRecognizerImpl::GestureRecognizerImpl() {
 }
 
@@ skipping 18 matching lines @@
 
 GestureConsumer* GestureRecognizerImpl::GetTargetForLocation(
     const gfx::PointF& location, int source_device_id) {
   const float max_distance =
       GestureConfiguration::max_separation_for_gesture_touches_in_pixels();
 
   gfx::PointF closest_point;
   int closest_touch_id = 0;
   double closest_distance_squared = std::numeric_limits<double>::infinity();
 
-  std::map<GestureConsumer*, GestureProviderAura*>::iterator i;
+  std::map<GestureConsumer*, GestureProviderImpl*>::iterator i;
   for (i = consumer_gesture_provider_.begin();
        i != consumer_gesture_provider_.end();
        ++i) {
-    const MotionEventAura& pointer_state = i->second->pointer_state();
+    const MotionEventImpl& 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().
       double distance_squared = (point - location).LengthSquared();
       if (distance_squared < closest_distance_squared) {
         closest_point = point;
         closest_touch_id = pointer_state.GetPointerId(j);
@@ skipping 11 matching lines @@
                                              GestureConsumer* new_consumer) {
   // Send cancel to all those save |new_consumer| and |current_consumer|.
   // Don't send a cancel to |current_consumer|, unless |new_consumer| is NULL.
   // Dispatching a touch-cancel event can end up altering |touch_id_target_|
   // (e.g. when the target of the event is destroyed, causing it to be removed
   // from |touch_id_target_| in |CleanupStateForConsumer()|). So create a list
   // of the touch-ids that need to be cancelled, and dispatch the cancel events
   // for them at the end.
 
   std::vector<GestureConsumer*> consumers;
-  std::map<GestureConsumer*, GestureProviderAura*>::iterator i;
+  std::map<GestureConsumer*, GestureProviderImpl*>::iterator i;
   for (i = consumer_gesture_provider_.begin();
        i != consumer_gesture_provider_.end();
        ++i) {
     if (i->first && i->first != new_consumer &&
         (i->first != current_consumer || new_consumer == NULL)) {
       consumers.push_back(i->first);
     }
   }
   for (std::vector<GestureConsumer*>::iterator iter = consumers.begin();
        iter != consumers.end();
@@ skipping 19 matching lines @@
     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) {
   bool cancelled_touch = false;
   if (consumer_gesture_provider_.count(consumer) == 0)
     return false;
-  const MotionEventAura& pointer_state =
+  const MotionEventImpl& pointer_state =
       consumer_gesture_provider_[consumer]->pointer_state();
   if (pointer_state.GetPointerCount() == 0)
     return false;
   // Pointer_state is modified every time after DispatchCancelTouchEvent.
   scoped_ptr<MotionEvent> pointer_state_clone = pointer_state.Clone();
   for (size_t i = 0; i < pointer_state_clone->GetPointerCount(); ++i) {
     gfx::PointF point(pointer_state_clone->GetX(i),
                       pointer_state_clone->GetY(i));
     TouchEvent touch_event(ui::ET_TOUCH_CANCELLED,
                            point,
                            ui::EF_IS_SYNTHESIZED,
                            pointer_state_clone->GetPointerId(i),
                            ui::EventTimeForNow(),
                            0.0f,
                            0.0f,
                            0.0f,
                            0.0f);
     GestureEventHelper* helper = FindDispatchHelperForConsumer(consumer);
     if (helper)
       helper->DispatchCancelTouchEvent(&touch_event);
     cancelled_touch = true;
   }
   return cancelled_touch;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, private:
 
-GestureProviderAura* GestureRecognizerImpl::GetGestureProviderForConsumer(
+GestureProviderImpl* GestureRecognizerImpl::GetGestureProviderForConsumer(
     GestureConsumer* consumer) {
-  GestureProviderAura* gesture_provider = consumer_gesture_provider_[consumer];
+  GestureProviderImpl* gesture_provider = consumer_gesture_provider_[consumer];
   if (!gesture_provider) {
     gesture_provider = CreateGestureProvider(this);
     consumer_gesture_provider_[consumer] = gesture_provider;
   }
   return gesture_provider;
 }
 
 void GestureRecognizerImpl::SetupTargets(const TouchEvent& event,
                                          GestureConsumer* target) {
   if (event.type() == ui::ET_TOUCH_RELEASED ||
@@ skipping 16 matching lines @@
 }
 
 bool GestureRecognizerImpl::ProcessTouchEventPreDispatch(
     const TouchEvent& event,
     GestureConsumer* consumer) {
   SetupTargets(event, consumer);
 
   if (event.result() & ER_CONSUMED)
     return false;
 
-  GestureProviderAura* gesture_provider =
+  GestureProviderImpl* gesture_provider =
       GetGestureProviderForConsumer(consumer);
   return gesture_provider->OnTouchEvent(event);
 }
 
 GestureRecognizer::Gestures*
 GestureRecognizerImpl::ProcessTouchEventPostDispatch(
     const TouchEvent& event,
     ui::EventResult result,
     GestureConsumer* consumer) {
-  GestureProviderAura* gesture_provider =
+  GestureProviderImpl* 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 (result & ui::ER_CONSUMED)
     return NULL;
-  GestureProviderAura* gesture_provider =
+  GestureProviderImpl* 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 (consumer_gesture_provider_.count(consumer)) {
@@ skipping 61 matching lines @@
   std::vector<GestureEventHelper*>::iterator it;
   for (it = helpers.begin(); it != helpers.end(); ++it)
     gesture_recognizer->AddGestureEventHelper(*it);
 
   helpers.clear();
   g_gesture_recognizer_instance =
       static_cast<GestureRecognizerImpl*>(gesture_recognizer);
 }
 
 }  // namespace ui