Delay Input.dispatchKeyEvent response until after key event ack.

content/browser/devtools/protocol/input_handler.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 "content/browser/devtools/protocol/input_handler.h"
 
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 119 matching lines @@
 
 InputHandler::InputHandler()
     : host_(NULL),
       page_scale_factor_(1.0),
       weak_factory_(this) {
 }
 
 InputHandler::~InputHandler() {
 }
 
+void InputHandler::OnInputEventAck(const blink::WebInputEvent& event,
+                                   bool is_synthetic) {
+  if (blink::WebInputEvent::isKeyboardEventType(event.type) && is_synthetic &&
+      !pending_key_event_ids_.empty()) {
+    SendDispatchKeyEventResponse(pending_key_event_ids_.front());
+    pending_key_event_ids_.pop();
+  }
+}
+
 void InputHandler::SetRenderWidgetHost(RenderWidgetHostImpl* host) {
   host_ = host;
 }
 
 void InputHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
 void InputHandler::OnSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   page_scale_factor_ = frame_metadata.page_scale_factor;
   scrollable_viewport_size_ = frame_metadata.scrollable_viewport_size;
 }
 
 Response InputHandler::DispatchKeyEvent(
+    DevToolsCommandId command_id,
     const std::string& type,
     const int* modifiers,
     const double* timestamp,
     const std::string* text,
     const std::string* unmodified_text,
     const std::string* key_identifier,
     const std::string* code,
     const std::string* key,
     const int* windows_virtual_key_code,
     const int* native_virtual_key_code,
     const bool* auto_repeat,
     const bool* is_keypad,
     const bool* is_system_key) {
   NativeWebKeyboardEvent event;
   event.skip_in_browser = true;
+  event.is_synthetic = true;
 
   if (type == dispatch_key_event::kTypeKeyDown) {
     event.type = blink::WebInputEvent::KeyDown;
   } else if (type == dispatch_key_event::kTypeKeyUp) {
     event.type = blink::WebInputEvent::KeyUp;
   } else if (type == dispatch_key_event::kTypeChar) {
     event.type = blink::WebInputEvent::Char;
   } else if (type == dispatch_key_event::kTypeRawKeyDown) {
     event.type = blink::WebInputEvent::RawKeyDown;
   } else {
@@ skipping 25 matching lines @@
   }
 
   if (key) {
     event.domKey = static_cast<int>(
         ui::KeycodeConverter::KeyStringToDomKey(*key));
   }
 
   if (!host_)
     return Response::ServerError("Could not connect to view");
 
+  pending_key_event_ids_.push(command_id);
   host_->Focus();
+  host_->AddInputEventObserver(this);

[dtapuska, 2016/10/14 19:06:29]

So is it possible to call this API twice in a row?  and then
AddInputEventObserver will get called twice and probably will DCHECK no?

Should this remove itself as an observer if it is getting destroyed?

[samuong, 2016/10/20 23:36:18]

The RWHI will check if the observer has already been added, and won't add the
same observer twice. It's not a DCHECK so it won't crash.

Anyway this is a moot point, since I'm now adding this in
InputHandler::SetRenderWidgetHost as you suggested elsewhere.

   host_->ForwardKeyboardEvent(event);
   return Response::OK();
 }
 
 Response InputHandler::DispatchMouseEvent(
     const std::string& type,
     int x,
     int y,
     const int* modifiers,
     const double* timestamp,
@@ skipping 238 matching lines @@
     bool is_last_tap = i == *tap_count - 1;
     host_->QueueSyntheticGesture(
         SyntheticGesture::Create(gesture_params),
         base::Bind(&InputHandler::SendSynthesizeTapGestureResponse,
                    weak_factory_.GetWeakPtr(), command_id, is_last_tap));
   }
 
   return Response::OK();
 }
 
+void InputHandler::SendDispatchKeyEventResponse(DevToolsCommandId command_id) {
+  client_->SendDispatchKeyEventResponse(
+      command_id, DispatchKeyEventResponse::Create());
+  host_->RemoveInputEventObserver(this);
+}
+
 void InputHandler::SendSynthesizePinchGestureResponse(
     DevToolsCommandId command_id,
     SyntheticGesture::Result result) {
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     client_->SendSynthesizePinchGestureResponse(
         command_id, SynthesizePinchGestureResponse::Create());
   } else {
     client_->SendError(command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic pinch failed, result was %d", result)));
@@ skipping 25 matching lines @@
   } else {
     client_->SendError(command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic tap failed, result was %d", result)));
   }
 }
 
 }  // namespace input
 }  // namespace devtools
 }  // namespace content