diff --git a/Source/web/InspectorOverlayImpl.cpp b/Source/web/InspectorOverlay.cpp
similarity index 86%
rename from Source/web/InspectorOverlayImpl.cpp
rename to Source/web/InspectorOverlay.cpp
index 445213e..5b892f4 100644
--- a/Source/web/InspectorOverlayImpl.cpp
+++ b/Source/web/InspectorOverlay.cpp
@@ -27,7 +27,7 @@
  */
 
 #include "config.h"
-#include "web/InspectorOverlayImpl.h"
+#include "web/InspectorOverlay.h"
 
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/V8InspectorOverlayHost.h"
@@ -95,9 +95,9 @@
 }
 } // 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)
     { }
 
@@ -119,13 +119,13 @@
     }
 
 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));
     }
@@ -164,24 +164,24 @@
     }
 
 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)
@@ -189,12 +189,12 @@
 {
 }
 
-InspectorOverlayImpl::~InspectorOverlayImpl()
+InspectorOverlay::~InspectorOverlay()
 {
     ASSERT(!m_overlayPage);
 }
 
-DEFINE_TRACE(InspectorOverlayImpl)
+DEFINE_TRACE(InspectorOverlay)
 {
     visitor->trace(m_highlightNode);
     visitor->trace(m_eventTargetNode);
@@ -208,7 +208,7 @@
     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;
@@ -216,7 +216,7 @@
     m_overlayHost->setListener(this);
 }
 
-void InspectorOverlayImpl::invalidate()
+void InspectorOverlay::invalidate()
 {
     if (!m_pageOverlay)
         m_pageOverlay = PageOverlay::create(m_webViewImpl, new InspectorPageOverlayDelegate(*this));
@@ -224,7 +224,7 @@
     m_pageOverlay->update();
 }
 
-void InspectorOverlayImpl::layout()
+void InspectorOverlay::layout()
 {
     if (isEmpty())
         return;
@@ -237,7 +237,7 @@
     overlayMainFrame()->view()->updateAllLifecyclePhases();
 }
 
-bool InspectorOverlayImpl::handleInputEvent(const WebInputEvent& inputEvent)
+bool InspectorOverlay::handleInputEvent(const WebInputEvent& inputEvent)
 {
     bool handled = false;
 
@@ -293,13 +293,13 @@
     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();
@@ -311,12 +311,12 @@
         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;
@@ -325,7 +325,7 @@
     scheduleUpdate();
 }
 
-void InspectorOverlayImpl::setInspectMode(InspectorDOMAgent::SearchMode searchMode, PassOwnPtr<InspectorHighlightConfig> highlightConfig)
+void InspectorOverlay::setInspectMode(InspectorDOMAgent::SearchMode searchMode, PassOwnPtr<InspectorHighlightConfig> highlightConfig)
 {
     if (m_layoutEditor)
         overlayClearSelection(true);
@@ -341,7 +341,7 @@
     }
 }
 
-void InspectorOverlayImpl::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
+void InspectorOverlay::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
 {
     m_quadHighlightConfig = highlightConfig;
     m_highlightQuad = quad;
@@ -349,7 +349,7 @@
     scheduleUpdate();
 }
 
-bool InspectorOverlayImpl::isEmpty()
+bool InspectorOverlay::isEmpty()
 {
     if (m_suspendCount)
         return true;
@@ -357,7 +357,7 @@
     return !hasVisibleElements && m_inspectMode == InspectorDOMAgent::NotSearching;
 }
 
-void InspectorOverlayImpl::scheduleUpdate()
+void InspectorOverlay::scheduleUpdate()
 {
     if (isEmpty()) {
         if (m_pageOverlay)
@@ -368,7 +368,7 @@
     m_webViewImpl->page()->chromeClient().scheduleAnimation();
 }
 
-void InspectorOverlayImpl::rebuildOverlayPage()
+void InspectorOverlay::rebuildOverlayPage()
 {
     FrameView* view = m_webViewImpl->mainFrameImpl()->frameView();
     if (!view)
@@ -394,7 +394,7 @@
     return result.release();
 }
 
-void InspectorOverlayImpl::drawNodeHighlight()
+void InspectorOverlay::drawNodeHighlight()
 {
     if (!m_highlightNode)
         return;
@@ -413,7 +413,7 @@
     }
 }
 
-void InspectorOverlayImpl::drawQuadHighlight()
+void InspectorOverlay::drawQuadHighlight()
 {
     if (!m_highlightQuad)
         return;
@@ -423,19 +423,19 @@
     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();
@@ -499,12 +499,12 @@
     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());
