Prepare SyntheticPointerAction to handle touch actions for multiple fingers

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 223 matching lines @@
           switches::kDisableHangMonitor)) {
     hang_monitor_timeout_.reset(new TimeoutMonitor(
         base::Bind(&RenderWidgetHostImpl::RendererIsUnresponsive,
                    weak_factory_.GetWeakPtr())));
   }
 
   new_content_rendering_timeout_.reset(new TimeoutMonitor(
       base::Bind(&RenderWidgetHostImpl::ClearDisplayedGraphics,
                  weak_factory_.GetWeakPtr())));
 
+  for (size_t i = 0; i < arraysize(index_map_); ++i)
+    index_map_[i] = -1;
+
   delegate_->RenderWidgetCreated(this);
 }
 
 RenderWidgetHostImpl::~RenderWidgetHostImpl() {
   if (!destroyed_)
     Destroy(false);
 }
 
 // static
 RenderWidgetHost* RenderWidgetHost::FromID(
@@ skipping 1439 matching lines @@
 void RenderWidgetHostImpl::OnQueueSyntheticGesture(
     const SyntheticGesturePacket& gesture_packet) {
   // Only allow untrustworthy gestures if explicitly enabled.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           cc::switches::kEnableGpuBenchmarking)) {
     bad_message::ReceivedBadMessage(GetProcess(),
                                     bad_message::RWH_SYNTHETIC_GESTURE);
     return;
   }
 
+  if (gesture_packet.gesture_params()->GetGestureType() ==
+      SyntheticGestureParams::POINTER_ACTION) {
+    QueueSyntheticPointerAction(
+        *SyntheticPointerActionParams::Cast(gesture_packet.gesture_params()));
+    return;
+  }
+
   QueueSyntheticGesture(
         SyntheticGesture::Create(*gesture_packet.gesture_params()),
         base::Bind(&RenderWidgetHostImpl::OnSyntheticGestureCompleted,
                    weak_factory_.GetWeakPtr()));
 }
 
+void RenderWidgetHostImpl::QueueSyntheticPointerAction(

[tdresser, 2016/04/18 15:24:39]

We'd prefer to have this logic encapsulated within the
SyntheticGestureController, if possible.

Does this need to live in RWHI?

[lanwei, 2016/04/19 19:05:32]

No, you are right, I will move this part related to queuing synthetic pointer
actions to SyntheticGestureController.

+    const SyntheticPointerActionParams& gesture_params) {
+  if (gesture_params.pointer_action_type() ==
+      SyntheticPointerActionParams::PointerActionType::PROCESS) {
+    if (!synthetic_gesture_controller_ && view_) {
+      synthetic_gesture_controller_.reset(new SyntheticGestureController(
+          view_->CreateSyntheticGestureTarget()));
+    }
+    if (synthetic_gesture_controller_) {
+      // Todo(lanwei@): Should check if type is pointer, make sure
+      // synthetic_pointer_ is not null.
+      DCHECK(gesture_params.pointer_action_type() !=
+             SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED);
+
+      if (!synthetic_pointer_)
+        SetSyntheticPointer(gesture_params);
+
+      QueueSyntheticGesture(
+          std::unique_ptr<SyntheticGesture>(new SyntheticPointerAction(
+              action_param_list_, synthetic_pointer_.get(), index_map_)),
+          base::Bind(&RenderWidgetHostImpl::OnSyntheticPointerActionCompleted,
+                     weak_factory_.GetWeakPtr()));
+    }
+    action_param_list_.clear();
+    return;
+  }
+
+  action_param_list_.push_back(gesture_params);
+}
+
+void RenderWidgetHostImpl::SetSyntheticPointer(
+    const SyntheticPointerActionParams& gesture_params) {
+  SyntheticGestureParams::GestureSourceType gesture_source_type =
+      gesture_params.gesture_source_type;
+  if (gesture_source_type == SyntheticGestureParams::DEFAULT_INPUT) {
+    if (synthetic_gesture_controller_) {
+      gesture_source_type =
+          synthetic_gesture_controller_->GetDefaultSyntheticGestureSourceType();
+      DCHECK_NE(gesture_source_type, SyntheticGestureParams::DEFAULT_INPUT);
+      synthetic_pointer_ = SyntheticPointer::Create(gesture_source_type);
+    }
+  }
+}
+
 void RenderWidgetHostImpl::OnSetCursor(const WebCursor& cursor) {
   SetCursor(cursor);
 }
 
 void RenderWidgetHostImpl::SetTouchEventEmulationEnabled(
     bool enabled, ui::GestureProviderConfigType config_type) {
   if (enabled) {
     if (!touch_emulator_) {
       touch_emulator_.reset(new TouchEmulator(
           this,
@@ skipping 236 matching lines @@
   if (type == BAD_ACK_MESSAGE) {
     bad_message::ReceivedBadMessage(process_, bad_message::RWH_BAD_ACK_MESSAGE);
   } else if (type == UNEXPECTED_EVENT_TYPE) {
     suppress_next_char_events_ = false;
   }
 }
 
 void RenderWidgetHostImpl::OnSyntheticGestureCompleted(
     SyntheticGesture::Result result) {
   Send(new InputMsg_SyntheticGestureCompleted(GetRoutingID()));
+  synthetic_pointer_.reset(nullptr);
+  ;
+}
+
+void RenderWidgetHostImpl::OnSyntheticPointerActionCompleted(
+    SyntheticGesture::Result result) {
+  // Do nothing
 }
 
 bool RenderWidgetHostImpl::ShouldDropInputEvents() const {
   return ignore_input_events_ || process_->IgnoreInputEvents() || !delegate_;
 }
 
 void RenderWidgetHostImpl::SetBackgroundOpaque(bool opaque) {
   Send(new ViewMsg_SetBackgroundOpaque(GetRoutingID(), opaque));
 }
 
@@ skipping 188 matching lines @@
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
   return delegate_ ?
       delegate_->GetOrCreateRootBrowserAccessibilityManager() : NULL;
 }
 
 }  // namespace content