Remove TouchEvent interface, and rename TouchEventImpl to TouchEvent

ui/base/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/base/gestures/gesture_recognizer_impl.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
+#include "ui/base/event.h"
 #include "ui/base/events.h"
 #include "ui/base/gestures/gesture_configuration.h"
 #include "ui/base/gestures/gesture_sequence.h"
 #include "ui/base/gestures/gesture_types.h"
 
 namespace ui {
 
 namespace {
 
 // This is used to pop a std::queue when returning from a function.
 class ScopedPop {
  public:
   explicit ScopedPop(std::queue<TouchEvent*>* queue) : queue_(queue) {
   }
 
   ~ScopedPop() {
     delete queue_->front();
     queue_->pop();
   }
 
  private:
   std::queue<TouchEvent*>* queue_;
   DISALLOW_COPY_AND_ASSIGN(ScopedPop);
 };
 
 // CancelledTouchEvent mirrors a TouchEvent object.
 class MirroredTouchEvent : public TouchEvent {
  public:
   explicit MirroredTouchEvent(const TouchEvent* real)
-      : type_(real->GetEventType()),
-        location_(real->GetLocation()),
-        touch_id_(real->GetTouchId()),
-        flags_(real->GetEventFlags()),
-        timestamp_(real->GetTimestamp()),
-        radius_x_(real->RadiusX()),
-        radius_y_(real->RadiusY()),
-        rotation_angle_(real->RotationAngle()),
-        force_(real->Force()) {
+      : TouchEvent(real->type(),
+                       real->location(),
+                       real->touch_id(),
+                       real->time_stamp()) {
+    set_flags(real->flags());
+    set_radius(real->radius_x(), real->radius_y());
+    set_rotation_angle(real->rotation_angle());
+    set_force(real->force());
   }
 
   virtual ~MirroredTouchEvent() {
   }
 
-  // Overridden from TouchEvent.
-  virtual EventType GetEventType() const OVERRIDE {
-    return type_;
-  }
-
-  virtual gfx::Point GetLocation() const OVERRIDE {
-    return location_;
-  }
-
-  virtual int GetTouchId() const OVERRIDE {
-    return touch_id_;
-  }
-
-  virtual int GetEventFlags() const OVERRIDE {
-    return flags_;
-  }
-
-  virtual base::TimeDelta GetTimestamp() const OVERRIDE {
-    return timestamp_;
-  }
-
-  virtual float RadiusX() const OVERRIDE {
-    return radius_x_;
-  }
-
-  virtual float RadiusY() const OVERRIDE {
-    return radius_y_;
-  }
-
-  virtual float RotationAngle() const OVERRIDE {
-    return rotation_angle_;
-  }
-
-  virtual float Force() const OVERRIDE {
-    return force_;
-  }
-
- protected:
-  void set_type(const EventType type) { type_ = type; }
-
  private:
-  EventType type_;
-  gfx::Point location_;
-  int touch_id_;
-  int flags_;
-  base::TimeDelta timestamp_;
-  float radius_x_;
-  float radius_y_;
-  float rotation_angle_;
-  float force_;
 
   DISALLOW_COPY_AND_ASSIGN(MirroredTouchEvent);
 };
 
 // A mirrored event, except for the type, which is always ET_TOUCH_CANCELLED.
 class CancelledTouchEvent : public MirroredTouchEvent {
  public:
   explicit CancelledTouchEvent(const TouchEvent* src)
       : MirroredTouchEvent(src) {
     set_type(ET_TOUCH_CANCELLED);
@@ skipping 58 matching lines @@
 
 GestureRecognizerImpl::~GestureRecognizerImpl() {
   STLDeleteValues(&consumer_sequence_);
   STLDeleteValues(&event_queue_);
 }
 
 // Checks if this finger is already down, if so, returns the current target.
 // Otherwise, returns NULL.
 GestureConsumer* GestureRecognizerImpl::GetTouchLockedTarget(
     TouchEvent* event) {
-  return touch_id_target_[event->GetTouchId()];
+  return touch_id_target_[event->touch_id()];
 }
 
 GestureConsumer* GestureRecognizerImpl::GetTargetForGestureEvent(
     GestureEvent* event) {
   GestureConsumer* target = NULL;
   int touch_id = event->GetLowestTouchId();
   target = touch_id_target_for_gestures_[touch_id];
   return target;
 }
 
@@ skipping 83 matching lines @@
     gesture_sequence = CreateSequence(helper_);
     consumer_sequence_[consumer] = gesture_sequence;
   }
   return gesture_sequence;
 }
 
 GestureSequence::Gestures* GestureRecognizerImpl::ProcessTouchEventForGesture(
     const TouchEvent& event,
     ui::TouchStatus status,
     GestureConsumer* target) {
-  if (event.GetEventType() == ui::ET_TOUCH_RELEASED ||
-      event.GetEventType() == ui::ET_TOUCH_CANCELLED) {
-    touch_id_target_[event.GetTouchId()] = NULL;
+  if (event.type() == ui::ET_TOUCH_RELEASED ||
+      event.type() == ui::ET_TOUCH_CANCELLED) {
+    touch_id_target_[event.touch_id()] = NULL;
   } else {
-    touch_id_target_[event.GetTouchId()] = target;
+    touch_id_target_[event.touch_id()] = target;
     if (target)
-      touch_id_target_for_gestures_[event.GetTouchId()] = target;
+      touch_id_target_for_gestures_[event.touch_id()] = target;
   }
 
   GestureSequence* gesture_sequence = GetGestureSequenceForConsumer(target);
   return gesture_sequence->ProcessTouchEventForGesture(event, status);
 }
 
 void GestureRecognizerImpl::QueueTouchEventForGesture(GestureConsumer* consumer,
                                                       const TouchEvent& event) {
   if (!event_queue_[consumer])
     event_queue_[consumer] = new std::queue<TouchEvent*>();
   event_queue_[consumer]->push(new MirroredTouchEvent(&event));
 }
 
 GestureSequence::Gestures* GestureRecognizerImpl::AdvanceTouchQueue(
     GestureConsumer* consumer,
     bool processed) {
   if (!event_queue_[consumer] || event_queue_[consumer]->empty()) {
     LOG(ERROR) << "Trying to advance an empty gesture queue for " << consumer;
     return NULL;
   }
 
   ScopedPop pop(event_queue_[consumer]);
   TouchEvent* event = event_queue_[consumer]->front();
 
   GestureSequence* sequence = GetGestureSequenceForConsumer(consumer);
 
-  if (processed && event->GetEventType() == ui::ET_TOUCH_RELEASED) {
+  if (processed && event->type() == ui::ET_TOUCH_RELEASED) {
     // A touch release was was processed (e.g. preventDefault()ed by a
     // web-page), but we still need to process a touch cancel.
     CancelledTouchEvent cancelled(event);
     return sequence->ProcessTouchEventForGesture(cancelled,
                                                  ui::TOUCH_STATUS_UNKNOWN);
   }
 
   return sequence->ProcessTouchEventForGesture(
       *event,
       processed ? ui::TOUCH_STATUS_CONTINUE : ui::TOUCH_STATUS_UNKNOWN);
@@ skipping 13 matching lines @@
   RemoveConsumerFromMap(consumer, &touch_id_target_);
   RemoveConsumerFromMap(consumer, &touch_id_target_for_gestures_);
 }
 
 // GestureRecognizer, static
 GestureRecognizer* GestureRecognizer::Create(GestureEventHelper* helper) {
   return new GestureRecognizerImpl(helper);
 }
 
 }  // namespace ui