Make SyntheticPointerAction to flush the pointer action sequence

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 <tuple>
@@ skipping 1166 matching lines @@
   NativeWebKeyboardEventWithLatencyInfo key_event_with_latency(key_event,
                                                                latency_info);
   key_event_with_latency.event.isBrowserShortcut = is_shortcut;
   DispatchInputEventWithLatencyInfo(key_event, &key_event_with_latency.latency);
   input_router_->SendKeyboardEvent(key_event_with_latency);
 }
 
 void RenderWidgetHostImpl::QueueSyntheticGesture(
     std::unique_ptr<SyntheticGesture> synthetic_gesture,
     const base::Callback<void(SyntheticGesture::Result)>& on_complete) {
-  if (!synthetic_gesture_controller_ && view_) {
-    synthetic_gesture_controller_.reset(
-        new SyntheticGestureController(view_->CreateSyntheticGestureTarget()));
+  if (!synthetic_gesture_controller_) {
+    if(!CreateSyntheticGestureController())
+      return;

[tdresser, 2016/10/31 14:22:58]

Should this ever happen? Should there be a CHECK or DCHECK?

[lanwei, 2016/12/04 18:08:02]

Done.

   }
-  if (synthetic_gesture_controller_) {
-    synthetic_gesture_controller_->QueueSyntheticGesture(
+
+  synthetic_gesture_controller_->QueueSyntheticGesture(
         std::move(synthetic_gesture), on_complete);
-  }
 }
 
 void RenderWidgetHostImpl::SetCursor(const WebCursor& cursor) {
   if (!view_)
     return;
   view_->UpdateCursor(cursor);
 }
 
 void RenderWidgetHostImpl::ShowContextMenuAtPoint(const gfx::Point& point) {
   Send(new ViewMsg_ShowContextMenu(
@@ skipping 534 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 (!synthetic_gesture_controller_) {
+    if(!CreateSyntheticGestureController())
+      return;

[tdresser, 2016/10/31 14:22:58]

Should this ever happen?

[lanwei, 2016/12/04 18:08:02]

Done.

+  }
+  std::unique_ptr<SyntheticGesture> synthetic_gesture;
+  const SyntheticGestureParams* gesture_params =
+      gesture_packet.gesture_params();
+  if (gesture_params->GetGestureType() ==
+      SyntheticGestureParams::POINTER_ACTION_LIST) {
+    synthetic_gesture =
+        synthetic_gesture_controller_->CreateSyntheticPointerAction(
+            *SyntheticPointerActionListParams::Cast(gesture_params));
+  } else {
+    synthetic_gesture = SyntheticGesture::Create(*gesture_params);
+  }
+
   QueueSyntheticGesture(
-        SyntheticGesture::Create(*gesture_packet.gesture_params()),
-        base::Bind(&RenderWidgetHostImpl::OnSyntheticGestureCompleted,
-                   weak_factory_.GetWeakPtr()));
+      std::move(synthetic_gesture),
+      base::Bind(&RenderWidgetHostImpl::OnSyntheticGestureCompleted,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetHostImpl::OnSetCursor(const WebCursor& cursor) {
   SetCursor(cursor);
 }
 
 void RenderWidgetHostImpl::SetTouchEventEmulationEnabled(
     bool enabled, ui::GestureProviderConfigType config_type) {
   if (enabled) {
     if (!touch_emulator_) {
@@ skipping 422 matching lines @@
 
 void RenderWidgetHostImpl::OnSnapshotDataReceivedAsync(
     int snapshot_id,
     scoped_refptr<base::RefCountedBytes> png_data) {
   if (png_data.get())
     OnSnapshotDataReceived(snapshot_id, png_data->front(), png_data->size());
   else
     OnSnapshotDataReceived(snapshot_id, NULL, 0);
 }
 
+bool RenderWidgetHostImpl::CreateSyntheticGestureController() {
+  DCHECK(!synthetic_gesture_controller_);
+
+  if (!view_)
+    return false;
+
+  synthetic_gesture_controller_.reset(
+      new SyntheticGestureController(view_->CreateSyntheticGestureTarget()));
+  return true;
+}
+
 // static
 void RenderWidgetHostImpl::CompositorFrameDrawn(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++) {
     std::set<RenderWidgetHostImpl*> rwhi_set;
     for (const auto& lc : latency_info[i].latency_components()) {
       if (lc.first.first == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
           lc.first.first == ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT ||
           lc.first.first == ui::TAB_SHOW_COMPONENT) {
         // Matches with GetLatencyComponentId
@@ skipping 17 matching lines @@
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
   return delegate_ ?
       delegate_->GetOrCreateRootBrowserAccessibilityManager() : NULL;
 }
 
 }  // namespace content