@@ -515,7 +515,7 @@
     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();
@@ -524,7 +524,7 @@
     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();
@@ -533,13 +533,13 @@
     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();
@@ -553,7 +553,7 @@
     hideHighlight();
 }
 
-void InspectorOverlayImpl::overlayResumed()
+void InspectorOverlay::overlayResumed()
 {
     if (m_debuggerAgent) {
         ErrorString error;
@@ -561,7 +561,7 @@
     }
 }
 
-void InspectorOverlayImpl::overlaySteppedOver()
+void InspectorOverlay::overlaySteppedOver()
 {
     if (m_debuggerAgent) {
         ErrorString error;
@@ -569,43 +569,43 @@
     }
 }
 
-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();
@@ -625,18 +625,18 @@
     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;
@@ -645,13 +645,13 @@
     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;
@@ -686,7 +686,7 @@
     return true;
 }
 
-bool InspectorOverlayImpl::handleMousePress()
+bool InspectorOverlay::handleMousePress()
 {
     if (!shouldSearchForNode())
         return false;
@@ -699,7 +699,7 @@
     return false;
 }
 
-bool InspectorOverlayImpl::handleGestureEvent(const PlatformGestureEvent& event)
+bool InspectorOverlay::handleGestureEvent(const PlatformGestureEvent& event)
 {
     if (!shouldSearchForNode() || event.type() != PlatformEvent::GestureTap)
         return false;
@@ -712,7 +712,7 @@
     return false;
 }
 
-bool InspectorOverlayImpl::handleTouchEvent(const PlatformTouchEvent& event)
+bool InspectorOverlay::handleTouchEvent(const PlatformTouchEvent& event)
 {
     if (!shouldSearchForNode())
         return false;
@@ -725,12 +725,12 @@
     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);
diff --git a/Source/web/InspectorOverlayImpl.h b/Source/web/InspectorOverlay.h
similarity index 90%
rename from Source/web/InspectorOverlayImpl.h
rename to Source/web/InspectorOverlay.h
index 57a4ed2..c1edacd 100644
--- a/Source/web/InspectorOverlayImpl.h
+++ b/Source/web/InspectorOverlay.h
@@ -26,8 +26,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef InspectorOverlayImpl_h
-#define InspectorOverlayImpl_h
+#ifndef InspectorOverlay_h
+#define InspectorOverlay_h
 
 #include "core/InspectorTypeBuilder.h"
 #include "core/inspector/InspectorDOMAgent.h"
@@ -61,21 +61,21 @@
 class PageOverlay;
 class WebViewImpl;
 
-class InspectorOverlayImpl final
-    : public NoBaseWillBeGarbageCollectedFinalized<InspectorOverlayImpl>
+class InspectorOverlay final
+    : public NoBaseWillBeGarbageCollectedFinalized<InspectorOverlay>
     , public InspectorDOMAgent::Client
     , public InspectorPageAgent::Client
     , public InspectorProfilerAgent::Client
     , public InspectorOverlayHost::Listener {
-    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(InspectorOverlayImpl);
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(InspectorOverlayImpl);
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(InspectorOverlay);
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(InspectorOverlay);
 public:
-    static PassOwnPtrWillBeRawPtr<InspectorOverlayImpl> create(WebViewImpl* webViewImpl)
+    static PassOwnPtrWillBeRawPtr<InspectorOverlay> create(WebViewImpl* webViewImpl)
     {
-        return adoptPtrWillBeNoop(new InspectorOverlayImpl(webViewImpl));
+        return adoptPtrWillBeNoop(new InspectorOverlay(webViewImpl));
     }
 
-    ~InspectorOverlayImpl() override;
+    ~InspectorOverlay() override;
     DECLARE_TRACE();
 
     void init(InspectorCSSAgent*, InspectorDebuggerAgent*, InspectorDOMAgent*);
@@ -86,7 +86,7 @@
     PageOverlay* pageOverlay() { return m_pageOverlay.get(); };
 
 private:
-    explicit InspectorOverlayImpl(WebViewImpl*);
+    explicit InspectorOverlay(WebViewImpl*);
     class InspectorOverlayChromeClient;
     class InspectorPageOverlayDelegate;
 
@@ -128,7 +128,7 @@
     void reset(const IntSize& viewportSize, const IntPoint& documentScrollOffset);
     void evaluateInOverlay(const String& method, const String& argument);
     void evaluateInOverlay(const String& method, PassRefPtr<JSONValue> argument);
-    void onTimer(Timer<InspectorOverlayImpl>*);
+    void onTimer(Timer<InspectorOverlay>*);
     void rebuildOverlayPage();
     void invalidate();
     void scheduleUpdate();
@@ -154,7 +154,7 @@
     bool m_drawViewSizeWithGrid;
     bool m_resizeTimerActive;
     bool m_omitTooltip;
-    Timer<InspectorOverlayImpl> m_timer;
+    Timer<InspectorOverlay> m_timer;
     int m_suspendCount;
     bool m_inLayout;
     bool m_needsUpdate;
@@ -171,4 +171,4 @@
 } // namespace blink
 
 
