Devtools: Rename InspectorOverlayImpl to InspectorOverlay

Source/web/InspectorOverlay.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 "config.h"
-#include "web/InspectorOverlayImpl.h"
+#include "web/InspectorOverlay.h"
 
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/V8InspectorOverlayHost.h"
 #include "core/dom/Node.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/InspectorCSSAgent.h"
@@ skipping 47 matching lines @@
 
 Node* hoveredNodeForEvent(LocalFrame* frame, const PlatformTouchEvent& event, bool ignorePointerEventsNone)
 {
     const Vector<PlatformTouchPoint>& points = event.touchPoints();
     if (!points.size())
         return nullptr;
     return hoveredNodeForPoint(frame, roundedIntPoint(points[0].pos()), ignorePointerEventsNone);
 }
 } // namespace
 
-class InspectorOverlayImpl::InspectorPageOverlayDelegate final : public PageOverlay::Delegate {
+class InspectorOverlay::InspectorPageOverlayDelegate final : public PageOverlay::Delegate {
 public:
-    explicit InspectorPageOverlayDelegate(InspectorOverlayImpl& overlay)
+    explicit InspectorPageOverlayDelegate(InspectorOverlay& overlay)
         : m_overlay(&overlay)
     { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_overlay);
         PageOverlay::Delegate::trace(visitor);
     }
 
     void paintPageOverlay(WebGraphicsContext* context, const WebSize& webViewSize)
     {
         if (m_overlay->isEmpty())
             return;
 
         GraphicsContext& graphicsContext = toWebGraphicsContextImpl(context)->graphicsContext();
         FrameView* view = m_overlay->overlayMainFrame()->view();
         ASSERT(!view->needsLayout());
         view->paint(&graphicsContext, IntRect(0, 0, view->width(), view->height()));
     }
 
 private:
-    RawPtrWillBeMember<InspectorOverlayImpl> m_overlay;
+    RawPtrWillBeMember<InspectorOverlay> m_overlay;
 };
 
 
-class InspectorOverlayImpl::InspectorOverlayChromeClient final : public EmptyChromeClient {
+class InspectorOverlay::InspectorOverlayChromeClient final : public EmptyChromeClient {
 public:
-    static PassOwnPtrWillBeRawPtr<InspectorOverlayChromeClient> create(ChromeClient& client, InspectorOverlayImpl& overlay)
+    static PassOwnPtrWillBeRawPtr<InspectorOverlayChromeClient> create(ChromeClient& client, InspectorOverlay& overlay)
     {
         return adoptPtrWillBeNoop(new InspectorOverlayChromeClient(client, overlay));
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_client);
         visitor->trace(m_overlay);
         EmptyChromeClient::trace(visitor);
     }
@@ skipping 18 matching lines @@
 
     void scheduleAnimation() override
     {
         if (m_overlay->m_inLayout)
             return;
 
         m_client->scheduleAnimation();
     }
 
 private:
-    InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlayImpl& overlay)
+    InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay& overlay)
         : m_client(&client)
         , m_overlay(&overlay)
     { }
 
     RawPtrWillBeMember<ChromeClient> m_client;
-    RawPtrWillBeMember<InspectorOverlayImpl> m_overlay;
+    RawPtrWillBeMember<InspectorOverlay> m_overlay;
 };
 
 
-InspectorOverlayImpl::InspectorOverlayImpl(WebViewImpl* webViewImpl)
+InspectorOverlay::InspectorOverlay(WebViewImpl* webViewImpl)
     : m_webViewImpl(webViewImpl)
     , m_overlayHost(InspectorOverlayHost::create())
     , m_drawViewSize(false)
     , m_drawViewSizeWithGrid(false)
     , m_resizeTimerActive(false)
     , m_omitTooltip(false)
-    , m_timer(this, &InspectorOverlayImpl::onTimer)
+    , m_timer(this, &InspectorOverlay::onTimer)
     , m_suspendCount(0)
     , m_inLayout(false)
     , m_needsUpdate(false)
     , m_inspectMode(InspectorDOMAgent::NotSearching)
 {
 }
 
