Revert of 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 112 matching lines @@
   } else {
     return false;
   }
   return true;
 }
 
 }  // namespace
 
 InputHandler::InputHandler()
     : host_(NULL),
-      input_queued_(false),
       page_scale_factor_(1.0),
       weak_factory_(this) {
 }
 
 InputHandler::~InputHandler() {
 }
 
-void InputHandler::OnInputEvent(const blink::WebInputEvent& event) {
-  input_queued_ = true;
-}
-
-void InputHandler::OnInputEventAck(const blink::WebInputEvent& event) {
-  if (blink::WebInputEvent::isKeyboardEventType(event.type) &&
-      !pending_key_command_ids_.empty()) {
-    SendDispatchKeyEventResponse(pending_key_command_ids_.front());
-    pending_key_command_ids_.pop_front();
-  } else if (blink::WebInputEvent::isMouseEventType(event.type) &&
-             !pending_mouse_command_ids_.empty()) {
-    SendDispatchMouseEventResponse(pending_mouse_command_ids_.front());
-    pending_mouse_command_ids_.pop_front();
-  }
-}
-
 void InputHandler::SetRenderWidgetHost(RenderWidgetHostImpl* host) {
-  ClearPendingKeyCommands();
-  ClearPendingMouseCommands();
-  if (host_)
-    host_->RemoveInputEventObserver(this);
   host_ = host;
-  if (host)
-    host->AddInputEventObserver(this);
 }
 
 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;
 }
 
-void InputHandler::Detached() {
-  ClearPendingKeyCommands();
-  ClearPendingMouseCommands();
-  if (host_)
-    host_->RemoveInputEventObserver(this);
-}
-
 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,
@@ skipping 41 matching lines @@
 
   if (key) {
     event.domKey = static_cast<int>(
         ui::KeycodeConverter::KeyStringToDomKey(*key));
   }
 
   if (!host_)
     return Response::ServerError("Could not connect to view");
 
   host_->Focus();
-  input_queued_ = false;
   host_->ForwardKeyboardEvent(event);
-  if (input_queued_)
-    pending_key_command_ids_.push_back(command_id);
-  else
-    SendDispatchKeyEventResponse(command_id);
   return Response::OK();
 }
 
 Response InputHandler::DispatchMouseEvent(
-    DevToolsCommandId command_id,
     const std::string& type,
     int x,
     int y,
     const int* modifiers,
     const double* timestamp,
     const std::string* button,
     const int* click_count) {
   blink::WebMouseEvent event;
 
   if (!SetMouseEventType(&event, type)) {
@@ skipping 11 matching lines @@
   event.windowY = y * page_scale_factor_;
   event.globalX = x * page_scale_factor_;
   event.globalY = y * page_scale_factor_;
   event.clickCount = click_count ? *click_count : 0;
   event.pointerType = blink::WebPointerProperties::PointerType::Mouse;
 
   if (!host_)
     return Response::ServerError("Could not connect to view");
 
   host_->Focus();
-  input_queued_ = false;
   host_->ForwardMouseEvent(event);
-  if (input_queued_)
-    pending_mouse_command_ids_.push_back(command_id);
-  else
-    SendDispatchMouseEventResponse(command_id);
   return Response::OK();
 }
 
 Response InputHandler::EmulateTouchFromMouseEvent(const std::string& type,
                                                   int x,
                                                   int y,
                                                   double timestamp,
                                                   const std::string& button,
                                                   double* delta_x,
                                                   double* delta_y,
@@ skipping 209 matching lines @@
 }
 
 Response InputHandler::DispatchTouchEvent(
     const std::string& type,
     const std::vector<std::unique_ptr<base::DictionaryValue>>& touch_points,
     const int* modifiers,
     const double* timestamp) {
   return Response::FallThrough();
 }
 
-void InputHandler::SendDispatchKeyEventResponse(DevToolsCommandId command_id) {
-  client_->SendDispatchKeyEventResponse(
-      command_id, DispatchKeyEventResponse::Create());
-}
-
-void InputHandler::SendDispatchMouseEventResponse(
-    DevToolsCommandId command_id) {
-  client_->SendDispatchMouseEventResponse(
-      command_id, DispatchMouseEventResponse::Create());
-}
-
 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 22 matching lines @@
       client_->SendSynthesizeTapGestureResponse(
           command_id, SynthesizeTapGestureResponse::Create());
     }
   } else {
     client_->SendError(command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic tap failed, result was %d", result)));
   }
 }
 
-void InputHandler::ClearPendingKeyCommands() {
-  for (const DevToolsCommandId& command_id : pending_key_command_ids_)
-    SendDispatchKeyEventResponse(command_id);
-  pending_key_command_ids_.clear();
-}
-
-void InputHandler::ClearPendingMouseCommands() {
-  for (const DevToolsCommandId& command_id : pending_mouse_command_ids_)
-    SendDispatchMouseEventResponse(command_id);
-  pending_mouse_command_ids_.clear();
-}
-
 }  // namespace input
 }  // namespace devtools
 }  // namespace content