Touch emulator: allow multiple touch streams.

content/browser/renderer_host/render_widget_host_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 "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 946 matching lines @@
           original_component.sequence_number,
           original_component.event_time,
           original_component.event_count);
     }
   }
 
   GestureEventWithLatencyInfo gesture_with_latency(gesture_event, latency_info);
   input_router_->SendGestureEvent(gesture_with_latency);
 }
 
-void RenderWidgetHostImpl::ForwardTouchEvent(
+void RenderWidgetHostImpl::ForwardEmulatedTouchEvent(
       const blink::WebTouchEvent& touch_event) {
-  ForwardTouchEventWithLatencyInfo(touch_event, ui::LatencyInfo());
+  ForwardTouchEventWithLatencyInfoFromStream(
+      touch_event, ui::LatencyInfo(), TouchStreamTracker::EMULATED_STREAM);
 }
 
 void RenderWidgetHostImpl::ForwardTouchEventWithLatencyInfo(
       const blink::WebTouchEvent& touch_event,
       const ui::LatencyInfo& ui_latency) {
+  ForwardTouchEventWithLatencyInfoFromStream(
+      touch_event, ui_latency, TouchStreamTracker::NATIVE_STREAM);
+}
+
+void RenderWidgetHostImpl::ForwardTouchEventWithLatencyInfoFromStream(
+    const blink::WebTouchEvent& touch_event,
+    const ui::LatencyInfo& ui_latency,
+    TouchStreamTracker::TouchStream stream) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardTouchEvent");
 
-  // Always forward TouchEvents for touch stream consistency. They will be
-  // ignored if appropriate in FilterInputEvent().
+  // Always forward TouchEvents from active touch stream for consistency.
+  // They will be ignored if appropriate in FilterInputEvent().
 
   ui::LatencyInfo latency_info =
       CreateRWHLatencyInfoIfNotExist(&ui_latency, touch_event.type);
   TouchEventWithLatencyInfo touch_with_latency(touch_event, latency_info);
+
+  if (touch_stream_tracker_) {
+    InputEventAckState ack_result =
+        touch_stream_tracker_->FilterTouchEventFromStream(touch_event, stream);
+    if (ack_result != INPUT_EVENT_ACK_STATE_UNKNOWN) {
+      OnTouchEventAckFromStream(touch_with_latency, ack_result, stream);
+      return;
+    }
+  }
+
   input_router_->SendTouchEvent(touch_with_latency);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (IgnoreInputEvents())
     return;
 
   if (!process_->HasConnection())
@@ skipping 629 matching lines @@
 void RenderWidgetHostImpl::OnSetCursor(const WebCursor& cursor) {
   SetCursor(cursor);
 }
 
 void RenderWidgetHostImpl::OnSetTouchEventEmulationEnabled(
     bool enabled, bool allow_pinch) {
   if (delegate_)
     delegate_->OnTouchEmulationEnabled(enabled);
 
   if (enabled) {
-    if (!touch_emulator_)
+    if (!touch_emulator_) {
+      touch_stream_tracker_.reset(new TouchStreamTracker());
       touch_emulator_.reset(new TouchEmulator(this));
+    }
     touch_emulator_->Enable(allow_pinch);
   } else {
     if (touch_emulator_)
       touch_emulator_->Disable();
   }
 }
 
 void RenderWidgetHostImpl::OnTextInputStateChanged(
     const ViewHostMsg_TextInputState_Params& params) {
   if (view_)
@@ skipping 240 matching lines @@
       ack_result = INPUT_EVENT_ACK_STATE_CONSUMED;
   }
 
   if (view_)
     view_->GestureEventAck(event.event, ack_result);
 }
 
 void RenderWidgetHostImpl::OnTouchEventAck(
     const TouchEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
+  TouchStreamTracker::TouchStream stream = TouchStreamTracker::NATIVE_STREAM;
+  if (touch_stream_tracker_)
+    stream = touch_stream_tracker_->OnTouchEventAck(event, ack_result);
+  OnTouchEventAckFromStream(event, ack_result, stream);
+}
+
+void RenderWidgetHostImpl::OnTouchEventAckFromStream(
+    const TouchEventWithLatencyInfo& event,
+    InputEventAckState ack_result,
+    TouchStreamTracker::TouchStream stream) {
   TouchEventWithLatencyInfo touch_event = event;
   touch_event.latency.AddLatencyNumber(
       ui::INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 0, 0);
   // TouchEvent latency ends at ack if it didn't cause any rendering.
   if (!touch_event.latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 0, NULL)) {
     touch_event.latency.AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT, 0, 0);
   }
   ComputeTouchLatency(touch_event.latency);
 
-  if (touch_emulator_ && touch_emulator_->HandleTouchEventAck(ack_result))
+  if (stream == TouchStreamTracker::EMULATED_STREAM) {
+    DCHECK(touch_emulator_);
+    touch_emulator_->HandleTouchEventAck(ack_result);
     return;
+  }
 
+  DCHECK(stream == TouchStreamTracker::NATIVE_STREAM);
   if (view_)
     view_->ProcessAckedTouchEvent(touch_event, ack_result);
 }
 
 void RenderWidgetHostImpl::OnUnexpectedEventAck(UnexpectedEventAckType type) {
   if (type == BAD_ACK_MESSAGE) {
     RecordAction(base::UserMetricsAction("BadMessageTerminate_RWH2"));
     process_->ReceivedBadMessage();
   } else if (type == UNEXPECTED_EVENT_TYPE) {
     suppress_next_char_events_ = false;
@@ skipping 469 matching lines @@
   }
 }
 
 SkColorType RenderWidgetHostImpl::PreferredReadbackFormat() {
   if (view_)
     return view_->PreferredReadbackFormat();
   return kN32_SkColorType;
 }
 
 }  // namespace content