[DevTools] Consolidate overlay-related functionality in Overlay domain

third_party/WebKit/Source/web/InspectorOverlayAgent.cpp

 /*
  * 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/InspectorOverlay.h"
+#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,
@@ skipping 23 matching lines @@
 
 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 InspectorOverlay::InspectorPageOverlayDelegate final
+class InspectorOverlayAgent::InspectorPageOverlayDelegate final
     : public PageOverlay::Delegate {
  public:
-  explicit InspectorPageOverlayDelegate(InspectorOverlay& overlay)
+  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<InspectorOverlay> overlay_;
+  Persistent<InspectorOverlayAgent> overlay_;
 };
 
-class InspectorOverlay::InspectorOverlayChromeClient final
+class InspectorOverlayAgent::InspectorOverlayChromeClient final
     : public EmptyChromeClient {
  public:
   static InspectorOverlayChromeClient* Create(ChromeClient& client,
-                                              InspectorOverlay& overlay) {
+                                              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 {
@@ skipping 13 matching lines @@
   void InvalidateRect(const IntRect&) override { overlay_->Invalidate(); }
 
   void ScheduleAnimation(LocalFrame* frame) override {
     if (overlay_->in_layout_)
       return;
 
     client_->ScheduleAnimation(frame);
   }
 
  private:
-  InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay& overlay)
+  InspectorOverlayChromeClient(ChromeClient& client,
+                               InspectorOverlayAgent& overlay)
       : client_(&client), overlay_(&overlay) {}
 
   Member<ChromeClient> client_;
-  Member<InspectorOverlay> overlay_;
+  Member<InspectorOverlayAgent> overlay_;
 };
 
-InspectorOverlay::InspectorOverlay(WebLocalFrameImpl* frame_impl)
+InspectorOverlayAgent::InspectorOverlayAgent(
+    WebLocalFrameImpl* frame_impl,
+    InspectedFrames* inspected_frames,
+    v8_inspector::V8InspectorSession* v8_session,
+    InspectorDOMAgent* dom_agent)
     : frame_impl_(frame_impl),
-      overlay_host_(InspectorOverlayHost::Create()),
+      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,
-             &InspectorOverlay::OnTimer),
+             &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_(InspectorDOMAgent::kNotSearching) {}
+      inspect_mode_(kNotSearching),
+      backend_node_id_to_inspect_(0) {}
 
-InspectorOverlay::~InspectorOverlay() {
+InspectorOverlayAgent::~InspectorOverlayAgent() {
   DCHECK(!overlay_page_);
 }
 
-DEFINE_TRACE(InspectorOverlay) {
+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_);
-}
-
-void InspectorOverlay::Init(v8_inspector::V8InspectorSession* v8_session,
-                            InspectorDOMAgent* dom_agent) {
-  v8_session_ = v8_session;
-  dom_agent_ = dom_agent;
-  overlay_host_->SetListener(this);
-}
-
-void InspectorOverlay::Invalidate() {
+  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 InspectorOverlay::UpdateAllLifecyclePhases() {
+void InspectorOverlayAgent::UpdateAllLifecyclePhases() {
   if (IsEmpty())
     return;
 
   AutoReset<bool> scoped(&in_layout_, true);
   if (needs_update_) {
     needs_update_ = false;
     RebuildOverlayPage();
   }
   OverlayMainFrame()->View()->UpdateAllLifecyclePhases();
 }
 
-bool InspectorOverlay::HandleInputEvent(const WebInputEvent& input_event) {
+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));
@@ skipping 18 matching lines @@
     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)
+    if (mouse_event.GetType() == WebInputEvent::kMouseDown) {
       handled = OverlayMainFrame()->GetEventHandler().HandleMousePressEvent(
                     mouse_event) != WebInputEventResult::kNotHandled;
-    if (mouse_event.GetType() == WebInputEvent::kMouseUp)
+    }
+    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 InspectorOverlay::SetPausedInDebuggerMessage(const String& message) {
-  paused_in_debugger_message_ = message;
-  ScheduleUpdate();
-}
-
-void InspectorOverlay::ShowReloadingBlanket() {
+void InspectorOverlayAgent::ShowReloadingBlanket() {
   show_reloading_blanket_ = true;
   ScheduleUpdate();
 }
 
-void InspectorOverlay::HideReloadingBlanket() {
+void InspectorOverlayAgent::HideReloadingBlanket() {
   if (!show_reloading_blanket_)
     return;
   show_reloading_blanket_ = false;
   if (suspended_)
     ClearInternal();
   else
     ScheduleUpdate();
 }
 
-void InspectorOverlay::HideHighlight() {
+void InspectorOverlayAgent::InnerHideHighlight() {
   highlight_node_.Clear();
   event_target_node_.Clear();
   highlight_quad_.reset();
   ScheduleUpdate();
 }
 
-void InspectorOverlay::HighlightNode(
-    Node* node,
-    const InspectorHighlightConfig& highlight_config,
-    bool omit_tooltip) {
-  HighlightNode(node, nullptr, highlight_config, omit_tooltip);
-}
-
-void InspectorOverlay::HighlightNode(
+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 InspectorOverlay::SetInspectMode(
-    InspectorDOMAgent::SearchMode search_mode,
-    std::unique_ptr<InspectorHighlightConfig> highlight_config) {
-  inspect_mode_ = search_mode;
-  ScheduleUpdate();
-
-  if (search_mode != InspectorDOMAgent::kNotSearching) {
-    inspect_mode_highlight_config_ = std::move(highlight_config);
-  } else {
-    hovered_node_for_inspect_mode_.Clear();
-    HideHighlight();
-  }
-}
-
-void InspectorOverlay::HighlightQuad(
+void InspectorOverlayAgent::InnerHighlightQuad(
     std::unique_ptr<FloatQuad> quad,
-    const InspectorHighlightConfig& highlight_config) {
-  quad_highlight_config_ = highlight_config;
+    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 InspectorOverlay::IsEmpty() {
+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_ == InspectorDOMAgent::kNotSearching;
+  return !has_visible_elements && inspect_mode_ == kNotSearching;
 }
 
-void InspectorOverlay::ScheduleUpdate() {
+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 InspectorOverlay::RebuildOverlayPage() {
+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);
@@ skipping 13 matching lines @@
 
 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 InspectorOverlay::DrawNodeHighlight() {
+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())
+  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_)
+  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 InspectorOverlay::DrawQuadHighlight() {
+void InspectorOverlayAgent::DrawQuadHighlight() {
   if (!highlight_quad_)
     return;
 
   InspectorHighlight highlight(WindowToViewportScale());
-  highlight.AppendQuad(*highlight_quad_, quad_highlight_config_.content,
-                       quad_highlight_config_.content_outline);
+  highlight.AppendQuad(*highlight_quad_, quad_content_color_,
+                       quad_content_outline_color_);
   EvaluateInOverlay("drawHighlight", highlight.AsProtocolValue());
 }
 
-void InspectorOverlay::DrawPausedInDebuggerMessage() {
-  if (inspect_mode_ == InspectorDOMAgent::kNotSearching &&
-      !paused_in_debugger_message_.IsNull())
+void InspectorOverlayAgent::DrawPausedInDebuggerMessage() {
+  if (inspect_mode_ == kNotSearching && !paused_in_debugger_message_.IsNull()) {
     EvaluateInOverlay("drawPausedInDebuggerMessage",
                       paused_in_debugger_message_);
+  }
 }
 
-void InspectorOverlay::DrawViewSize() {
+void InspectorOverlayAgent::DrawViewSize() {
   if (resize_timer_active_ && draw_view_size_)
     EvaluateInOverlay("drawViewSize", "");
 }
 
-float InspectorOverlay::WindowToViewportScale() const {
+float InspectorOverlayAgent::WindowToViewportScale() const {
   LocalFrame* frame = frame_impl_->GetFrame();
   if (!frame)
     return 1.0f;
   return frame->GetPage()->GetChromeClient().WindowToViewportScalar(1.0f);
 }
 
-Page* InspectorOverlay::OverlayPage() {
+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_);
@@ skipping 59 matching lines @@
   EvaluateInOverlay("setPlatform", "windows");
 #elif OS(MACOSX)
   EvaluateInOverlay("setPlatform", "mac");
 #elif OS(POSIX)
   EvaluateInOverlay("setPlatform", "linux");
 #endif
 
   return overlay_page_.Get();
 }
 
-LocalFrame* InspectorOverlay::OverlayMainFrame() {
+LocalFrame* InspectorOverlayAgent::OverlayMainFrame() {
   return ToLocalFrame(OverlayPage()->MainFrame());
 }
 
-void InspectorOverlay::Reset(const IntSize& viewport_size,
-                             const IntPoint& document_scroll_offset) {
+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 InspectorOverlay::EvaluateInOverlay(const String& method,
-                                         const String& argument) {
+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 InspectorOverlay::EvaluateInOverlay(
+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 InspectorOverlay::EvaluateInOverlayForTest(const String& script) {
+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 InspectorOverlay::OnTimer(TimerBase*) {
+void InspectorOverlayAgent::OnTimer(TimerBase*) {
   resize_timer_active_ = false;
   ScheduleUpdate();
 }
 
-void InspectorOverlay::ClearInternal() {
+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_ = InspectorDOMAgent::kNotSearching;
+  inspect_mode_ = kNotSearching;
   timer_.Stop();
-  HideHighlight();
+  InnerHideHighlight();
 }
 
-void InspectorOverlay::Clear() {
-  ClearInternal();
-  v8_session_ = nullptr;
-  dom_agent_.Clear();
-  overlay_host_->SetListener(nullptr);
-}
-
-void InspectorOverlay::OverlayResumed() {
+void InspectorOverlayAgent::OverlayResumed() {
   if (v8_session_)
     v8_session_->resume();
 }
 
-void InspectorOverlay::OverlaySteppedOver() {
+void InspectorOverlayAgent::OverlaySteppedOver() {
   if (v8_session_)
     v8_session_->stepOver();
 }
 
-void InspectorOverlay::Suspend() {
-  if (!suspended_) {
-    suspended_ = true;
-    ClearInternal();
-  }
-}
-
-void InspectorOverlay::Resume() {
-  suspended_ = false;
-}
-
-void InspectorOverlay::PageLayoutInvalidated(bool resized) {
+void InspectorOverlayAgent::PageLayoutInvalidated(bool resized) {
   if (resized && draw_view_size_) {
     resize_timer_active_ = true;
     timer_.StartOneShot(1, BLINK_FROM_HERE);
   }
   ScheduleUpdate();
 }
 
-void InspectorOverlay::SetShowViewportSizeOnResize(bool show) {
-  draw_view_size_ = show;
-}
-
-bool InspectorOverlay::HandleMouseMove(const WebMouseEvent& event) {
+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_ != InspectorDOMAgent::kSearchingForUAShadow) {
+  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.
-      HideHighlight();
+      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;
-    if (dom_agent_)
-      dom_agent_->NodeHighlightedInOverlay(node);
-    HighlightNode(node, event_target, *inspect_mode_highlight_config_,
-                  (event.GetModifiers() &
-                   (WebInputEvent::kControlKey | WebInputEvent::kMetaKey)));
+    NodeHighlightRequested(node);
+    bool omit_tooltip = event.GetModifiers() &
+                        (WebInputEvent::kControlKey | WebInputEvent::kMetaKey);
+    InnerHighlightNode(node, event_target, *inspect_mode_highlight_config_,
+                       omit_tooltip);
   }
   return true;
 }
 
-bool InspectorOverlay::HandleMouseDown() {
+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 InspectorOverlay::HandleMouseUp() {
+bool InspectorOverlayAgent::HandleMouseUp() {
   if (swallow_next_mouse_up_) {
     swallow_next_mouse_up_ = false;
     return true;
   }
   return false;
 }
 
-bool InspectorOverlay::HandleGestureEvent(const WebGestureEvent& event) {
+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_) {
-    HighlightNode(node, *inspect_mode_highlight_config_, false);
+    InnerHighlightNode(node, nullptr, *inspect_mode_highlight_config_, false);
     Inspect(node);
     return true;
   }
   return false;
 }
 
-bool InspectorOverlay::HandleTouchEvent(const WebTouchEvent& event) {
+bool InspectorOverlayAgent::HandleTouchEvent(const WebTouchEvent& event) {
   if (!ShouldSearchForNode())
     return false;
   Node* node = HoveredNodeForEvent(frame_impl_->GetFrame(), event, false);
   if (node && inspect_mode_highlight_config_) {
-    HighlightNode(node, *inspect_mode_highlight_config_, false);
+    InnerHighlightNode(node, nullptr, *inspect_mode_highlight_config_, false);
     Inspect(node);
     return true;
   }
   return false;
 }
 
-bool InspectorOverlay::ShouldSearchForNode() {
-  return inspect_mode_ != InspectorDOMAgent::kNotSearching;
+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();
 }
 
-void InspectorOverlay::Inspect(Node* node) {
-  if (dom_agent_)
-    dom_agent_->Inspect(node);
+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