Revert of [DevTools] Consolidate overlay-related functionality in Overlay domain

third_party/WebKit/Source/web/InspectorOverlayAgent.cpp

Index: third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
diff --git a/third_party/WebKit/Source/web/InspectorOverlayAgent.cpp b/third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
deleted file mode 100644
index e5ad62dc885af4993741a082418efa89e6a91cf3..0000000000000000000000000000000000000000
--- a/third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
+++ /dev/null
@@ -1,1162 +0,0 @@
-/*
- * Copyright (C) 2011 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "web/InspectorOverlayAgent.h"
-
-#include <memory>
-
-#include "bindings/core/v8/ScriptController.h"
-#include "bindings/core/v8/ScriptSourceCode.h"
-#include "bindings/core/v8/V8Binding.h"
-#include "bindings/core/v8/V8InspectorOverlayHost.h"
-#include "core/dom/DOMNodeIds.h"
-#include "core/dom/Node.h"
-#include "core/dom/StaticNodeList.h"
-#include "core/dom/TaskRunnerHelper.h"
-#include "core/frame/FrameView.h"
-#include "core/frame/LocalFrame.h"
-#include "core/frame/LocalFrameClient.h"
-#include "core/frame/Settings.h"
-#include "core/frame/VisualViewport.h"
-#include "core/html/HTMLFrameOwnerElement.h"
-#include "core/input/EventHandler.h"
-#include "core/inspector/IdentifiersFactory.h"
-#include "core/inspector/InspectedFrames.h"
-#include "core/inspector/InspectorDOMAgent.h"
-#include "core/inspector/InspectorOverlayHost.h"
-#include "core/layout/api/LayoutViewItem.h"
-#include "core/loader/EmptyClients.h"
-#include "core/loader/FrameLoadRequest.h"
-#include "core/page/ChromeClient.h"
-#include "core/page/Page.h"
-#include "platform/ScriptForbiddenScope.h"
-#include "platform/graphics/Color.h"
-#include "platform/graphics/GraphicsContext.h"
-#include "platform/graphics/paint/CullRect.h"
-#include "platform/wtf/AutoReset.h"
-#include "public/platform/Platform.h"
-#include "public/platform/WebData.h"
-#include "v8/include/v8.h"
-#include "web/ChromeClientImpl.h"
-#include "web/PageOverlay.h"
-#include "web/WebInputEventConversion.h"
-#include "web/WebLocalFrameImpl.h"
-#include "web/WebViewImpl.h"
-
-namespace blink {
-
-using protocol::Maybe;
-using protocol::Response;
-
-namespace {
-
-namespace OverlayAgentState {
-static const char kEnabled[] = "enabled";
-static const char kShowDebugBorders[] = "showDebugBorders";
-static const char kShowFPSCounter[] = "showFPSCounter";
-static const char kShowPaintRects[] = "showPaintRects";
-static const char kShowScrollBottleneckRects[] = "showScrollBottleneckRects";
-static const char kShowSizeOnResize[] = "showSizeOnResize";
-static const char kSuspended[] = "suspended";
-static const char kPausedInDebuggerMessage[] = "pausedInDebuggerMessage";
-}
-
-Node* HoveredNodeForPoint(LocalFrame* frame,
-                          const IntPoint& point_in_root_frame,
-                          bool ignore_pointer_events_none) {
-  HitTestRequest::HitTestRequestType hit_type =
-      HitTestRequest::kMove | HitTestRequest::kReadOnly |
-      HitTestRequest::kAllowChildFrameContent;
-  if (ignore_pointer_events_none)
-    hit_type |= HitTestRequest::kIgnorePointerEventsNone;
-  HitTestRequest request(hit_type);
-  HitTestResult result(request,
-                       frame->View()->RootFrameToContents(point_in_root_frame));
-  frame->ContentLayoutItem().HitTest(result);
-  Node* node = result.InnerPossiblyPseudoNode();
-  while (node && node->getNodeType() == Node::kTextNode)
-    node = node->parentNode();
-  return node;
-}
-
-Node* HoveredNodeForEvent(LocalFrame* frame,
-                          const WebGestureEvent& event,
-                          bool ignore_pointer_events_none) {
-  return HoveredNodeForPoint(frame,
-                             RoundedIntPoint(event.PositionInRootFrame()),
-                             ignore_pointer_events_none);
-}
-
-Node* HoveredNodeForEvent(LocalFrame* frame,
-                          const WebMouseEvent& event,
-                          bool ignore_pointer_events_none) {
-  return HoveredNodeForPoint(frame,
-                             RoundedIntPoint(event.PositionInRootFrame()),
-                             ignore_pointer_events_none);
-}
-
-Node* HoveredNodeForEvent(LocalFrame* frame,
-                          const WebTouchEvent& event,
-                          bool ignore_pointer_events_none) {
-  if (!event.touches_length)
-    return nullptr;
-  WebTouchPoint transformed_point = event.TouchPointInRootFrame(0);
-  return HoveredNodeForPoint(frame, RoundedIntPoint(transformed_point.position),
-                             ignore_pointer_events_none);
-}
-
-bool ParseQuad(std::unique_ptr<protocol::Array<double>> quad_array,
-               FloatQuad* quad) {
-  const size_t kCoordinatesInQuad = 8;
-  if (!quad_array || quad_array->length() != kCoordinatesInQuad)
-    return false;
-  quad->SetP1(FloatPoint(quad_array->get(0), quad_array->get(1)));
-  quad->SetP2(FloatPoint(quad_array->get(2), quad_array->get(3)));
-  quad->SetP3(FloatPoint(quad_array->get(4), quad_array->get(5)));
-  quad->SetP4(FloatPoint(quad_array->get(6), quad_array->get(7)));
-  return true;
-}
-
-}  // namespace
-
-class InspectorOverlayAgent::InspectorPageOverlayDelegate final
-    : public PageOverlay::Delegate {
- public:
-  explicit InspectorPageOverlayDelegate(InspectorOverlayAgent& overlay)
-      : overlay_(&overlay) {}
-
-  void PaintPageOverlay(const PageOverlay&,
-                        GraphicsContext& graphics_context,
-                        const WebSize& web_view_size) const override {
-    if (overlay_->IsEmpty())
-      return;
-
-    FrameView* view = overlay_->OverlayMainFrame()->View();
-    DCHECK(!view->NeedsLayout());
-    view->Paint(graphics_context,
-                CullRect(IntRect(0, 0, view->Width(), view->Height())));
-  }
-
- private:
-  Persistent<InspectorOverlayAgent> overlay_;
-};
-
-class InspectorOverlayAgent::InspectorOverlayChromeClient final
-    : public EmptyChromeClient {
- public:
-  static InspectorOverlayChromeClient* Create(ChromeClient& client,
-                                              InspectorOverlayAgent& overlay) {
-    return new InspectorOverlayChromeClient(client, overlay);
-  }
-
-  DEFINE_INLINE_VIRTUAL_TRACE() {
-    visitor->Trace(client_);
-    visitor->Trace(overlay_);
-    EmptyChromeClient::Trace(visitor);
-  }
-
-  void SetCursor(const Cursor& cursor, LocalFrame* local_root) override {
-    ToChromeClientImpl(client_)->SetCursorOverridden(false);
-    ToChromeClientImpl(client_)->SetCursor(cursor,
-                                           overlay_->frame_impl_->GetFrame());
-    ToChromeClientImpl(client_)->SetCursorOverridden(false);
-  }
-
-  void SetToolTip(LocalFrame& frame,
-                  const String& tooltip,
-                  TextDirection direction) override {
-    DCHECK_EQ(&frame, overlay_->OverlayMainFrame());
-    client_->SetToolTip(*overlay_->frame_impl_->GetFrame(), tooltip, direction);
-  }
-
-  void InvalidateRect(const IntRect&) override { overlay_->Invalidate(); }
-
-  void ScheduleAnimation(LocalFrame* frame) override {
-    if (overlay_->in_layout_)
-      return;
-
-    client_->ScheduleAnimation(frame);
-  }
-
- private:
-  InspectorOverlayChromeClient(ChromeClient& client,
-                               InspectorOverlayAgent& overlay)
-      : client_(&client), overlay_(&overlay) {}
-
-  Member<ChromeClient> client_;
-  Member<InspectorOverlayAgent> overlay_;
-};
-
-InspectorOverlayAgent::InspectorOverlayAgent(
-    WebLocalFrameImpl* frame_impl,
-    InspectedFrames* inspected_frames,
-    v8_inspector::V8InspectorSession* v8_session,
-    InspectorDOMAgent* dom_agent)
-    : frame_impl_(frame_impl),
-      inspected_frames_(inspected_frames),
-      enabled_(false),
-      overlay_host_(new InspectorOverlayHost(this)),
-      draw_view_size_(false),
-      resize_timer_active_(false),
-      omit_tooltip_(false),
-      timer_(TaskRunnerHelper::Get(TaskType::kUnspecedTimer,
-                                   frame_impl->GetFrame()),
-             this,
-             &InspectorOverlayAgent::OnTimer),
-      suspended_(false),
-      show_reloading_blanket_(false),
-      in_layout_(false),
-      needs_update_(false),
-      v8_session_(v8_session),
-      dom_agent_(dom_agent),
-      swallow_next_mouse_up_(false),
-      inspect_mode_(kNotSearching),
-      backend_node_id_to_inspect_(0) {}
-
-InspectorOverlayAgent::~InspectorOverlayAgent() {
-  DCHECK(!overlay_page_);
-}
-
-DEFINE_TRACE(InspectorOverlayAgent) {
-  visitor->Trace(frame_impl_);
-  visitor->Trace(inspected_frames_);
-  visitor->Trace(highlight_node_);
-  visitor->Trace(event_target_node_);
-  visitor->Trace(overlay_page_);
-  visitor->Trace(overlay_chrome_client_);
-  visitor->Trace(overlay_host_);
-  visitor->Trace(dom_agent_);
-  visitor->Trace(hovered_node_for_inspect_mode_);
-  InspectorBaseAgent::Trace(visitor);
-}
-
-void InspectorOverlayAgent::Restore() {
-  if (state_->booleanProperty(OverlayAgentState::kEnabled, false))
-    enabled_ = true;
-  setShowDebugBorders(
-      state_->booleanProperty(OverlayAgentState::kShowDebugBorders, false));
-  setShowFPSCounter(
-      state_->booleanProperty(OverlayAgentState::kShowFPSCounter, false));
-  setShowPaintRects(
-      state_->booleanProperty(OverlayAgentState::kShowPaintRects, false));
-  setShowScrollBottleneckRects(state_->booleanProperty(
-      OverlayAgentState::kShowScrollBottleneckRects, false));
-  setShowViewportSizeOnResize(
-      state_->booleanProperty(OverlayAgentState::kShowSizeOnResize, false));
-  String message;
-  state_->getString(OverlayAgentState::kPausedInDebuggerMessage, &message);
-  setPausedInDebuggerMessage(message);
-  setSuspended(state_->booleanProperty(OverlayAgentState::kSuspended, false));
-}
-
-void InspectorOverlayAgent::Dispose() {
-  show_reloading_blanket_ = false;
-  ClearInternal();
-  InspectorBaseAgent::Dispose();
-}
-
-Response InspectorOverlayAgent::enable() {
-  if (!dom_agent_->Enabled())
-    return Response::Error("DOM should be enabled first");
-  state_->setBoolean(OverlayAgentState::kEnabled, true);
-  enabled_ = true;
-  if (backend_node_id_to_inspect_)
-    GetFrontend()->inspectNodeRequested(backend_node_id_to_inspect_);
-  backend_node_id_to_inspect_ = 0;
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::disable() {
-  state_->setBoolean(OverlayAgentState::kEnabled, false);
-  enabled_ = false;
-  setShowDebugBorders(false);
-  setShowFPSCounter(false);
-  setShowPaintRects(false);
-  setShowScrollBottleneckRects(false);
-  setShowViewportSizeOnResize(false);
-  setPausedInDebuggerMessage(String());
-  setSuspended(false);
-  SetSearchingForNode(kNotSearching,
-                      Maybe<protocol::Overlay::HighlightConfig>());
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setShowDebugBorders(bool show) {
-  state_->setBoolean(OverlayAgentState::kShowDebugBorders, show);
-  if (show) {
-    Response response = CompositingEnabled();
-    if (!response.isSuccess())
-      return response;
-  }
-  frame_impl_->ViewImpl()->SetShowDebugBorders(show);
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setShowFPSCounter(bool show) {
-  state_->setBoolean(OverlayAgentState::kShowFPSCounter, show);
-  if (show) {
-    Response response = CompositingEnabled();
-    if (!response.isSuccess())
-      return response;
-  }
-  frame_impl_->ViewImpl()->SetShowFPSCounter(show);
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setShowPaintRects(bool show) {
-  state_->setBoolean(OverlayAgentState::kShowPaintRects, show);
-  if (show) {
-    Response response = CompositingEnabled();
-    if (!response.isSuccess())
-      return response;
-  }
-  frame_impl_->ViewImpl()->SetShowPaintRects(show);
-  if (!show && frame_impl_->GetFrameView())
-    frame_impl_->GetFrameView()->Invalidate();
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setShowScrollBottleneckRects(bool show) {
-  state_->setBoolean(OverlayAgentState::kShowScrollBottleneckRects, show);
-  if (show) {
-    Response response = CompositingEnabled();
-    if (!response.isSuccess())
-      return response;
-  }
-  frame_impl_->ViewImpl()->SetShowScrollBottleneckRects(show);
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setShowViewportSizeOnResize(bool show) {
-  state_->setBoolean(OverlayAgentState::kShowSizeOnResize, show);
-  draw_view_size_ = show;
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setPausedInDebuggerMessage(
-    Maybe<String> message) {
-  String just_message = message.fromMaybe(String());
-  state_->setString(OverlayAgentState::kPausedInDebuggerMessage, just_message);
-  paused_in_debugger_message_ = just_message;
-  ScheduleUpdate();
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setSuspended(bool suspended) {
-  state_->setBoolean(OverlayAgentState::kSuspended, suspended);
-  if (suspended && !suspended_ && !show_reloading_blanket_)
-    ClearInternal();
-  suspended_ = suspended;
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::setInspectMode(
-    const String& mode,
-    Maybe<protocol::Overlay::HighlightConfig> highlight_config) {
-  SearchMode search_mode;
-  if (mode == protocol::Overlay::InspectModeEnum::SearchForNode) {
-    search_mode = kSearchingForNormal;
-  } else if (mode == protocol::Overlay::InspectModeEnum::SearchForUAShadowDOM) {
-    search_mode = kSearchingForUAShadow;
-  } else if (mode == protocol::Overlay::InspectModeEnum::None) {
-    search_mode = kNotSearching;
-  } else {
-    return Response::Error(
-        String("Unknown mode \"" + mode + "\" was provided."));
-  }
-
-  if (search_mode != kNotSearching) {
-    Response response = dom_agent_->PushDocumentUponHandlelessOperation();
-    if (!response.isSuccess())
-      return response;
-  }
-
-  return SetSearchingForNode(search_mode, std::move(highlight_config));
-}
-
-Response InspectorOverlayAgent::highlightRect(
-    int x,
-    int y,
-    int width,
-    int height,
-    Maybe<protocol::DOM::RGBA> color,
-    Maybe<protocol::DOM::RGBA> outline_color) {
-  std::unique_ptr<FloatQuad> quad =
-      WTF::WrapUnique(new FloatQuad(FloatRect(x, y, width, height)));
-  InnerHighlightQuad(std::move(quad), std::move(color),
-                     std::move(outline_color));
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::highlightQuad(
-    std::unique_ptr<protocol::Array<double>> quad_array,
-    Maybe<protocol::DOM::RGBA> color,
-    Maybe<protocol::DOM::RGBA> outline_color) {
-  std::unique_ptr<FloatQuad> quad = WTF::MakeUnique<FloatQuad>();
-  if (!ParseQuad(std::move(quad_array), quad.get()))
-    return Response::Error("Invalid Quad format");
-  InnerHighlightQuad(std::move(quad), std::move(color),
-                     std::move(outline_color));
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::highlightNode(
-    std::unique_ptr<protocol::Overlay::HighlightConfig>
-        highlight_inspector_object,
-    Maybe<int> node_id,
-    Maybe<int> backend_node_id,
-    Maybe<String> object_id) {
-  Node* node = nullptr;
-  Response response;
-  if (node_id.isJust()) {
-    response = dom_agent_->AssertNode(node_id.fromJust(), node);
-  } else if (backend_node_id.isJust()) {
-    node = DOMNodeIds::NodeForId(backend_node_id.fromJust());
-    response = !node ? Response::Error("No node found for given backend id")
-                     : Response::OK();
-  } else if (object_id.isJust()) {
-    response = dom_agent_->NodeForRemoteObjectId(object_id.fromJust(), node);
-  } else {
-    response = Response::Error(
-        "Either nodeId, backendNodeId or objectId must be specified");
-  }
-
-  if (!response.isSuccess())
-    return response;
-
-  std::unique_ptr<InspectorHighlightConfig> highlight_config;
-  response = HighlightConfigFromInspectorObject(
-      std::move(highlight_inspector_object), &highlight_config);
-  if (!response.isSuccess())
-    return response;
-
-  InnerHighlightNode(node, nullptr, *highlight_config, false);
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::highlightFrame(
-    const String& frame_id,
-    Maybe<protocol::DOM::RGBA> color,
-    Maybe<protocol::DOM::RGBA> outline_color) {
-  LocalFrame* frame =
-      IdentifiersFactory::FrameById(inspected_frames_, frame_id);
-  // FIXME: Inspector doesn't currently work cross process.
-  if (frame && frame->DeprecatedLocalOwner()) {
-    std::unique_ptr<InspectorHighlightConfig> highlight_config =
-        WTF::MakeUnique<InspectorHighlightConfig>();
-    highlight_config->show_info = true;  // Always show tooltips for frames.
-    highlight_config->content =
-        InspectorDOMAgent::ParseColor(color.fromMaybe(nullptr));
-    highlight_config->content_outline =
-        InspectorDOMAgent::ParseColor(outline_color.fromMaybe(nullptr));
-    InnerHighlightNode(frame->DeprecatedLocalOwner(), nullptr,
-                       *highlight_config, false);
-  }
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::hideHighlight() {
-  InnerHideHighlight();
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::getHighlightObjectForTest(
-    int node_id,
-    std::unique_ptr<protocol::DictionaryValue>* result) {
-  Node* node = nullptr;
-  Response response = dom_agent_->AssertNode(node_id, node);
-  if (!response.isSuccess())
-    return response;
-  InspectorHighlight highlight(node, InspectorHighlight::DefaultConfig(), true);
-  *result = highlight.AsProtocolValue();
-  return Response::OK();
-}
-
-void InspectorOverlayAgent::Invalidate() {
-  if (!page_overlay_) {
-    page_overlay_ = PageOverlay::Create(
-        frame_impl_, WTF::WrapUnique(new InspectorPageOverlayDelegate(*this)));
-  }
-
-  page_overlay_->Update();
-}
-
-void InspectorOverlayAgent::UpdateAllLifecyclePhases() {
-  if (IsEmpty())
-    return;
-
-  AutoReset<bool> scoped(&in_layout_, true);
-  if (needs_update_) {
-    needs_update_ = false;
-    RebuildOverlayPage();
-  }
-  OverlayMainFrame()->View()->UpdateAllLifecyclePhases();
-}
-
-bool InspectorOverlayAgent::HandleInputEvent(const WebInputEvent& input_event) {
-  bool handled = false;
-
-  if (IsEmpty())
-    return false;
-
-  if (input_event.GetType() == WebInputEvent::kGestureTap) {
-    // We only have a use for gesture tap.
-    WebGestureEvent transformed_event = TransformWebGestureEvent(
-        frame_impl_->GetFrameView(),
-        static_cast<const WebGestureEvent&>(input_event));
-    handled = HandleGestureEvent(transformed_event);
-    if (handled)
-      return true;
-
-    OverlayMainFrame()->GetEventHandler().HandleGestureEvent(transformed_event);
-  }
-  if (WebInputEvent::IsMouseEventType(input_event.GetType())) {
-    WebMouseEvent mouse_event =
-        TransformWebMouseEvent(frame_impl_->GetFrameView(),
-                               static_cast<const WebMouseEvent&>(input_event));
-
-    if (mouse_event.GetType() == WebInputEvent::kMouseMove)
-      handled = HandleMouseMove(mouse_event);
-    else if (mouse_event.GetType() == WebInputEvent::kMouseDown)
-      handled = HandleMouseDown();
-    else if (mouse_event.GetType() == WebInputEvent::kMouseUp)
-      handled = HandleMouseUp();
-
-    if (handled)
-      return true;
-
-    if (mouse_event.GetType() == WebInputEvent::kMouseMove) {
-      handled = OverlayMainFrame()->GetEventHandler().HandleMouseMoveEvent(
-                    mouse_event, TransformWebMouseEventVector(
-                                     frame_impl_->GetFrameView(),
-                                     std::vector<const WebInputEvent*>())) !=
-                WebInputEventResult::kNotHandled;
-    }
-    if (mouse_event.GetType() == WebInputEvent::kMouseDown) {
-      handled = OverlayMainFrame()->GetEventHandler().HandleMousePressEvent(
-                    mouse_event) != WebInputEventResult::kNotHandled;
-    }
-    if (mouse_event.GetType() == WebInputEvent::kMouseUp) {
-      handled = OverlayMainFrame()->GetEventHandler().HandleMouseReleaseEvent(
-                    mouse_event) != WebInputEventResult::kNotHandled;
-    }
-  }
-
-  if (WebInputEvent::IsTouchEventType(input_event.GetType())) {
-    WebTouchEvent transformed_event =
-        TransformWebTouchEvent(frame_impl_->GetFrameView(),
-                               static_cast<const WebTouchEvent&>(input_event));
-    handled = HandleTouchEvent(transformed_event);
-    if (handled)
-      return true;
-    OverlayMainFrame()->GetEventHandler().HandleTouchEvent(
-        transformed_event, Vector<WebTouchEvent>());
-  }
-  if (WebInputEvent::IsKeyboardEventType(input_event.GetType())) {
-    OverlayMainFrame()->GetEventHandler().KeyEvent(
-        static_cast<const WebKeyboardEvent&>(input_event));
-  }
-
-  if (input_event.GetType() == WebInputEvent::kMouseWheel) {
-    WebMouseWheelEvent transformed_event = TransformWebMouseWheelEvent(
-        frame_impl_->GetFrameView(),
-        static_cast<const WebMouseWheelEvent&>(input_event));
-    handled = OverlayMainFrame()->GetEventHandler().HandleWheelEvent(
-                  transformed_event) != WebInputEventResult::kNotHandled;
-  }
-
-  return handled;
-}
-
-void InspectorOverlayAgent::ShowReloadingBlanket() {
-  show_reloading_blanket_ = true;
-  ScheduleUpdate();
-}
-
-void InspectorOverlayAgent::HideReloadingBlanket() {
-  if (!show_reloading_blanket_)
-    return;
-  show_reloading_blanket_ = false;
-  if (suspended_)
-    ClearInternal();
-  else
-    ScheduleUpdate();
-}
-
-void InspectorOverlayAgent::InnerHideHighlight() {
-  highlight_node_.Clear();
-  event_target_node_.Clear();
-  highlight_quad_.reset();
-  ScheduleUpdate();
-}
-
-void InspectorOverlayAgent::InnerHighlightNode(
-    Node* node,
-    Node* event_target,
-    const InspectorHighlightConfig& highlight_config,
-    bool omit_tooltip) {
-  node_highlight_config_ = highlight_config;
-  highlight_node_ = node;
-  event_target_node_ = event_target;
-  omit_tooltip_ = omit_tooltip;
-  ScheduleUpdate();
-}
-
-void InspectorOverlayAgent::InnerHighlightQuad(
-    std::unique_ptr<FloatQuad> quad,
-    Maybe<protocol::DOM::RGBA> color,
-    Maybe<protocol::DOM::RGBA> outline_color) {
-  quad_content_color_ = InspectorDOMAgent::ParseColor(color.fromMaybe(nullptr));
-  quad_content_outline_color_ =
-      InspectorDOMAgent::ParseColor(outline_color.fromMaybe(nullptr));
-  highlight_quad_ = std::move(quad);
-  omit_tooltip_ = false;
-  ScheduleUpdate();
-}
-
-bool InspectorOverlayAgent::IsEmpty() {
-  if (show_reloading_blanket_)
-    return false;
-  if (suspended_)
-    return true;
-  bool has_visible_elements = highlight_node_ || event_target_node_ ||
-                              highlight_quad_ ||
-                              (resize_timer_active_ && draw_view_size_) ||
-                              !paused_in_debugger_message_.IsNull();
-  return !has_visible_elements && inspect_mode_ == kNotSearching;
-}
-
-void InspectorOverlayAgent::ScheduleUpdate() {
-  if (IsEmpty()) {
-    if (page_overlay_)
-      page_overlay_.reset();
-    return;
-  }
-  needs_update_ = true;
-  LocalFrame* frame = frame_impl_->GetFrame();
-  if (frame) {
-    frame->GetPage()->GetChromeClient().ScheduleAnimation(frame);
-  }
-}
-
-void InspectorOverlayAgent::RebuildOverlayPage() {
-  FrameView* view = frame_impl_->GetFrameView();
-  LocalFrame* frame = frame_impl_->GetFrame();
-  if (!view || !frame)
-    return;
-
-  IntRect visible_rect_in_document =
-      view->GetScrollableArea()->VisibleContentRect();
-  IntSize viewport_size = frame->GetPage()->GetVisualViewport().Size();
-  OverlayMainFrame()->View()->Resize(viewport_size);
-  OverlayPage()->GetVisualViewport().SetSize(viewport_size);
-  OverlayMainFrame()->SetPageZoomFactor(WindowToViewportScale());
-
-  Reset(viewport_size, visible_rect_in_document.Location());
-
-  if (show_reloading_blanket_) {
-    EvaluateInOverlay("showReloadingBlanket", "");
-    return;
-  }
-  DrawNodeHighlight();
-  DrawQuadHighlight();
-  DrawPausedInDebuggerMessage();
-  DrawViewSize();
-}
-
-static std::unique_ptr<protocol::DictionaryValue> BuildObjectForSize(
-    const IntSize& size) {
-  std::unique_ptr<protocol::DictionaryValue> result =
-      protocol::DictionaryValue::create();
-  result->setInteger("width", size.Width());
-  result->setInteger("height", size.Height());
-  return result;
-}
-
-void InspectorOverlayAgent::DrawNodeHighlight() {
-  if (!highlight_node_)
-    return;
-
-  String selectors = node_highlight_config_.selector_list;
-  StaticElementList* elements = nullptr;
-  DummyExceptionStateForTesting exception_state;
-  ContainerNode* query_base = highlight_node_->ContainingShadowRoot();
-  if (!query_base)
-    query_base = highlight_node_->ownerDocument();
-  if (selectors.length()) {
-    elements =
-        query_base->QuerySelectorAll(AtomicString(selectors), exception_state);
-  }
-  if (elements && !exception_state.HadException()) {
-    for (unsigned i = 0; i < elements->length(); ++i) {
-      Element* element = elements->item(i);
-      InspectorHighlight highlight(element, node_highlight_config_, false);
-      std::unique_ptr<protocol::DictionaryValue> highlight_json =
-          highlight.AsProtocolValue();
-      EvaluateInOverlay("drawHighlight", std::move(highlight_json));
-    }
-  }
-
-  bool append_element_info =
-      highlight_node_->IsElementNode() && !omit_tooltip_ &&
-      node_highlight_config_.show_info && highlight_node_->GetLayoutObject() &&
-      highlight_node_->GetDocument().GetFrame();
-  InspectorHighlight highlight(highlight_node_.Get(), node_highlight_config_,
-                               append_element_info);
-  if (event_target_node_) {
-    highlight.AppendEventTargetQuads(event_target_node_.Get(),
-                                     node_highlight_config_);
-  }
-
-  std::unique_ptr<protocol::DictionaryValue> highlight_json =
-      highlight.AsProtocolValue();
-  EvaluateInOverlay("drawHighlight", std::move(highlight_json));
-}
-
-void InspectorOverlayAgent::DrawQuadHighlight() {
-  if (!highlight_quad_)
-    return;
-
-  InspectorHighlight highlight(WindowToViewportScale());
-  highlight.AppendQuad(*highlight_quad_, quad_content_color_,
-                       quad_content_outline_color_);
-  EvaluateInOverlay("drawHighlight", highlight.AsProtocolValue());
-}
-
-void InspectorOverlayAgent::DrawPausedInDebuggerMessage() {
-  if (inspect_mode_ == kNotSearching && !paused_in_debugger_message_.IsNull()) {
-    EvaluateInOverlay("drawPausedInDebuggerMessage",
-                      paused_in_debugger_message_);
-  }
-}
-
-void InspectorOverlayAgent::DrawViewSize() {
-  if (resize_timer_active_ && draw_view_size_)
-    EvaluateInOverlay("drawViewSize", "");
-}
-
-float InspectorOverlayAgent::WindowToViewportScale() const {
-  LocalFrame* frame = frame_impl_->GetFrame();
-  if (!frame)
-    return 1.0f;
-  return frame->GetPage()->GetChromeClient().WindowToViewportScalar(1.0f);
-}
-
-Page* InspectorOverlayAgent::OverlayPage() {
-  if (overlay_page_)
-    return overlay_page_.Get();
-
-  ScriptForbiddenScope::AllowUserAgentScript allow_script;
-
-  DEFINE_STATIC_LOCAL(LocalFrameClient, dummy_local_frame_client,
-                      (EmptyLocalFrameClient::Create()));
-  Page::PageClients page_clients;
-  FillWithEmptyClients(page_clients);
-  DCHECK(!overlay_chrome_client_);
-  overlay_chrome_client_ = InspectorOverlayChromeClient::Create(
-      frame_impl_->GetFrame()->GetPage()->GetChromeClient(), *this);
-  page_clients.chrome_client = overlay_chrome_client_.Get();
-  overlay_page_ = Page::Create(page_clients);
-
-  Settings& settings = frame_impl_->GetFrame()->GetPage()->GetSettings();
-  Settings& overlay_settings = overlay_page_->GetSettings();
-
-  overlay_settings.GetGenericFontFamilySettings().UpdateStandard(
-      settings.GetGenericFontFamilySettings().Standard());
-  overlay_settings.GetGenericFontFamilySettings().UpdateSerif(
-      settings.GetGenericFontFamilySettings().Serif());
-  overlay_settings.GetGenericFontFamilySettings().UpdateSansSerif(
-      settings.GetGenericFontFamilySettings().SansSerif());
-  overlay_settings.GetGenericFontFamilySettings().UpdateCursive(
-      settings.GetGenericFontFamilySettings().Cursive());
-  overlay_settings.GetGenericFontFamilySettings().UpdateFantasy(
-      settings.GetGenericFontFamilySettings().Fantasy());
-  overlay_settings.GetGenericFontFamilySettings().UpdatePictograph(
-      settings.GetGenericFontFamilySettings().Pictograph());
-  overlay_settings.SetMinimumFontSize(settings.GetMinimumFontSize());
-  overlay_settings.SetMinimumLogicalFontSize(
-      settings.GetMinimumLogicalFontSize());
-  overlay_settings.SetScriptEnabled(true);
-  overlay_settings.SetPluginsEnabled(false);
-  overlay_settings.SetLoadsImagesAutomatically(true);
-  // FIXME: http://crbug.com/363843. Inspector should probably create its
-  // own graphics layers and attach them to the tree rather than going
-  // through some non-composited paint function.
-  overlay_settings.SetAcceleratedCompositingEnabled(false);
-
-  LocalFrame* frame =
-      LocalFrame::Create(&dummy_local_frame_client, *overlay_page_, 0);
-  frame->SetView(FrameView::Create(*frame));
-  frame->Init();
-  FrameLoader& loader = frame->Loader();
-  frame->View()->SetCanHaveScrollbars(false);
-  frame->View()->SetBaseBackgroundColor(Color::kTransparent);
-
-  const WebData& overlay_page_html_resource =
-      Platform::Current()->LoadResource("InspectorOverlayPage.html");
-  loader.Load(
-      FrameLoadRequest(0, ResourceRequest(BlankURL()),
-                       SubstituteData(overlay_page_html_resource, "text/html",
-                                      "UTF-8", KURL(), kForceSynchronousLoad)));
-  v8::Isolate* isolate = ToIsolate(frame);
-  ScriptState* script_state = ToScriptStateForMainWorld(frame);
-  DCHECK(script_state);
-  ScriptState::Scope scope(script_state);
-  v8::Local<v8::Object> global = script_state->GetContext()->Global();
-  v8::Local<v8::Value> overlay_host_obj =
-      ToV8(overlay_host_.Get(), global, isolate);
-  DCHECK(!overlay_host_obj.IsEmpty());
-  global
-      ->Set(script_state->GetContext(),
-            V8AtomicString(isolate, "InspectorOverlayHost"), overlay_host_obj)
-      .ToChecked();
-
-#if OS(WIN)
-  EvaluateInOverlay("setPlatform", "windows");
-#elif OS(MACOSX)
-  EvaluateInOverlay("setPlatform", "mac");
-#elif OS(POSIX)
-  EvaluateInOverlay("setPlatform", "linux");
-#endif
-
-  return overlay_page_.Get();
-}
-
-LocalFrame* InspectorOverlayAgent::OverlayMainFrame() {
-  return ToLocalFrame(OverlayPage()->MainFrame());
-}
-
-void InspectorOverlayAgent::Reset(const IntSize& viewport_size,
-                                  const IntPoint& document_scroll_offset) {
-  std::unique_ptr<protocol::DictionaryValue> reset_data =
-      protocol::DictionaryValue::create();
-  reset_data->setDouble(
-      "deviceScaleFactor",
-      frame_impl_->GetFrame()->GetPage()->DeviceScaleFactorDeprecated());
-  reset_data->setDouble(
-      "pageScaleFactor",
-      frame_impl_->GetFrame()->GetPage()->GetVisualViewport().Scale());
-
-  IntRect viewport_in_screen =
-      frame_impl_->GetFrame()->GetPage()->GetChromeClient().ViewportToScreen(
-          IntRect(IntPoint(), viewport_size), frame_impl_->GetFrame()->View());
-  reset_data->setObject("viewportSize",
-                        BuildObjectForSize(viewport_in_screen.Size()));
-
-  // The zoom factor in the overlay frame already has been multiplied by the
-  // window to viewport scale (aka device scale factor), so cancel it.
-  reset_data->setDouble(
-      "pageZoomFactor",
-      frame_impl_->GetFrame()->PageZoomFactor() / WindowToViewportScale());
-
-  reset_data->setInteger("scrollX", document_scroll_offset.X());
-  reset_data->setInteger("scrollY", document_scroll_offset.Y());
-  EvaluateInOverlay("reset", std::move(reset_data));
-}
-
-void InspectorOverlayAgent::EvaluateInOverlay(const String& method,
-                                              const String& argument) {
-  ScriptForbiddenScope::AllowUserAgentScript allow_script;
-  std::unique_ptr<protocol::ListValue> command = protocol::ListValue::create();
-  command->pushValue(protocol::StringValue::create(method));
-  command->pushValue(protocol::StringValue::create(argument));
-  ToLocalFrame(OverlayPage()->MainFrame())
-      ->GetScriptController()
-      .ExecuteScriptInMainWorld(
-          "dispatch(" + command->serialize() + ")",
-          ScriptController::kExecuteScriptWhenScriptsDisabled);
-}
-
-void InspectorOverlayAgent::EvaluateInOverlay(
-    const String& method,
-    std::unique_ptr<protocol::Value> argument) {
-  ScriptForbiddenScope::AllowUserAgentScript allow_script;
-  std::unique_ptr<protocol::ListValue> command = protocol::ListValue::create();
-  command->pushValue(protocol::StringValue::create(method));
-  command->pushValue(std::move(argument));
-  ToLocalFrame(OverlayPage()->MainFrame())
-      ->GetScriptController()
-      .ExecuteScriptInMainWorld(
-          "dispatch(" + command->serialize() + ")",
-          ScriptController::kExecuteScriptWhenScriptsDisabled);
-}
-
-String InspectorOverlayAgent::EvaluateInOverlayForTest(const String& script) {
-  ScriptForbiddenScope::AllowUserAgentScript allow_script;
-  v8::HandleScope handle_scope(ToIsolate(OverlayMainFrame()));
-  v8::Local<v8::Value> string =
-      ToLocalFrame(OverlayPage()->MainFrame())
-          ->GetScriptController()
-          .ExecuteScriptInMainWorldAndReturnValue(
-              ScriptSourceCode(script),
-              ScriptController::kExecuteScriptWhenScriptsDisabled);
-  return ToCoreStringWithUndefinedOrNullCheck(string);
-}
-
-void InspectorOverlayAgent::OnTimer(TimerBase*) {
-  resize_timer_active_ = false;
-  ScheduleUpdate();
-}
-
-void InspectorOverlayAgent::ClearInternal() {
-  if (overlay_page_) {
-    overlay_page_->WillBeDestroyed();
-    overlay_page_.Clear();
-    overlay_chrome_client_.Clear();
-  }
-  resize_timer_active_ = false;
-  paused_in_debugger_message_ = String();
-  inspect_mode_ = kNotSearching;
-  timer_.Stop();
-  InnerHideHighlight();
-}
-
-void InspectorOverlayAgent::OverlayResumed() {
-  if (v8_session_)
-    v8_session_->resume();
-}
-
-void InspectorOverlayAgent::OverlaySteppedOver() {
-  if (v8_session_)
-    v8_session_->stepOver();
-}
-
-void InspectorOverlayAgent::PageLayoutInvalidated(bool resized) {
-  if (resized && draw_view_size_) {
-    resize_timer_active_ = true;
-    timer_.StartOneShot(1, BLINK_FROM_HERE);
-  }
-  ScheduleUpdate();
-}
-
-bool InspectorOverlayAgent::HandleMouseMove(const WebMouseEvent& event) {
-  if (!ShouldSearchForNode())
-    return false;
-
-  LocalFrame* frame = frame_impl_->GetFrame();
-  if (!frame || !frame->View() || frame->ContentLayoutItem().IsNull())
-    return false;
-  Node* node = HoveredNodeForEvent(
-      frame, event, event.GetModifiers() & WebInputEvent::kShiftKey);
-
-  // Do not highlight within user agent shadow root unless requested.
-  if (inspect_mode_ != kSearchingForUAShadow) {
-    ShadowRoot* shadow_root = InspectorDOMAgent::UserAgentShadowRoot(node);
-    if (shadow_root)
-      node = &shadow_root->host();
-  }
-
-  // Shadow roots don't have boxes - use host element instead.
-  if (node && node->IsShadowRoot())
-    node = node->ParentOrShadowHostNode();
-
-  if (!node)
-    return true;
-
-  if (node->IsFrameOwnerElement()) {
-    HTMLFrameOwnerElement* frame_owner = ToHTMLFrameOwnerElement(node);
-    if (frame_owner->ContentFrame() &&
-        !frame_owner->ContentFrame()->IsLocalFrame()) {
-      // Do not consume event so that remote frame can handle it.
-      InnerHideHighlight();
-      hovered_node_for_inspect_mode_.Clear();
-      return false;
-    }
-  }
-
-  Node* event_target = (event.GetModifiers() & WebInputEvent::kShiftKey)
-                           ? HoveredNodeForEvent(frame, event, false)
-                           : nullptr;
-  if (event_target == node)
-    event_target = nullptr;
-
-  if (node && inspect_mode_highlight_config_) {
-    hovered_node_for_inspect_mode_ = node;
-    NodeHighlightRequested(node);
-    bool omit_tooltip = event.GetModifiers() &
-                        (WebInputEvent::kControlKey | WebInputEvent::kMetaKey);
-    InnerHighlightNode(node, event_target, *inspect_mode_highlight_config_,
-                       omit_tooltip);
-  }
-  return true;
-}
-
-bool InspectorOverlayAgent::HandleMouseDown() {
-  swallow_next_mouse_up_ = false;
-  if (!ShouldSearchForNode())
-    return false;
-
-  if (hovered_node_for_inspect_mode_) {
-    swallow_next_mouse_up_ = true;
-    Inspect(hovered_node_for_inspect_mode_.Get());
-    hovered_node_for_inspect_mode_.Clear();
-    return true;
-  }
-  return false;
-}
-
-bool InspectorOverlayAgent::HandleMouseUp() {
-  if (swallow_next_mouse_up_) {
-    swallow_next_mouse_up_ = false;
-    return true;
-  }
-  return false;
-}
-
-bool InspectorOverlayAgent::HandleGestureEvent(const WebGestureEvent& event) {
-  if (!ShouldSearchForNode() || event.GetType() != WebInputEvent::kGestureTap)
-    return false;
-  Node* node = HoveredNodeForEvent(frame_impl_->GetFrame(), event, false);
-  if (node && inspect_mode_highlight_config_) {
-    InnerHighlightNode(node, nullptr, *inspect_mode_highlight_config_, false);
-    Inspect(node);
-    return true;
-  }
-  return false;
-}
-
-bool InspectorOverlayAgent::HandleTouchEvent(const WebTouchEvent& event) {
-  if (!ShouldSearchForNode())
-    return false;
-  Node* node = HoveredNodeForEvent(frame_impl_->GetFrame(), event, false);
-  if (node && inspect_mode_highlight_config_) {
-    InnerHighlightNode(node, nullptr, *inspect_mode_highlight_config_, false);
-    Inspect(node);
-    return true;
-  }
-  return false;
-}
-
-Response InspectorOverlayAgent::CompositingEnabled() {
-  bool main_frame = frame_impl_->ViewImpl() && !frame_impl_->Parent();
-  if (!main_frame || !frame_impl_->ViewImpl()
-                          ->GetPage()
-                          ->GetSettings()
-                          .GetAcceleratedCompositingEnabled())
-    return Response::Error("Compositing mode is not supported");
-  return Response::OK();
-}
-
-bool InspectorOverlayAgent::ShouldSearchForNode() {
-  return inspect_mode_ != kNotSearching;
-}
-
-void InspectorOverlayAgent::Inspect(Node* inspected_node) {
-  if (!inspected_node)
-    return;
-
-  Node* node = inspected_node;
-  while (node && !node->IsElementNode() && !node->IsDocumentNode() &&
-         !node->IsDocumentFragment())
-    node = node->ParentOrShadowHostNode();
-  if (!node)
-    return;
-
-  int backend_node_id = DOMNodeIds::IdForNode(node);
-  if (!enabled_) {
-    backend_node_id_to_inspect_ = backend_node_id;
-    return;
-  }
-
-  GetFrontend()->inspectNodeRequested(backend_node_id);
-}
-
-void InspectorOverlayAgent::NodeHighlightRequested(Node* node) {
-  if (!enabled_)
-    return;
-
-  while (node && !node->IsElementNode() && !node->IsDocumentNode() &&
-         !node->IsDocumentFragment())
-    node = node->ParentOrShadowHostNode();
-
-  if (!node)
-    return;
-
-  int node_id = dom_agent_->PushNodePathToFrontend(node);
-  GetFrontend()->nodeHighlightRequested(node_id);
-}
-
-Response InspectorOverlayAgent::SetSearchingForNode(
-    SearchMode search_mode,
-    Maybe<protocol::Overlay::HighlightConfig> highlight_inspector_object) {
-  if (search_mode == kNotSearching) {
-    inspect_mode_ = search_mode;
-    ScheduleUpdate();
-    hovered_node_for_inspect_mode_.Clear();
-    InnerHideHighlight();
-    return Response::OK();
-  }
-
-  std::unique_ptr<InspectorHighlightConfig> config;
-  Response response = HighlightConfigFromInspectorObject(
-      std::move(highlight_inspector_object), &config);
-  if (!response.isSuccess())
-    return response;
-  inspect_mode_ = search_mode;
-  inspect_mode_highlight_config_ = std::move(config);
-  ScheduleUpdate();
-  return Response::OK();
-}
-
-Response InspectorOverlayAgent::HighlightConfigFromInspectorObject(
-    Maybe<protocol::Overlay::HighlightConfig> highlight_inspector_object,
-    std::unique_ptr<InspectorHighlightConfig>* out_config) {
-  if (!highlight_inspector_object.isJust()) {
-    return Response::Error(
-        "Internal error: highlight configuration parameter is missing");
-  }
-
-  protocol::Overlay::HighlightConfig* config =
-      highlight_inspector_object.fromJust();
-  std::unique_ptr<InspectorHighlightConfig> highlight_config =
-      WTF::MakeUnique<InspectorHighlightConfig>();
-  highlight_config->show_info = config->getShowInfo(false);
-  highlight_config->show_rulers = config->getShowRulers(false);
-  highlight_config->show_extension_lines = config->getShowExtensionLines(false);
-  highlight_config->display_as_material = config->getDisplayAsMaterial(false);
-  highlight_config->content =
-      InspectorDOMAgent::ParseColor(config->getContentColor(nullptr));
-  highlight_config->padding =
-      InspectorDOMAgent::ParseColor(config->getPaddingColor(nullptr));
-  highlight_config->border =
-      InspectorDOMAgent::ParseColor(config->getBorderColor(nullptr));
-  highlight_config->margin =
-      InspectorDOMAgent::ParseColor(config->getMarginColor(nullptr));
-  highlight_config->event_target =
-      InspectorDOMAgent::ParseColor(config->getEventTargetColor(nullptr));
-  highlight_config->shape =
-      InspectorDOMAgent::ParseColor(config->getShapeColor(nullptr));
-  highlight_config->shape_margin =
-      InspectorDOMAgent::ParseColor(config->getShapeMarginColor(nullptr));
-  highlight_config->selector_list = config->getSelectorList("");
-
-  *out_config = std::move(highlight_config);
-  return Response::OK();
-}
-
-}  // namespace blink