-#endif // InspectorOverlayImpl_h
+#endif // InspectorOverlay_h
diff --git a/Source/web/WebDevToolsAgentImpl.cpp b/Source/web/WebDevToolsAgentImpl.cpp
index 5be0482..49662c0 100644
--- a/Source/web/WebDevToolsAgentImpl.cpp
+++ b/Source/web/WebDevToolsAgentImpl.cpp
@@ -93,7 +93,7 @@
 #include "public/web/WebSettings.h"
 #include "web/DevToolsEmulator.h"
 #include "web/InspectorEmulationAgent.h"
-#include "web/InspectorOverlayImpl.h"
+#include "web/InspectorOverlay.h"
 #include "web/InspectorRenderingAgent.h"
 #include "web/WebFrameWidgetImpl.h"
 #include "web/WebInputEventConversion.h"
@@ -289,7 +289,7 @@
         return adoptPtrWillBeNoop(agent);
     }
 
-    WebDevToolsAgentImpl* agent = new WebDevToolsAgentImpl(frame, client, InspectorOverlayImpl::create(view));
+    WebDevToolsAgentImpl* agent = new WebDevToolsAgentImpl(frame, client, InspectorOverlay::create(view));
     agent->registerAgent(InspectorRenderingAgent::create(view));
     agent->registerAgent(InspectorEmulationAgent::create(view));
     // TODO(dgozman): migrate each of the following agents to frame once module is ready.
@@ -307,7 +307,7 @@
 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
     WebLocalFrameImpl* webLocalFrameImpl,
     WebDevToolsAgentClient* client,
-    PassOwnPtrWillBeRawPtr<InspectorOverlayImpl> overlay)
+    PassOwnPtrWillBeRawPtr<InspectorOverlay> overlay)
     : m_client(client)
     , m_webLocalFrameImpl(webLocalFrameImpl)
     , m_attached(false)
diff --git a/Source/web/WebDevToolsAgentImpl.h b/Source/web/WebDevToolsAgentImpl.h
index 8c8feac..d90da8e 100644
--- a/Source/web/WebDevToolsAgentImpl.h
+++ b/Source/web/WebDevToolsAgentImpl.h
@@ -48,7 +48,7 @@
 class DebuggerTask;
 class GraphicsLayer;
 class InspectorInspectorAgent;
-class InspectorOverlayImpl;
+class InspectorOverlay;
 class InspectorPageAgent;
 class InspectorResourceContentLoader;
 class LocalFrame;
@@ -82,7 +82,7 @@
 
     void willBeDestroyed();
     WebDevToolsAgentClient* client() { return m_client; }
-    InspectorOverlayImpl* overlay() const { return m_overlay.get(); }
+    InspectorOverlay* overlay() const { return m_overlay.get(); }
     void flushPendingProtocolNotifications();
     void dispatchMessageFromFrontend(const String& message);
     void registerAgent(PassOwnPtrWillBeRawPtr<InspectorAgent>);
@@ -106,7 +106,7 @@
     void evaluateInWebInspector(long callId, const WebString& script) override;
 
 private:
-    WebDevToolsAgentImpl(WebLocalFrameImpl*, WebDevToolsAgentClient*, PassOwnPtrWillBeRawPtr<InspectorOverlayImpl>);
+    WebDevToolsAgentImpl(WebLocalFrameImpl*, WebDevToolsAgentClient*, PassOwnPtrWillBeRawPtr<InspectorOverlay>);
 
     // InspectorStateClient implementation.
     void updateInspectorStateCookie(const WTF::String&) override;
@@ -140,7 +140,7 @@
     OwnPtrWillBeMember<InjectedScriptManager> m_injectedScriptManager;
     OwnPtrWillBeMember<InspectorResourceContentLoader> m_resourceContentLoader;
     OwnPtrWillBeMember<InspectorCompositeState> m_state;
-    OwnPtrWillBeMember<InspectorOverlayImpl> m_overlay;
+    OwnPtrWillBeMember<InspectorOverlay> m_overlay;
 
     RawPtrWillBeMember<InspectorInspectorAgent> m_inspectorAgent;
     RawPtrWillBeMember<InspectorDOMAgent> m_domAgent;
