[Tracking Patch] Unified gesture detection

content/browser/renderer_host/input/content_motion_event_impl.cc

Index: content/browser/renderer_host/input/content_motion_event_impl.cc
diff --git a/content/browser/renderer_host/input/content_motion_event_impl.cc b/content/browser/renderer_host/input/content_motion_event_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bf3cb81354aad9dc9c5b85f439dabb05fac9493d
--- /dev/null
+++ b/content/browser/renderer_host/input/content_motion_event_impl.cc
@@ -0,0 +1,156 @@
+// 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 "content/browser/renderer_host/input/content_motion_event_impl.h"
+
+#include "base/logging.h"
+
+using blink::WebInputEvent;
+using blink::WebPoint;
+using blink::WebTouchEvent;
+using blink::WebTouchPoint;
+
+namespace content {
+namespace {
+
+bool AllTouchPointsHaveState(const WebTouchEvent& event,
+                             WebTouchPoint::State state) {
+  for (size_t i = 0; i < event.touchesLength; ++i) {
+    if (event.touches[i].state != state)
+      return false;
+  }
+  return true;
+}
+
+ui::MotionEvent::Action GetActionFrom(const WebTouchEvent& event) {
+  switch (event.type) {
+    case WebInputEvent::TouchStart:
+      if (AllTouchPointsHaveState(event, WebTouchPoint::StatePressed))
+        return ui::MotionEvent::ACTION_DOWN;
+      else
+        return ui::MotionEvent::ACTION_POINTER_DOWN;
+    case WebInputEvent::TouchEnd:
+      if (AllTouchPointsHaveState(event, WebTouchPoint::StateReleased))
+        return ui::MotionEvent::ACTION_UP;
+      else
+        return ui::MotionEvent::ACTION_POINTER_UP;
+    case WebInputEvent::TouchCancel:
+      DCHECK(AllTouchPointsHaveState(event, WebTouchPoint::StateCancelled));
+      return ui::MotionEvent::ACTION_CANCEL;
+    case WebInputEvent::TouchMove:
+      return ui::MotionEvent::ACTION_MOVE;
+    default:
+      break;
+  };
+  NOTREACHED() << "Invalid masked TouchEvent action.";
+  return ui::MotionEvent::ACTION_CANCEL;
+}
+
+int GetActionIndexFrom(const WebTouchEvent& event) {
+  for (size_t i = 0; i < event.touchesLength; ++i) {
+    if (event.touches[i].state != WebTouchPoint::StateUndefined &&
+        event.touches[i].state != WebTouchPoint::StateStationary)
+      return i;
+  }
+  return -1;
+}
+
+}  // namespace
+
+ContentMotionEventImpl::ContentMotionEventImpl(const NativeWebTouchEvent& event)
+    : event_(event),
+      cached_action_(GetActionFrom(event)),
+      cached_action_index_(GetActionIndexFrom(event)) {
+  DCHECK_GT(GetPointerCount(), 0U);
+}
+
+ContentMotionEventImpl::~ContentMotionEventImpl() {}
+
+ContentMotionEventImpl::Action ContentMotionEventImpl::GetAction() const {
+  return cached_action_;
+}
+
+int ContentMotionEventImpl::GetActionIndex() const {
+  return cached_action_index_;
+}
+
+size_t ContentMotionEventImpl::GetPointerCount() const {
+  return event_.touchesLength;
+}
+
+int ContentMotionEventImpl::GetPointerId(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, GetPointerCount());
+  return event_.touches[pointer_index].id;
+}
+
+float ContentMotionEventImpl::GetX(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, GetPointerCount());
+  return event_.touches[pointer_index].position.x;
+}
+
+float ContentMotionEventImpl::GetY(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, GetPointerCount());
+  return event_.touches[pointer_index].position.y;
+}
+
+float ContentMotionEventImpl::GetTouchMajor(size_t pointer_index) const {
+  DCHECK_LT(pointer_index, GetPointerCount());
+  // TODO(jdduke): We should be a bit more careful about axes here.
+  return 2.f * std::max(event_.touches[pointer_index].radiusX,
+                        event_.touches[pointer_index].radiusY);
+}
+
+base::TimeTicks ContentMotionEventImpl::GetEventTime() const {
+  return base::TimeTicks() +
+         base::TimeDelta::FromMicroseconds(event_.timeStampSeconds *
+                                           base::Time::kMicrosecondsPerSecond);
+}
+
+size_t ContentMotionEventImpl::GetHistorySize() const {
+  return 0;
+}
+
+base::TimeTicks ContentMotionEventImpl::GetHistoricalEventTime(
+    size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return base::TimeTicks();
+}
+
+float ContentMotionEventImpl::GetHistoricalTouchMajor(
+    size_t pointer_index,
+    size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return 0.f;
+}
+
+float ContentMotionEventImpl::GetHistoricalX(size_t pointer_index,
+                                         size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return 0.f;
+}
+
+float ContentMotionEventImpl::GetHistoricalY(size_t pointer_index,
+                                         size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return 0.f;
+}
+
+scoped_ptr<ui::MotionEvent> ContentMotionEventImpl::Clone() const {
+  return scoped_ptr<MotionEvent>(new ContentMotionEventImpl(event_));
+}
+
+scoped_ptr<ui::MotionEvent> ContentMotionEventImpl::Cancel() const {
+  NativeWebTouchEvent cancel_event(event_);
+
+  cancel_event.type = WebInputEvent::TouchCancel;
+  for (size_t i = 0; i < cancel_event.touchesLength; ++i)
+    cancel_event.touches[i].state = WebTouchPoint::StateCancelled;
+
+  return scoped_ptr<MotionEvent>(new ContentMotionEventImpl(cancel_event));
+}
+
+// StackAllocatedContentMotionEventImpl
+
+
+}  // namespace content