-InspectorOverlayImpl::~InspectorOverlayImpl()
+InspectorOverlay::~InspectorOverlay()
 {
     ASSERT(!m_overlayPage);
 }
 
-DEFINE_TRACE(InspectorOverlayImpl)
+DEFINE_TRACE(InspectorOverlay)
 {
     visitor->trace(m_highlightNode);
     visitor->trace(m_eventTargetNode);
     visitor->trace(m_overlayPage);
     visitor->trace(m_overlayChromeClient);
     visitor->trace(m_overlayHost);
     visitor->trace(m_debuggerAgent);
     visitor->trace(m_domAgent);
     visitor->trace(m_cssAgent);
     visitor->trace(m_layoutEditor);
     visitor->trace(m_hoveredNodeForInspectMode);
 }
 
-void InspectorOverlayImpl::init(InspectorCSSAgent* cssAgent, InspectorDebuggerAgent* debuggerAgent, InspectorDOMAgent* domAgent)
+void InspectorOverlay::init(InspectorCSSAgent* cssAgent, InspectorDebuggerAgent* debuggerAgent, InspectorDOMAgent* domAgent)
 {
     m_debuggerAgent = debuggerAgent;
     m_domAgent = domAgent;
     m_cssAgent = cssAgent;
     m_overlayHost->setListener(this);
 }
 
-void InspectorOverlayImpl::invalidate()
+void InspectorOverlay::invalidate()
 {
     if (!m_pageOverlay)
         m_pageOverlay = PageOverlay::create(m_webViewImpl, new InspectorPageOverlayDelegate(*this));
 
     m_pageOverlay->update();
 }
 
-void InspectorOverlayImpl::layout()
+void InspectorOverlay::layout()
 {
     if (isEmpty())
         return;
 
     TemporaryChange<bool> scoped(m_inLayout, true);
     if (m_needsUpdate) {
         m_needsUpdate = false;
         rebuildOverlayPage();
     }
     overlayMainFrame()->view()->updateAllLifecyclePhases();
 }
 
-bool InspectorOverlayImpl::handleInputEvent(const WebInputEvent& inputEvent)
+bool InspectorOverlay::handleInputEvent(const WebInputEvent& inputEvent)
 {
     bool handled = false;
 
     if (isEmpty())
         return false;
 
     if (WebInputEvent::isGestureEventType(inputEvent.type) && inputEvent.type == WebInputEvent::GestureTap) {
         // Only let GestureTab in (we only need it and we know PlatformGestureEventBuilder supports it).
         PlatformGestureEvent gestureEvent = PlatformGestureEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebGestureEvent&>(inputEvent));
         handled = handleGestureEvent(gestureEvent);
@@ skipping 35 matching lines @@
     }
 
     if (inputEvent.type == WebInputEvent::MouseWheel) {
         PlatformWheelEvent wheelEvent = PlatformWheelEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebMouseWheelEvent&>(inputEvent));
         handled = overlayMainFrame()->eventHandler().handleWheelEvent(wheelEvent);
     }
 
     return handled;
 }
 
-void InspectorOverlayImpl::setPausedInDebuggerMessage(const String* message)
+void InspectorOverlay::setPausedInDebuggerMessage(const String* message)
 {
     m_pausedInDebuggerMessage = message ? *message : String();
     scheduleUpdate();
 }
 
-void InspectorOverlayImpl::hideHighlight()
+void InspectorOverlay::hideHighlight()
 {
     m_highlightNode.clear();
     m_eventTargetNode.clear();
     m_highlightQuad.clear();
 
     if (m_layoutEditor && m_inspectModeHighlightConfig)
         highlightNode(m_layoutEditor->element(), *m_inspectModeHighlightConfig, false);
     else
         scheduleUpdate();
 }
 
