Use a flag to send events asynchronously without waiting for response

In order to send multiple events in one frame, we want to use
"SendCommandAndIgnoreResponse" to dispatch events, but this approach
may break some tests which do not wait for the action finish in the
tests. We will use a flag which will only be called asynchronously in
testdriver Action API, which we use promise to wait for the action
finishing.

Bug: 999750, 606367
Change-Id: I05c850667c3b9aac95c0d4c7ea210360a48ffa2e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1783243Reviewed-by: John Chen <johnchen@chromium.org>
Commit-Queue: Lan Wei <lanwei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#693174}

chrome/test/chromedriver/chrome/stub_web_view.cc

@@ -117,19 +117,23 @@ Status StubWebView::GetFrameByFunction(const std::string& frame,
 }
 
 Status StubWebView::DispatchMouseEvents(const std::list<MouseEvent>& events,
-                                        const std::string& frame) {
+                                        const std::string& frame,
+                                        bool async_dispatch_events) {
   return Status(kOk);
 }
 
-Status StubWebView::DispatchTouchEvent(const TouchEvent& event) {
+Status StubWebView::DispatchTouchEvent(const TouchEvent& event,
+                                       bool async_dispatch_events) {
   return Status(kOk);
 }
 
-Status StubWebView::DispatchTouchEvents(const std::list<TouchEvent>& events) {
+Status StubWebView::DispatchTouchEvents(const std::list<TouchEvent>& events,
+                                        bool async_dispatch_events) {
   return Status(kOk);
 }
 
-Status StubWebView::DispatchKeyEvents(const std::list<KeyEvent>& events) {
+Status StubWebView::DispatchKeyEvents(const std::list<KeyEvent>& events,
+                                      bool async_dispatch_events) {
   return Status(kOk);
 }
 

chrome/test/chromedriver/chrome/stub_web_view.h

@@ -63,10 +63,14 @@ class StubWebView : public WebView {
                             const base::ListValue& args,
                             std::string* out_frame) override;
   Status DispatchMouseEvents(const std::list<MouseEvent>& events,
-                             const std::string& frame) override;
-  Status DispatchTouchEvent(const TouchEvent& event) override;
-  Status DispatchTouchEvents(const std::list<TouchEvent>& events) override;
-  Status DispatchKeyEvents(const std::list<KeyEvent>& events) override;
+                             const std::string& frame,
+                             bool async_dispatch_events = false) override;
+  Status DispatchTouchEvent(const TouchEvent& event,
+                            bool async_dispatch_events = false) override;
+  Status DispatchTouchEvents(const std::list<TouchEvent>& events,
+                             bool async_dispatch_events = false) override;
+  Status DispatchKeyEvents(const std::list<KeyEvent>& events,
+                           bool async_dispatch_events = false) override;
   Status GetCookies(std::unique_ptr<base::ListValue>* cookies,
                     const std::string& current_page_url) override;
   Status DeleteCookie(const std::string& name,

chrome/test/chromedriver/chrome/web_view.h

@@ -142,16 +142,20 @@ class WebView {
 
   // Dispatch a sequence of mouse events.
   virtual Status DispatchMouseEvents(const std::list<MouseEvent>& events,
-                                     const std::string& frame) = 0;
+                                     const std::string& frame,
+                                     bool async_dispatch_events) = 0;
 
   // Dispatch a single touch event.
-  virtual Status DispatchTouchEvent(const TouchEvent& event) = 0;
+  virtual Status DispatchTouchEvent(const TouchEvent& event,
+                                    bool async_dispatch_events) = 0;
 
   // Dispatch a sequence of touch events.
-  virtual Status DispatchTouchEvents(const std::list<TouchEvent>& events) = 0;
+  virtual Status DispatchTouchEvents(const std::list<TouchEvent>& events,
+                                     bool async_dispatch_events) = 0;
 
   // Dispatch a sequence of key events.
-  virtual Status DispatchKeyEvents(const std::list<KeyEvent>& events) = 0;
+  virtual Status DispatchKeyEvents(const std::list<KeyEvent>& events,
+                                   bool async_dispatch_events) = 0;
 
   // Return all the cookies visible to the current page.
   virtual Status GetCookies(std::unique_ptr<base::ListValue>* cookies,

chrome/test/chromedriver/chrome/web_view_impl.cc

@@ -518,10 +518,12 @@ Status WebViewImpl::DispatchTouchEventsForMouseEvents(
 }
 
 Status WebViewImpl::DispatchMouseEvents(const std::list<MouseEvent>& events,
-                                        const std::string& frame) {
+                                        const std::string& frame,
+                                        bool async_dispatch_events) {
   if (mobile_emulation_override_manager_->IsEmulatingTouch())
     return DispatchTouchEventsForMouseEvents(events, frame);
 
+  Status status(kOk);
   for (auto it = events.begin(); it != events.end(); ++it) {
     base::DictionaryValue params;
     params.SetString("type", GetAsString(it->type));
@@ -532,19 +534,27 @@ Status WebViewImpl::DispatchMouseEvents(const std::list<MouseEvent>& events,
     params.SetInteger("buttons", it->buttons);
     params.SetInteger("clickCount", it->click_count);
     params.SetString("pointerType", GetAsString(it->pointer_type));
-    Status status = client_->SendCommandAndIgnoreResponse(
-        "Input.dispatchMouseEvent", params);
+
+    if (async_dispatch_events) {
+      status = client_->SendCommandAndIgnoreResponse("Input.dispatchMouseEvent",
+                                                     params);
+    } else {
+      status = client_->SendCommand("Input.dispatchMouseEvent", params);
+    }
+
     if (status.IsError())
       return status;
   }
-  return Status(kOk);
+  return status;
 }
 
-Status WebViewImpl::DispatchTouchEvent(const TouchEvent& event) {
+Status WebViewImpl::DispatchTouchEvent(const TouchEvent& event,
+                                       bool async_dispatch_events) {
   base::DictionaryValue params;
   std::string type = GetAsString(event.type);
   params.SetString("type", type);
   std::unique_ptr<base::ListValue> point_list(new base::ListValue);
+  Status status(kOk);
   if (type == "touchStart" || type == "touchMove") {
     std::unique_ptr<base::DictionaryValue> point(new base::DictionaryValue());
     point->SetInteger("x", event.x);
@@ -557,20 +567,28 @@ Status WebViewImpl::DispatchTouchEvent(const TouchEvent& event) {
     point_list->Append(std::move(point));
   }
   params.Set("touchPoints", std::move(point_list));
-  return client_->SendCommandAndIgnoreResponse("Input.dispatchTouchEvent",
-                                               params);
+  if (async_dispatch_events) {
+    status = client_->SendCommandAndIgnoreResponse("Input.dispatchTouchEvent",
+                                                   params);
+  } else {
+    status = client_->SendCommand("Input.dispatchTouchEvent", params);
+  }
+  return status;
 }
 
-Status WebViewImpl::DispatchTouchEvents(const std::list<TouchEvent>& events) {
+Status WebViewImpl::DispatchTouchEvents(const std::list<TouchEvent>& events,
+                                        bool async_dispatch_events) {
   for (auto it = events.begin(); it != events.end(); ++it) {
-    Status status = DispatchTouchEvent(*it);
+    Status status = DispatchTouchEvent(*it, async_dispatch_events);
     if (status.IsError())
       return status;
   }
   return Status(kOk);
 }
 
-Status WebViewImpl::DispatchKeyEvents(const std::list<KeyEvent>& events) {
+Status WebViewImpl::DispatchKeyEvents(const std::list<KeyEvent>& events,
+                                      bool async_dispatch_events) {
+  Status status(kOk);
   for (auto it = events.begin(); it != events.end(); ++it) {
     base::DictionaryValue params;
     params.SetString("type", GetAsString(it->type));
@@ -606,12 +624,18 @@ Status WebViewImpl::DispatchKeyEvents(const std::list<KeyEvent>& events) {
       else
         params.SetInteger("location", it->location);
     }
-    Status status =
-        client_->SendCommandAndIgnoreResponse("Input.dispatchKeyEvent", params);
+
+    if (async_dispatch_events) {
+      status = client_->SendCommandAndIgnoreResponse("Input.dispatchKeyEvent",
+                                                     params);
+    } else {
+      status = client_->SendCommand("Input.dispatchKeyEvent", params);
+    }
+
     if (status.IsError())
       return status;
   }
-  return Status(kOk);
+  return status;
 }
 
 Status WebViewImpl::GetCookies(std::unique_ptr<base::ListValue>* cookies,

chrome/test/chromedriver/chrome/web_view_impl.h

@@ -103,10 +103,14 @@ class WebViewImpl : public WebView {
                             const base::ListValue& args,
                             std::string* out_frame) override;
   Status DispatchMouseEvents(const std::list<MouseEvent>& events,
-                             const std::string& frame) override;
-  Status DispatchTouchEvent(const TouchEvent& event) override;
-  Status DispatchTouchEvents(const std::list<TouchEvent>& events) override;
-  Status DispatchKeyEvents(const std::list<KeyEvent>& events) override;
+                             const std::string& frame,
+                             bool async_dispatch_events = false) override;
+  Status DispatchTouchEvent(const TouchEvent& event,
+                            bool async_dispatch_events = false) override;
+  Status DispatchTouchEvents(const std::list<TouchEvent>& events,
+                             bool async_dispatch_events = false) override;
+  Status DispatchKeyEvents(const std::list<KeyEvent>& events,
+                           bool async_dispatch_events = false) override;
   Status GetCookies(std::unique_ptr<base::ListValue>* cookies,
                     const std::string& current_page_url) override;
   Status DeleteCookie(const std::string& name,

chrome/test/chromedriver/element_commands.cc

@@ -201,8 +201,8 @@ Status ExecuteClickElement(Session* session,
     events.push_back(MouseEvent(kReleasedMouseEventType, kLeftMouseButton,
                                 location.x, location.y,
                                 session->sticky_modifiers, 1, 1));
-    status =
-        web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
+    status = web_view->DispatchMouseEvents(events, session->GetCurrentFrameId(),
+                                           false);
     if (status.IsOk())
       session->mouse_position = location;
     return status;
@@ -226,7 +226,7 @@ Status ExecuteTouchSingleTap(Session* session,
         TouchEvent(kTouchStart, location.x, location.y));
     events.push_back(
         TouchEvent(kTouchEnd, location.x, location.y));
-    return web_view->DispatchTouchEvents(events);
+    return web_view->DispatchTouchEvents(events, false);
   }
   return web_view->SynthesizeTapGesture(location.x, location.y, 1, false);
 }
@@ -287,7 +287,7 @@ Status ExecuteFlick(Session* session,
     return Status(kInvalidArgument, "'speed' must be a positive integer");
 
   status = web_view->DispatchTouchEvent(
-      TouchEvent(kTouchStart, location.x, location.y));
+      TouchEvent(kTouchStart, location.x, location.y), false);
   if (status.IsError())
     return status;
 
@@ -301,16 +301,16 @@ Status ExecuteFlick(Session* session,
       (offset * kFlickTouchEventsPerSecond) / speed;
   for (int i = 0; i < total_events; i++) {
     status = web_view->DispatchTouchEvent(
-        TouchEvent(kTouchMove,
-                   location.x + xoffset_per_event * i,
-                   location.y + yoffset_per_event * i));
+        TouchEvent(kTouchMove, location.x + xoffset_per_event * i,
+                   location.y + yoffset_per_event * i),
+        false);
     if (status.IsError())
       return status;
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(1000 / kFlickTouchEventsPerSecond));
   }
   return web_view->DispatchTouchEvent(
-      TouchEvent(kTouchEnd, location.x + xoffset, location.y + yoffset));
+      TouchEvent(kTouchEnd, location.x + xoffset, location.y + yoffset), false);
 }
 
 Status ExecuteClearElement(Session* session,

chrome/test/chromedriver/util.cc

@@ -73,7 +73,7 @@ Status SendKeysOnWindow(
       keys, release_modifiers, &sticky_modifiers_tmp, &events);
   if (status.IsError())
     return status;
-  status = web_view->DispatchKeyEvents(events);
+  status = web_view->DispatchKeyEvents(events, false);
   if (status.IsOk())
     *sticky_modifiers = sticky_modifiers_tmp;
   return status;

chrome/test/chromedriver/window_commands.cc

@@ -337,7 +337,7 @@ Status ExecuteTouchEvent(
   std::list<TouchEvent> events;
   events.push_back(
       TouchEvent(type, relative_x, relative_y));
-  return web_view->DispatchTouchEvents(events);
+  return web_view->DispatchTouchEvents(events, false);
 }
 
 Status WindowViewportSize(Session* session,
@@ -859,8 +859,8 @@ Status ExecuteMouseMoveTo(Session* session,
   events.push_back(MouseEvent(kMovedMouseEventType,
                               session->pressed_mouse_button, location.x,
                               location.y, session->sticky_modifiers, 0, 0));
-  Status status =
-      web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
+  Status status = web_view->DispatchMouseEvents(
+      events, session->GetCurrentFrameId(), false);
   if (status.IsOk())
     session->mouse_position = location;
   return status;
@@ -884,7 +884,8 @@ Status ExecuteMouseClick(Session* session,
                  session->mouse_position.y, session->sticky_modifiers,
                  MouseButtonToButtons(button), 1));
   session->pressed_mouse_button = kNoneMouseButton;
-  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
+  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId(),
+                                       false);
 }
 
 Status ExecuteMouseButtonDown(Session* session,
@@ -901,7 +902,8 @@ Status ExecuteMouseButtonDown(Session* session,
       MouseEvent(kPressedMouseEventType, button, session->mouse_position.x,
                  session->mouse_position.y, session->sticky_modifiers, 0, 1));
   session->pressed_mouse_button = button;
-  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
+  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId(),
+                                       false);
 }
 
 Status ExecuteMouseButtonUp(Session* session,
@@ -919,7 +921,8 @@ Status ExecuteMouseButtonUp(Session* session,
                  session->mouse_position.y, session->sticky_modifiers,
                  MouseButtonToButtons(button), 1));
   session->pressed_mouse_button = kNoneMouseButton;
-  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
+  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId(),
+                                       false);
 }
 
 Status ExecuteMouseDoubleClick(Session* session,
@@ -947,7 +950,8 @@ Status ExecuteMouseDoubleClick(Session* session,
                  session->mouse_position.y, session->sticky_modifiers,
                  MouseButtonToButtons(button), 2));
   session->pressed_mouse_button = kNoneMouseButton;
-  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
+  return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId(),
+                                       false);
 }
 
 Status ExecuteTouchDown(Session* session,
@@ -1340,7 +1344,8 @@ Status ExecutePerformActions(Session* session,
                 session->sticky_modifiers &= ~KeyToKeyModifiers(event.key);
               }
 
-              Status status = web_view->DispatchKeyEvents(dispatch_key_events);
+              Status status =
+                  web_view->DispatchKeyEvents(dispatch_key_events, true);
               if (status.IsError())
                 return status;
             }
@@ -1432,7 +1437,7 @@ Status ExecutePerformActions(Session* session,
               }
               dispatch_mouse_events.push_back(event);
               Status status = web_view->DispatchMouseEvents(
-                  dispatch_mouse_events, session->GetCurrentFrameId());
+                  dispatch_mouse_events, session->GetCurrentFrameId(), true);
               if (status.IsError())
                 return status;
             } else if (pointer_type == "touch") {
@@ -1449,7 +1454,7 @@ Status ExecutePerformActions(Session* session,
                 action_input_states[j]->SetInteger("pressed", 0);
               }
               if (has_touch_start[id]) {
-                Status status = web_view->DispatchTouchEvent(event);
+                Status status = web_view->DispatchTouchEvent(event, true);
                 if (status.IsError())
                   return status;
               }
@@ -1484,7 +1489,7 @@ Status ExecuteReleaseActions(Session* session,
       it->input_state->GetDictionary("pressed", &pressed);
       if (!pressed->HasKey(it->key_event->key))
         continue;
-      web_view->DispatchKeyEvents({*it->key_event});
+      web_view->DispatchKeyEvents({*it->key_event}, false);
       pressed->Remove(it->key_event->key, nullptr);
     } else if (it->mouse_event) {
       int pressed = it->input_state->FindKey("pressed")->GetInt();
@@ -1492,13 +1497,13 @@ Status ExecuteReleaseActions(Session* session,
       if ((pressed & button_mask) == 0)
         continue;
       web_view->DispatchMouseEvents({*it->mouse_event},
-                                    session->GetCurrentFrameId());
+                                    session->GetCurrentFrameId(), false);
       it->input_state->SetInteger("pressed", pressed & ~button_mask);
     } else if (it->touch_event) {
       int pressed = it->input_state->FindKey("pressed")->GetInt();
       if (pressed == 0)
         continue;
-      web_view->DispatchTouchEvents({*it->touch_event});
+      web_view->DispatchTouchEvents({*it->touch_event}, false);
       it->input_state->SetInteger("pressed", 0);
     }
   }