DevTools: disable input event processing while auditing with lighthouse.

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 193 matching lines @@
 
 // static
 std::vector<InputHandler*> InputHandler::ForAgentHost(
     DevToolsAgentHostImpl* host) {
   return DevToolsSession::HandlersForAgentHost<InputHandler>(
       host, Input::Metainfo::domainName);
 }
 
 void InputHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   ClearPendingKeyAndMouseCallbacks();
-  if (host_)
+  if (host_) {
     host_->GetRenderWidgetHost()->RemoveInputEventObserver(this);
+    if (ignore_input_events_)
+      host_->GetRenderWidgetHost()->SetIgnoreInputEvents(false);
+  }
   host_ = host;
-  if (host)
+  if (host) {
     host->GetRenderWidgetHost()->AddInputEventObserver(this);
+    if (ignore_input_events_)
+      host_->GetRenderWidgetHost()->SetIgnoreInputEvents(true);
+  }
 }
 
 void InputHandler::OnInputEvent(const blink::WebInputEvent& event) {
   input_queued_ = true;
 }
 
 void InputHandler::OnInputEventAck(const blink::WebInputEvent& event) {
   if (blink::WebInputEvent::IsKeyboardEventType(event.GetType()) &&
       !pending_key_callbacks_.empty()) {
     pending_key_callbacks_.front()->sendSuccess();
@@ skipping 10 matching lines @@
 }
 
 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::Disable() {
   ClearPendingKeyAndMouseCallbacks();
-  if (host_)
+  if (host_) {
     host_->GetRenderWidgetHost()->RemoveInputEventObserver(this);
+    if (ignore_input_events_)
+      host_->GetRenderWidgetHost()->SetIgnoreInputEvents(false);
+  }
+  ignore_input_events_ = false;
   return Response::OK();
 }
 
 void InputHandler::DispatchKeyEvent(
     const std::string& type,
     Maybe<int> modifiers,
     Maybe<double> timestamp,
     Maybe<std::string> text,
     Maybe<std::string> unmodified_text,
     Maybe<std::string> key_identifier,
@@ skipping 190 matching lines @@
   if (!host_ || !host_->GetRenderWidgetHost())
     return Response::InternalError();
 
   if (wheel_event)
     host_->GetRenderWidgetHost()->ForwardWheelEvent(*wheel_event);
   else
     host_->GetRenderWidgetHost()->ForwardMouseEvent(*mouse_event);
   return Response::OK();
 }
 
+Response InputHandler::SetIgnoreInputEvents(bool ignore) {
+  ignore_input_events_ = ignore;
+  if (host_)
+    host_->GetRenderWidgetHost()->SetIgnoreInputEvents(ignore);
+  return Response::OK();
+}
+
 void InputHandler::SynthesizePinchGesture(
     int x,
     int y,
     double scale_factor,
     Maybe<int> relative_speed,
     Maybe<std::string> gesture_source_type,
     std::unique_ptr<SynthesizePinchGestureCallback> callback) {
   if (!host_ || !host_->GetRenderWidgetHost()) {
     callback->sendFailure(Response::InternalError());
     return;
@@ skipping 190 matching lines @@
 }
 
 bool InputHandler::PointIsWithinContents(gfx::PointF point) const {
   gfx::Rect bounds = host_->GetView()->GetViewBounds();
   bounds -= bounds.OffsetFromOrigin();  // Translate the bounds to (0,0).
   return bounds.Contains(point.x(), point.y());
 }
 
 }  // namespace protocol
 }  // namespace content