-void InspectorOverlayImpl::highlightNode(Node* node, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
+void InspectorOverlay::highlightNode(Node* node, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
 {
     highlightNode(node, nullptr, highlightConfig, omitTooltip);
 }
 
-void InspectorOverlayImpl::highlightNode(Node* node, Node* eventTarget, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
+void InspectorOverlay::highlightNode(Node* node, Node* eventTarget, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
 {
     m_nodeHighlightConfig = highlightConfig;
     m_highlightNode = node;
     m_eventTargetNode = eventTarget;
     m_omitTooltip = omitTooltip;
     scheduleUpdate();
 }
 
-void InspectorOverlayImpl::setInspectMode(InspectorDOMAgent::SearchMode searchMode, PassOwnPtr<InspectorHighlightConfig> highlightConfig)
+void InspectorOverlay::setInspectMode(InspectorDOMAgent::SearchMode searchMode, PassOwnPtr<InspectorHighlightConfig> highlightConfig)
 {
     if (m_layoutEditor)
         overlayClearSelection(true);
 
     m_inspectMode = searchMode;
     scheduleUpdate();
 
     if (searchMode != InspectorDOMAgent::NotSearching) {
         m_inspectModeHighlightConfig = highlightConfig;
     } else {
         m_hoveredNodeForInspectMode.clear();
         hideHighlight();
     }
 }
 
-void InspectorOverlayImpl::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
+void InspectorOverlay::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
 {
     m_quadHighlightConfig = highlightConfig;
     m_highlightQuad = quad;
     m_omitTooltip = false;
     scheduleUpdate();
 }
 
-bool InspectorOverlayImpl::isEmpty()
+bool InspectorOverlay::isEmpty()
 {
     if (m_suspendCount)
         return true;
     bool hasVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || (m_resizeTimerActive && m_drawViewSize) || !m_pausedInDebuggerMessage.isNull();
     return !hasVisibleElements && m_inspectMode == InspectorDOMAgent::NotSearching;
 }
 
-void InspectorOverlayImpl::scheduleUpdate()
+void InspectorOverlay::scheduleUpdate()
 {
     if (isEmpty()) {
         if (m_pageOverlay)
             m_pageOverlay.clear();
         return;
     }
     m_needsUpdate = true;
     m_webViewImpl->page()->chromeClient().scheduleAnimation();
 }
 
-void InspectorOverlayImpl::rebuildOverlayPage()
+void InspectorOverlay::rebuildOverlayPage()
 {
     FrameView* view = m_webViewImpl->mainFrameImpl()->frameView();
     if (!view)
         return;
 
     IntRect visibleRectInDocument = view->scrollableArea()->visibleContentRect();
     IntSize viewportSize = m_webViewImpl->page()->frameHost().visualViewport().size();
     toLocalFrame(overlayPage()->mainFrame())->view()->resize(viewportSize);
     overlayPage()->frameHost().visualViewport().setSize(viewportSize);
     reset(viewportSize, visibleRectInDocument.location());
 
     drawNodeHighlight();
     drawQuadHighlight();
     drawPausedInDebuggerMessage();
     drawViewSize();
 }
 
 static PassRefPtr<JSONObject> buildObjectForSize(const IntSize& size)
 {
     RefPtr<JSONObject> result = JSONObject::create();
     result->setNumber("width", size.width());
     result->setNumber("height", size.height());
     return result.release();
 }
 
-void InspectorOverlayImpl::drawNodeHighlight()
+void InspectorOverlay::drawNodeHighlight()
 {
     if (!m_highlightNode)
         return;
 
     bool appendElementInfo = m_highlightNode->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && m_highlightNode->layoutObject() && m_highlightNode->document().frame();
     InspectorHighlight highlight(m_highlightNode.get(), m_nodeHighlightConfig, appendElementInfo);
     if (m_eventTargetNode)
         highlight.appendEventTargetQuads(m_eventTargetNode.get(), m_nodeHighlightConfig);
 
     RefPtr<JSONObject> highlightJSON = highlight.asJSONObject();
     evaluateInOverlay("drawHighlight", highlightJSON.release());
     if (m_layoutEditor && m_highlightNode == m_layoutEditor->element()) {
         RefPtr<JSONObject> layoutEditorInfo = m_layoutEditor->buildJSONInfo();
         if (layoutEditorInfo)
             evaluateInOverlay("showLayoutEditor", layoutEditorInfo.release());
     }
 }
 
-void InspectorOverlayImpl::drawQuadHighlight()
+void InspectorOverlay::drawQuadHighlight()
 {
     if (!m_highlightQuad)
         return;
 
     InspectorHighlight highlight;
     highlight.appendQuad(*m_highlightQuad, m_quadHighlightConfig.content, m_quadHighlightConfig.contentOutline);
     evaluateInOverlay("drawHighlight", highlight.asJSONObject());
 }
 
-void InspectorOverlayImpl::drawPausedInDebuggerMessage()
+void InspectorOverlay::drawPausedInDebuggerMessage()
 {
     if (m_inspectMode == InspectorDOMAgent::NotSearching && !m_pausedInDebuggerMessage.isNull())
         evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
 }
 
-void InspectorOverlayImpl::drawViewSize()
+void InspectorOverlay::drawViewSize()
 {
     if (m_resizeTimerActive && m_drawViewSize)
         evaluateInOverlay("drawViewSize", m_drawViewSizeWithGrid ? "true" : "false");
 }
 
-Page* InspectorOverlayImpl::overlayPage()
+Page* InspectorOverlay::overlayPage()
 {
     if (m_overlayPage)
         return m_overlayPage.get();
 
     ScriptForbiddenScope::AllowUserAgentScript allowScript;
 
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<FrameLoaderClient>, dummyFrameLoaderClient, (EmptyFrameLoaderClient::create()));
     Page::PageClients pageClients;
     fillWithEmptyClients(pageClients);
     ASSERT(!m_overlayChromeClient);
@@ skipping 43 matching lines @@
     evaluateInOverlay("setPlatform", "windows");
 #elif OS(MACOSX)
     evaluateInOverlay("setPlatform", "mac");
 #elif OS(POSIX)
     evaluateInOverlay("setPlatform", "linux");
 #endif
 
     return m_overlayPage.get();
 }
 
-LocalFrame* InspectorOverlayImpl::overlayMainFrame()
+LocalFrame* InspectorOverlay::overlayMainFrame()
 {
     return toLocalFrame(overlayPage()->mainFrame());
 }
 
-void InspectorOverlayImpl::reset(const IntSize& viewportSize, const IntPoint& documentScrollOffset)
+void InspectorOverlay::reset(const IntSize& viewportSize, const IntPoint& documentScrollOffset)
 {
     RefPtr<JSONObject> resetData = JSONObject::create();
     resetData->setNumber("deviceScaleFactor", m_webViewImpl->page()->deviceScaleFactor());
     resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
     resetData->setNumber("pageZoomFactor", m_webViewImpl->mainFrameImpl()->frame()->pageZoomFactor());
     resetData->setNumber("scrollX", documentScrollOffset.x());
     resetData->setNumber("scrollY", documentScrollOffset.y());
     evaluateInOverlay("reset", resetData.release());
 }
 
-void InspectorOverlayImpl::evaluateInOverlay(const String& method, const String& argument)
+void InspectorOverlay::evaluateInOverlay(const String& method, const String& argument)
 {
     ScriptForbiddenScope::AllowUserAgentScript allowScript;
     RefPtr<JSONArray> command = JSONArray::create();
     command->pushString(method);
     command->pushString(argument);
     toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorld("dispatch(" + command->toJSONString() + ")", ScriptController::ExecuteScriptWhenScriptsDisabled);
 }
 
-void InspectorOverlayImpl::evaluateInOverlay(const String& method, PassRefPtr<JSONValue> argument)
+void InspectorOverlay::evaluateInOverlay(const String& method, PassRefPtr<JSONValue> argument)
 {
     ScriptForbiddenScope::AllowUserAgentScript allowScript;
     RefPtr<JSONArray> command = JSONArray::create();
     command->pushString(method);
     command->pushValue(argument);
     toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorld("dispatch(" + command->toJSONString() + ")", ScriptController::ExecuteScriptWhenScriptsDisabled);
 }
 
-void InspectorOverlayImpl::onTimer(Timer<InspectorOverlayImpl>*)
+void InspectorOverlay::onTimer(Timer<InspectorOverlay>*)
 {
     m_resizeTimerActive = false;
     scheduleUpdate();
 }
 
-void InspectorOverlayImpl::clear()
+void InspectorOverlay::clear()
 {
     if (m_overlayPage) {
         m_overlayPage->willBeDestroyed();
         m_overlayPage.clear();
         m_overlayChromeClient.clear();
     }
     m_resizeTimerActive = false;
     m_pausedInDebuggerMessage = String();
     m_inspectMode = InspectorDOMAgent::NotSearching;
     m_timer.stop();
     hideHighlight();
 }
 
-void InspectorOverlayImpl::overlayResumed()
+void InspectorOverlay::overlayResumed()
 {
     if (m_debuggerAgent) {
         ErrorString error;
         m_debuggerAgent->resume(&error);
     }
 }
 
-void InspectorOverlayImpl::overlaySteppedOver()
+void InspectorOverlay::overlaySteppedOver()
 {
     if (m_debuggerAgent) {
         ErrorString error;
         m_debuggerAgent->stepOver(&error);
     }
 }
 
-void InspectorOverlayImpl::overlayStartedPropertyChange(const String& property)
+void InspectorOverlay::overlayStartedPropertyChange(const String& property)
 {
     ASSERT(m_layoutEditor);
     m_layoutEditor->overlayStartedPropertyChange(property);
 }
 
-void InspectorOverlayImpl::overlayPropertyChanged(float value)
+void InspectorOverlay::overlayPropertyChanged(float value)
 {
     ASSERT(m_layoutEditor);
     m_layoutEditor->overlayPropertyChanged(value);
 }
 
-void InspectorOverlayImpl::overlayEndedPropertyChange()
+void InspectorOverlay::overlayEndedPropertyChange()
 {
     ASSERT(m_layoutEditor);
     m_layoutEditor->overlayEndedPropertyChange();
 }
 
-void InspectorOverlayImpl::overlayNextSelector()
+void InspectorOverlay::overlayNextSelector()
 {
     ASSERT(m_layoutEditor);
     m_layoutEditor->nextSelector();
 }
 
-void InspectorOverlayImpl::overlayPreviousSelector()
+void InspectorOverlay::overlayPreviousSelector()
 {
     ASSERT(m_layoutEditor);
     m_layoutEditor->previousSelector();
 }
 
-String InspectorOverlayImpl::overlayCurrentSelectorInfo()
+String InspectorOverlay::overlayCurrentSelectorInfo()
 {
     ASSERT(m_layoutEditor);
     return m_layoutEditor->currentSelectorInfo();
 }
 
-void InspectorOverlayImpl::overlayClearSelection(bool commitChanges)
+void InspectorOverlay::overlayClearSelection(bool commitChanges)
 {
     ASSERT(m_layoutEditor);
     m_hoveredNodeForInspectMode = m_layoutEditor->element();
 
     if (commitChanges)
         m_layoutEditor->commitChanges();
 
     if (m_layoutEditor) {
         m_layoutEditor->dispose();
         m_layoutEditor.clear();
     }
 
     if (m_inspectModeHighlightConfig)
         highlightNode(m_hoveredNodeForInspectMode.get(), *m_inspectModeHighlightConfig, false);
 
     toChromeClientImpl(m_webViewImpl->page()->chromeClient()).setCursorOverridden(false);
     toChromeClientImpl(m_webViewImpl->page()->chromeClient()).setCursor(pointerCursor());
 }
 
-void InspectorOverlayImpl::profilingStarted()
+void InspectorOverlay::profilingStarted()
 {
     if (!m_suspendCount++)
         clear();
 }
 
-void InspectorOverlayImpl::profilingStopped()
+void InspectorOverlay::profilingStopped()
 {
     --m_suspendCount;
 }
 
-void InspectorOverlayImpl::pageLayoutInvalidated(bool resized)
+void InspectorOverlay::pageLayoutInvalidated(bool resized)
 {
     if (resized && m_drawViewSize) {
         m_resizeTimerActive = true;
         m_timer.startOneShot(1, FROM_HERE);
     }
     scheduleUpdate();
 }
 
-void InspectorOverlayImpl::setShowViewportSizeOnResize(bool show, bool showGrid)
+void InspectorOverlay::setShowViewportSizeOnResize(bool show, bool showGrid)
 {
     m_drawViewSize = show;
     m_drawViewSizeWithGrid = showGrid;
 }
 
-bool InspectorOverlayImpl::handleMouseMove(const PlatformMouseEvent& event)
+bool InspectorOverlay::handleMouseMove(const PlatformMouseEvent& event)
 {
     if (!shouldSearchForNode())
         return false;
 
     LocalFrame* frame = m_webViewImpl->mainFrameImpl()->frame();
     if (!frame->view() || !frame->contentLayoutObject())
         return false;
     Node* node = hoveredNodeForEvent(frame, event, event.shiftKey());
 
     // Do not highlight within user agent shadow root unless requested.
@@ skipping 14 matching lines @@
     if (eventTarget == node)
         eventTarget = nullptr;
 
     if (node && m_inspectModeHighlightConfig) {
         m_hoveredNodeForInspectMode = node;
         highlightNode(node, eventTarget, *m_inspectModeHighlightConfig, event.ctrlKey() || event.metaKey());
     }
     return true;
 }
 
-bool InspectorOverlayImpl::handleMousePress()
+bool InspectorOverlay::handleMousePress()
 {
     if (!shouldSearchForNode())
         return false;
 
     if (m_hoveredNodeForInspectMode) {
         inspect(m_hoveredNodeForInspectMode.get());
         m_hoveredNodeForInspectMode.clear();
         return true;
     }
     return false;
 }
 
-bool InspectorOverlayImpl::handleGestureEvent(const PlatformGestureEvent& event)
+bool InspectorOverlay::handleGestureEvent(const PlatformGestureEvent& event)
 {
     if (!shouldSearchForNode() || event.type() != PlatformEvent::GestureTap)
         return false;
     Node* node = hoveredNodeForEvent(m_webViewImpl->mainFrameImpl()->frame(), event, false);
     if (node && m_inspectModeHighlightConfig) {
         highlightNode(node, *m_inspectModeHighlightConfig, false);
         inspect(node);
         return true;
     }
     return false;
 }
 
-bool InspectorOverlayImpl::handleTouchEvent(const PlatformTouchEvent& event)
+bool InspectorOverlay::handleTouchEvent(const PlatformTouchEvent& event)
 {
     if (!shouldSearchForNode())
         return false;
     Node* node = hoveredNodeForEvent(m_webViewImpl->mainFrameImpl()->frame(), event, false);
     if (node && m_inspectModeHighlightConfig) {
         highlightNode(node, *m_inspectModeHighlightConfig, false);
         inspect(node);
         return true;
     }
     return false;
 }
 
-bool InspectorOverlayImpl::shouldSearchForNode()
+bool InspectorOverlay::shouldSearchForNode()
 {
     return m_inspectMode != InspectorDOMAgent::NotSearching && !m_layoutEditor;
 }
 
-void InspectorOverlayImpl::inspect(Node* node)
+void InspectorOverlay::inspect(Node* node)
 {
     if (m_domAgent)
         m_domAgent->inspect(node);
 
     if (node && node->isElementNode() && m_inspectMode == InspectorDOMAgent::ShowLayoutEditor && !m_layoutEditor) {
         m_layoutEditor = LayoutEditor::create(toElement(node), m_cssAgent, m_domAgent);
         toChromeClientImpl(m_webViewImpl->page()->chromeClient()).setCursorOverridden(true);
         highlightNode(node, *m_inspectModeHighlightConfig, false);
     }
 }
 
 } // namespace blink