diff --git a/Source/web/WebViewImpl.cpp b/Source/web/WebViewImpl.cpp
index d8969fa..c8b541f 100644
--- a/Source/web/WebViewImpl.cpp
+++ b/Source/web/WebViewImpl.cpp
@@ -155,7 +155,7 @@
 #include "web/DevToolsEmulator.h"
 #include "web/FullscreenController.h"
 #include "web/GraphicsLayerFactoryChromium.h"
-#include "web/InspectorOverlayImpl.h"
+#include "web/InspectorOverlay.h"
 #include "web/LinkHighlightImpl.h"
 #include "web/PageOverlay.h"
 #include "web/PrerendererClientImpl.h"
@@ -497,10 +497,10 @@
     return mainFrame ? mainFrame->devToolsAgentImpl() : nullptr;
 }
 
-InspectorOverlayImpl* WebViewImpl::inspectorOverlay()
+InspectorOverlay* WebViewImpl::inspectorOverlay()
 {
     if (WebDevToolsAgentImpl* devtools = mainFrameDevToolsAgentImpl())
-        return static_cast<InspectorOverlayImpl*>(devtools->overlay());
+        return devtools->overlay();
     return nullptr;
 }
 
@@ -1901,7 +1901,7 @@
 
     PageWidgetDelegate::layout(*m_page, *mainFrameImpl()->frame());
     updateLayerTreeBackgroundColor();
-    if (InspectorOverlayImpl* overlay = inspectorOverlay())
+    if (InspectorOverlay* overlay = inspectorOverlay())
         overlay->layout();
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->updateGeometry();
@@ -2086,7 +2086,7 @@
     if (m_devToolsEmulator->handleInputEvent(inputEvent))
         return true;
 
-    if (InspectorOverlayImpl* overlay = inspectorOverlay()) {
+    if (InspectorOverlay* overlay = inspectorOverlay()) {
         if (overlay->handleInputEvent(inputEvent))
             return true;
     }
@@ -4437,7 +4437,7 @@
 {
     if (m_pageColorOverlay)
         m_pageColorOverlay->update();
-    if (InspectorOverlayImpl* overlay = inspectorOverlay()) {
+    if (InspectorOverlay* overlay = inspectorOverlay()) {
         PageOverlay* inspectorPageOverlay = overlay->pageOverlay();
         if (inspectorPageOverlay)
             inspectorPageOverlay->update();
diff --git a/Source/web/WebViewImpl.h b/Source/web/WebViewImpl.h
index 59820ae..0cf600a 100644
--- a/Source/web/WebViewImpl.h
+++ b/Source/web/WebViewImpl.h
@@ -72,7 +72,7 @@
 class DevToolsEmulator;
 class Frame;
 class FullscreenController;
-class InspectorOverlayImpl;
+class InspectorOverlay;
 class LinkHighlightImpl;
 class PageOverlay;
 class PageScaleConstraintsSet;
@@ -525,7 +525,7 @@
     FloatSize elasticOverscroll() const { return m_elasticOverscroll; }
 
 private:
-    InspectorOverlayImpl* inspectorOverlay();
+    InspectorOverlay* inspectorOverlay();
 
     void setPageScaleFactorAndLocation(float, const FloatPoint&);
 
@@ -703,7 +703,7 @@
     // The popup associated with an input/select element.
     RefPtr<WebPagePopupImpl> m_pagePopup;
 
-    OwnPtrWillBePersistent<InspectorOverlayImpl> m_inspectorOverlay;
+    OwnPtrWillBePersistent<InspectorOverlay> m_inspectorOverlay;
     OwnPtrWillBePersistent<DevToolsEmulator> m_devToolsEmulator;
     OwnPtr<PageOverlay> m_pageColorOverlay;
 
diff --git a/Source/web/web.gypi b/Source/web/web.gypi
index e36c2d8..9dc7762 100644
--- a/Source/web/web.gypi
+++ b/Source/web/web.gypi
@@ -47,8 +47,8 @@
       'IndexedDBClientImpl.h',
       'InspectorEmulationAgent.cpp',
       'InspectorEmulationAgent.h',
-      'InspectorOverlayImpl.cpp',
-      'InspectorOverlayImpl.h',
+      'InspectorOverlay.cpp',
+      'InspectorOverlay.h',
       'InspectorRenderingAgent.cpp',
       'InspectorRenderingAgent.h',
       'LinkHighlightImpl.cpp',
