Plumbs through android supplying multipe touch points

services/native_viewport/native_viewport_impl.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 "services/native_viewport/native_viewport_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
-#include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/public/cpp/application/interface_factory.h"
 #include "services/gles2/gpu_state.h"
 #include "services/native_viewport/platform_viewport_headless.h"
 #include "ui/events/event.h"
 
 namespace native_viewport {
-namespace {
-
-bool IsRateLimitedEventType(const mojo::EventPtr& event) {
-  return event->action == mojo::EVENT_TYPE_POINTER_MOVE;
-}
-
-}  // namespace
 
 NativeViewportImpl::NativeViewportImpl(
     bool is_headless,
     const scoped_refptr<gles2::GpuState>& gpu_state,
     mojo::InterfaceRequest<mojo::NativeViewport> request)
     : is_headless_(is_headless),
       context_provider_(gpu_state),
       sent_metrics_(false),
       metrics_(mojo::ViewportMetrics::New()),
-      waiting_for_event_ack_(false),
       binding_(this, request.Pass()),
       weak_factory_(this) {
   binding_.set_error_handler(this);
 }
 
 NativeViewportImpl::~NativeViewportImpl() {
   // Destroy the NativeViewport early on as it may call us back during
   // destruction and we want to be in a known state.
   platform_viewport_.reset();
 }
@@ skipping 68 matching lines @@
   create_callback_.Run(metrics_.Clone());
   sent_metrics_ = true;
   create_callback_.reset();
 }
 
 void NativeViewportImpl::OnAcceleratedWidgetDestroyed() {
   context_provider_.SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
 }
 
 bool NativeViewportImpl::OnEvent(mojo::EventPtr event) {
-  if (event.is_null() || !event_dispatcher_.get() ||
-      (waiting_for_event_ack_ && IsRateLimitedEventType(event))) {
+  if (event.is_null() || !event_dispatcher_.get())
     return false;
+
+  mojo::NativeViewportEventDispatcher::OnEventCallback callback;
+  switch (event->action) {
+    case mojo::EVENT_TYPE_POINTER_MOVE: {
+      // TODO(sky): add logic to remember last event location and not send if
+      // the same.
+      if (pointers_waiting_on_ack_.count(event->pointer_data->pointer_id))
+        return false;
+
+      pointers_waiting_on_ack_.insert(event->pointer_data->pointer_id);
+      scoped_ptr<PointerId> id_wrapper(new PointerId);
+      id_wrapper->id = event->pointer_data->pointer_id;
+      callback =
+          base::Bind(&NativeViewportImpl::AckEvent, weak_factory_.GetWeakPtr(),
+                     base::Owned(id_wrapper.release()));

[qsr, 2015/03/24 08:20:22]

Do you expect that this callback can be called multiple time? If not, could you
make AckEvent takes a scoped_ptr?

[sky, 2015/03/24 13:18:21]

Done.

+      break;
+    }
+
+    case mojo::EVENT_TYPE_POINTER_CANCEL:
+      pointers_waiting_on_ack_.clear();
+      break;
+
+    case mojo::EVENT_TYPE_POINTER_UP:
+      pointers_waiting_on_ack_.erase(event->pointer_data->pointer_id);
+      break;
+
+    default:
+      break;
   }
 
-  event_dispatcher_->OnEvent(
-      event.Pass(),
-      base::Bind(&NativeViewportImpl::AckEvent, weak_factory_.GetWeakPtr()));
-  waiting_for_event_ack_ = true;
+  event_dispatcher_->OnEvent(event.Pass(), callback);
   return false;
 }
 
 void NativeViewportImpl::OnDestroyed() {
   // This will signal a connection error and cause us to delete |this|.
   binding_.Close();
 }
 
 void NativeViewportImpl::OnConnectionError() {
   binding_.set_error_handler(nullptr);
   delete this;
 }
 
-void NativeViewportImpl::AckEvent() {
-  waiting_for_event_ack_ = false;
+void NativeViewportImpl::AckEvent(PointerId* id) {
+  pointers_waiting_on_ack_.erase(id->id);
 }
 
 }  // namespace native_viewport