Cleanup namespace usage in Source/web/[A-V]*.h

This patch removes unnecessary blink:: prefixes.
Also it merges *namspace blink{}* blocks.

BUG=

Review URL: https://codereview.chromium.org/462613002

git-svn-id: svn://svn.chromium.org/blink/trunk@179959 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/web/AssociatedURLLoader.h

@@ -37,10 +37,9 @@
 #include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 
-namespace blink { class DocumentThreadableLoader; }
-
 namespace blink {
 
+class DocumentThreadableLoader;
 class WebLocalFrameImpl;
 
 // This class is used to implement WebFrame::createAssociatedURLLoader.
@@ -64,7 +63,7 @@ private:
     WebURLLoaderOptions m_options;
     WebURLLoaderClient* m_client;
     OwnPtr<ClientAdapter> m_clientAdapter;
-    RefPtr<blink::DocumentThreadableLoader> m_loader;
+    RefPtr<DocumentThreadableLoader> m_loader;
 };
 
 } // namespace blink

third_party/WebKit/Source/web/DateTimeChooserImpl.h

@@ -35,40 +35,37 @@
 #include "core/page/PagePopupClient.h"
 #include "platform/DateTimeChooser.h"
 
-namespace blink {
-class PagePopup;
-class DateTimeChooserClient;
-}
-
 namespace blink {
 
 class ChromeClientImpl;
+class DateTimeChooserClient;
+class PagePopup;
 
-class DateTimeChooserImpl FINAL : public blink::DateTimeChooser, public blink::PagePopupClient {
+class DateTimeChooserImpl FINAL : public DateTimeChooser, public PagePopupClient {
 public:
-    static PassRefPtrWillBeRawPtr<DateTimeChooserImpl> create(ChromeClientImpl*, blink::DateTimeChooserClient*, const blink::DateTimeChooserParameters&);
+    static PassRefPtrWillBeRawPtr<DateTimeChooserImpl> create(ChromeClientImpl*, DateTimeChooserClient*, const DateTimeChooserParameters&);
     virtual ~DateTimeChooserImpl();
-    virtual void trace(blink::Visitor*) OVERRIDE;
+    virtual void trace(Visitor*) OVERRIDE;
 
     // DateTimeChooser functions:
     virtual void endChooser() OVERRIDE;
 
 private:
-    DateTimeChooserImpl(ChromeClientImpl*, blink::DateTimeChooserClient*, const blink::DateTimeChooserParameters&);
+    DateTimeChooserImpl(ChromeClientImpl*, DateTimeChooserClient*, const DateTimeChooserParameters&);
     // PagePopupClient functions:
-    virtual blink::IntSize contentSize() OVERRIDE;
-    virtual void writeDocument(blink::SharedBuffer*) OVERRIDE;
-    virtual blink::Locale& locale() OVERRIDE;
+    virtual IntSize contentSize() OVERRIDE;
+    virtual void writeDocument(SharedBuffer*) OVERRIDE;
+    virtual Locale& locale() OVERRIDE;
     virtual void setValueAndClosePopup(int, const String&) OVERRIDE;
     virtual void setValue(const String&) OVERRIDE;
     virtual void closePopup() OVERRIDE;
     virtual void didClosePopup() OVERRIDE;
 
     ChromeClientImpl* m_chromeClient;
-    RawPtrWillBeMember<blink::DateTimeChooserClient> m_client;
-    blink::PagePopup* m_popup;
-    blink::DateTimeChooserParameters m_parameters;
-    OwnPtr<blink::Locale> m_locale;
+    RawPtrWillBeMember<DateTimeChooserClient> m_client;
+    PagePopup* m_popup;
+    DateTimeChooserParameters m_parameters;
+    OwnPtr<Locale> m_locale;
 };
 
 }

third_party/WebKit/Source/web/ExternalPopupMenu.h

@@ -38,16 +38,13 @@
 #include "public/web/WebExternalPopupMenuClient.h"
 
 namespace blink {
+
 class FloatQuad;
 class LocalFrame;
 class FrameView;
 class IntRect;
 class IntSize;
 class PopupMenuClient;
-}
-
-namespace blink {
-
 class WebExternalPopupMenu;
 class WebViewImpl;
 struct WebPopupMenuInfo;
@@ -55,14 +52,14 @@ class WebMouseEvent;
 
 // The ExternalPopupMenu connects the actual implementation of the popup menu
 // to the WebCore popup menu.
-class ExternalPopupMenu FINAL : public blink::PopupMenu, public WebExternalPopupMenuClient {
+class ExternalPopupMenu FINAL : public PopupMenu, public WebExternalPopupMenuClient {
 public:
-    ExternalPopupMenu(blink::LocalFrame&, blink::PopupMenuClient*, WebViewImpl&);
+    ExternalPopupMenu(LocalFrame&, PopupMenuClient*, WebViewImpl&);
     virtual ~ExternalPopupMenu();
 
 private:
-    // blink::PopupMenu methods:
-    virtual void show(const blink::FloatQuad& controlPosition, const blink::IntSize&, int index) OVERRIDE;
+    // PopupMenu methods:
+    virtual void show(const FloatQuad& controlPosition, const IntSize&, int index) OVERRIDE;
     virtual void hide() OVERRIDE;
     virtual void updateFromElement() OVERRIDE;
     virtual void disconnectClient() OVERRIDE;
@@ -73,18 +70,18 @@ private:
     virtual void didAcceptIndices(const WebVector<int>& indices) OVERRIDE;
     virtual void didCancel() OVERRIDE;
 
-    void dispatchEvent(blink::Timer<ExternalPopupMenu>*);
+    void dispatchEvent(Timer<ExternalPopupMenu>*);
     // Fills |info| with the popup menu information contained in the
-    // blink::PopupMenuClient associated with this ExternalPopupMenu.
+    // PopupMenuClient associated with this ExternalPopupMenu.
     void getPopupMenuInfo(WebPopupMenuInfo* info);
     int toPopupMenuItemIndex(int index);
     int toExternalPopupMenuItemIndex(int index);
 
-    blink::PopupMenuClient* m_popupMenuClient;
-    RefPtr<blink::FrameView> m_frameView;
+    PopupMenuClient* m_popupMenuClient;
+    RefPtr<FrameView> m_frameView;
     WebViewImpl& m_webView;
     OwnPtr<WebMouseEvent> m_syntheticEvent;
-    blink::Timer<ExternalPopupMenu> m_dispatchEventTimer;
+    Timer<ExternalPopupMenu> m_dispatchEventTimer;
     // The actual implementor of the show menu.
     WebExternalPopupMenu* m_webExternalPopupMenu;
 };

third_party/WebKit/Source/web/FullscreenController.h

@@ -38,11 +38,9 @@
 #include "wtf/RefPtr.h"
 
 namespace blink {
+
 class Element;
 class LocalFrame;
-}
-
-namespace blink {
 class WebViewImpl;
 
 class FullscreenController {
@@ -54,8 +52,8 @@ public:
     void willExitFullScreen();
     void didExitFullScreen();
 
-    void enterFullScreenForElement(blink::Element*);
-    void exitFullScreenForElement(blink::Element*);
+    void enterFullScreenForElement(Element*);
+    void exitFullScreenForElement(Element*);
 
     bool isFullscreen() { return m_fullScreenFrame; }
 
@@ -66,19 +64,19 @@ private:
     WebViewImpl* m_webViewImpl;
 
     float m_exitFullscreenPageScaleFactor;
-    blink::IntSize m_exitFullscreenScrollOffset;
-    blink::FloatPoint m_exitFullscreenPinchViewportOffset;
+    IntSize m_exitFullscreenScrollOffset;
+    FloatPoint m_exitFullscreenPinchViewportOffset;
 
     // If set, the WebView is transitioning to fullscreen for this element.
-    RefPtrWillBePersistent<blink::Element> m_provisionalFullScreenElement;
+    RefPtrWillBePersistent<Element> m_provisionalFullScreenElement;
 
     // If set, the WebView is in fullscreen mode for an element in this frame.
-    RefPtr<blink::LocalFrame> m_fullScreenFrame;
+    RefPtr<LocalFrame> m_fullScreenFrame;
 
     bool m_isCancelingFullScreen;
 };
 
-}
+} // namespace blink
 
 #endif
 

third_party/WebKit/Source/web/GeolocationClientProxy.h

@@ -31,29 +31,27 @@
 #include "public/web/WebGeolocationController.h"
 
 namespace blink {
-class GeolocationPosition;
-}
 
-namespace blink {
+class GeolocationPosition;
 class WebGeolocationClient;
 
-class GeolocationClientProxy FINAL : public blink::GeolocationClient {
+class GeolocationClientProxy FINAL : public GeolocationClient {
 public:
     GeolocationClientProxy(WebGeolocationClient* client);
     virtual ~GeolocationClientProxy();
-    void setController(blink::GeolocationController *controller);
+    void setController(GeolocationController*);
     virtual void geolocationDestroyed() OVERRIDE;
     virtual void startUpdating() OVERRIDE;
     virtual void stopUpdating() OVERRIDE;
     virtual void setEnableHighAccuracy(bool) OVERRIDE;
-    virtual blink::GeolocationPosition* lastPosition() OVERRIDE;
+    virtual GeolocationPosition* lastPosition() OVERRIDE;
 
-    virtual void requestPermission(blink::Geolocation*) OVERRIDE;
-    virtual void cancelPermissionRequest(blink::Geolocation*) OVERRIDE;
+    virtual void requestPermission(Geolocation*) OVERRIDE;
+    virtual void cancelPermissionRequest(Geolocation*) OVERRIDE;
 
 private:
     WebGeolocationClient* m_client;
-    blink::Persistent<blink::GeolocationPosition> m_lastPosition;
+    Persistent<GeolocationPosition> m_lastPosition;
 };
 
 } // namespace blink

third_party/WebKit/Source/web/GraphicsLayerFactoryChromium.h

@@ -31,13 +31,13 @@
 namespace blink {
 class WebViewImpl;
 
-class GraphicsLayerFactoryChromium FINAL : public blink::GraphicsLayerFactory {
+class GraphicsLayerFactoryChromium FINAL : public GraphicsLayerFactory {
 public:
     explicit GraphicsLayerFactoryChromium(WebViewImpl*);
 
     virtual ~GraphicsLayerFactoryChromium();
 
-    virtual PassOwnPtr<blink::GraphicsLayer> createGraphicsLayer(blink::GraphicsLayerClient*) OVERRIDE;
+    virtual PassOwnPtr<GraphicsLayer> createGraphicsLayer(GraphicsLayerClient*) OVERRIDE;
 
 private:
     // The owner of this GraphicsLayerFactoryChromium.

third_party/WebKit/Source/web/InspectorClientImpl.h

@@ -42,7 +42,7 @@ class WebDevToolsAgentClient;
 class WebDevToolsAgentImpl;
 class WebViewImpl;
 
-class InspectorClientImpl FINAL : public blink::InspectorClient, public blink::InspectorFrontendChannel {
+class InspectorClientImpl FINAL : public InspectorClient, public InspectorFrontendChannel {
 public:
     explicit InspectorClientImpl(WebViewImpl*);
     virtual ~InspectorClientImpl();
@@ -51,7 +51,7 @@ public:
     virtual void highlight() OVERRIDE;
     virtual void hideHighlight() OVERRIDE;
 
-    virtual void sendMessageToFrontend(PassRefPtr<blink::JSONObject>) OVERRIDE;
+    virtual void sendMessageToFrontend(PassRefPtr<JSONObject>) OVERRIDE;
     virtual void flush() OVERRIDE;
 
     virtual void updateInspectorStateCookie(const WTF::String&) OVERRIDE;
@@ -67,13 +67,13 @@ public:
     virtual void setContinuousPaintingEnabled(bool) OVERRIDE;
     virtual void setShowScrollBottleneckRects(bool) OVERRIDE;
     virtual void resetScrollAndPageScaleFactor() OVERRIDE;
-    virtual void showContextMenu(float x, float y, PassRefPtr<blink::ContextMenuProvider>) OVERRIDE;
+    virtual void showContextMenu(float x, float y, PassRefPtr<ContextMenuProvider>) OVERRIDE;
 
     virtual void getAllocatedObjects(HashSet<const void*>&) OVERRIDE;
     virtual void dumpUncountedAllocatedObjects(const HashMap<const void*, size_t>&) OVERRIDE;
 
-    virtual void dispatchKeyEvent(const blink::PlatformKeyboardEvent&) OVERRIDE;
-    virtual void dispatchMouseEvent(const blink::PlatformMouseEvent&) OVERRIDE;
+    virtual void dispatchKeyEvent(const PlatformKeyboardEvent&) OVERRIDE;
+    virtual void dispatchMouseEvent(const PlatformMouseEvent&) OVERRIDE;
 
     virtual void setTraceEventCallback(const String& categoryFilter, TraceEventCallback) OVERRIDE;
     virtual void resetTraceEventCallback() OVERRIDE;

third_party/WebKit/Source/web/InspectorFrontendClientImpl.h

@@ -35,19 +35,16 @@
 #include "wtf/Noncopyable.h"
 
 namespace blink {
+
 class InspectorFrontendHost;
 class Page;
-}
-
-namespace blink {
-
 class WebDevToolsFrontendClient;
 class WebDevToolsFrontendImpl;
 
-class InspectorFrontendClientImpl FINAL : public blink::InspectorFrontendClient {
+class InspectorFrontendClientImpl FINAL : public InspectorFrontendClient {
     WTF_MAKE_NONCOPYABLE(InspectorFrontendClientImpl);
 public:
-    InspectorFrontendClientImpl(blink::Page*, WebDevToolsFrontendClient*, WebDevToolsFrontendImpl*);
+    InspectorFrontendClientImpl(Page*, WebDevToolsFrontendClient*, WebDevToolsFrontendImpl*);
     virtual ~InspectorFrontendClientImpl();
     virtual void trace(Visitor*) OVERRIDE;
 
@@ -63,9 +60,9 @@ public:
     virtual void dispose() OVERRIDE;
 
 private:
-    RawPtrWillBeMember<blink::Page> m_frontendPage;
+    RawPtrWillBeMember<Page> m_frontendPage;
     WebDevToolsFrontendClient* m_client;
-    RefPtrWillBeMember<blink::InspectorFrontendHost> m_frontendHost;
+    RefPtrWillBeMember<InspectorFrontendHost> m_frontendHost;
 };
 
 } // namespace blink

third_party/WebKit/Source/web/LinkHighlight.h

@@ -38,20 +38,17 @@
 #include "wtf/Vector.h"
 
 namespace blink {
+
 class RenderLayer;
 class RenderObject;
 class Node;
-}
-
-namespace blink {
-
 struct WebFloatRect;
 struct WebRect;
 class WebViewImpl;
 
-class LinkHighlight FINAL : public WebContentLayerClient, public WebCompositorAnimationDelegate, blink::LinkHighlightClient {
+class LinkHighlight FINAL : public WebContentLayerClient, public WebCompositorAnimationDelegate, LinkHighlightClient {
 public:
-    static PassOwnPtr<LinkHighlight> create(blink::Node*, WebViewImpl*);
+    static PassOwnPtr<LinkHighlight> create(Node*, WebViewImpl*);
     virtual ~LinkHighlight();
 
     WebContentLayer* contentLayer();
@@ -64,35 +61,35 @@ public:
         WebContentLayerClient::GraphicsContextStatus = GraphicsContextEnabled) OVERRIDE;
 
     // WebCompositorAnimationDelegate implementation.
-    virtual void notifyAnimationStarted(double monotonicTime, blink::WebCompositorAnimation::TargetProperty) OVERRIDE;
-    virtual void notifyAnimationFinished(double monotonicTime, blink::WebCompositorAnimation::TargetProperty) OVERRIDE;
+    virtual void notifyAnimationStarted(double monotonicTime, WebCompositorAnimation::TargetProperty) OVERRIDE;
+    virtual void notifyAnimationFinished(double monotonicTime, WebCompositorAnimation::TargetProperty) OVERRIDE;
 
     // LinkHighlightClient inplementation.
     virtual void invalidate() OVERRIDE;
     virtual WebLayer* layer() OVERRIDE;
     virtual void clearCurrentGraphicsLayer() OVERRIDE;
 
-    blink::GraphicsLayer* currentGraphicsLayerForTesting() const { return m_currentGraphicsLayer; }
+    GraphicsLayer* currentGraphicsLayerForTesting() const { return m_currentGraphicsLayer; }
 
 private:
-    LinkHighlight(blink::Node*, WebViewImpl*);
+    LinkHighlight(Node*, WebViewImpl*);
 
     void releaseResources();
-    void computeQuads(blink::Node*, WTF::Vector<blink::FloatQuad>&) const;
+    void computeQuads(Node*, WTF::Vector<FloatQuad>&) const;
 
-    blink::RenderLayer* computeEnclosingCompositingLayer();
+    RenderLayer* computeEnclosingCompositingLayer();
     void clearGraphicsLayerLinkHighlightPointer();
     // This function computes the highlight path, and returns true if it has changed
     // size since the last call to this function.
-    bool computeHighlightLayerPathAndPosition(blink::RenderLayer*);
+    bool computeHighlightLayerPathAndPosition(RenderLayer*);
 
     OwnPtr<WebContentLayer> m_contentLayer;
     OwnPtr<WebLayer> m_clipLayer;
-    blink::Path m_path;
+    Path m_path;
 
-    RefPtrWillBePersistent<blink::Node> m_node;
+    RefPtrWillBePersistent<Node> m_node;
     WebViewImpl* m_owningWebViewImpl;
-    blink::GraphicsLayer* m_currentGraphicsLayer;
+    GraphicsLayer* m_currentGraphicsLayer;
 
     bool m_geometryNeedsUpdate;
     bool m_isAnimating;

third_party/WebKit/Source/web/LocalFileSystemClient.h

@@ -36,14 +36,14 @@
 
 namespace blink {
 
-class LocalFileSystemClient FINAL : public blink::FileSystemClient {
+class LocalFileSystemClient FINAL : public FileSystemClient {
 public:
     static PassOwnPtr<FileSystemClient> create();
 
     virtual ~LocalFileSystemClient();
 
-    virtual bool requestFileSystemAccessSync(blink::ExecutionContext*) OVERRIDE;
-    virtual void requestFileSystemAccessAsync(blink::ExecutionContext*, PassOwnPtr<blink::PermissionCallbacks>) OVERRIDE;
+    virtual bool requestFileSystemAccessSync(ExecutionContext*) OVERRIDE;
+    virtual void requestFileSystemAccessAsync(ExecutionContext*, PassOwnPtr<PermissionCallbacks>) OVERRIDE;
 
 private:
     LocalFileSystemClient();

third_party/WebKit/Source/web/PageOverlay.h

@@ -33,12 +33,10 @@
 #include "wtf/PassOwnPtr.h"
 
 namespace blink {
+
 class GraphicsContext;
 class GraphicsLayer;
 class GraphicsLayerClient;
-}
-
-namespace blink {
 class OverlayGraphicsLayerClientImpl;
 class WebPageOverlay;
 class WebViewImpl;
@@ -58,9 +56,9 @@ public:
 
     void clear();
     void update();
-    void paintWebFrame(blink::GraphicsContext&);
+    void paintWebFrame(GraphicsContext&);
 
-    blink::GraphicsLayer* graphicsLayer() const { return m_layer.get(); }
+    GraphicsLayer* graphicsLayer() const { return m_layer.get(); }
 
 private:
     PageOverlay(WebViewImpl*, WebPageOverlay*);
@@ -68,8 +66,8 @@ private:
 
     WebViewImpl* m_viewImpl;
     WebPageOverlay* m_overlay;
-    OwnPtr<blink::GraphicsLayerClient> m_layerClient;
-    OwnPtr<blink::GraphicsLayer> m_layer;
+    OwnPtr<GraphicsLayerClient> m_layerClient;
+    OwnPtr<GraphicsLayer> m_layer;
     int m_zOrder;
 };
 

third_party/WebKit/Source/web/PopupContainer.h

+
 /*
  * Copyright (c) 2011, Google Inc. All rights reserved.
  *
@@ -37,44 +38,41 @@
 #include "web/PopupListBox.h"
 
 namespace blink {
+
 class ChromeClient;
 class FrameView;
 class PopupMenuClient;
-}
-
-namespace blink {
-
 struct WebPopupMenuInfo;
 
-class PopupContainer FINAL : public blink::FramelessScrollView {
+class PopupContainer FINAL : public FramelessScrollView {
 public:
-    static PassRefPtr<PopupContainer> create(blink::PopupMenuClient*, bool deviceSupportsTouch);
+    static PassRefPtr<PopupContainer> create(PopupMenuClient*, bool deviceSupportsTouch);
 
     // Whether a key event should be sent to this popup.
     bool isInterestedInEventForKey(int keyCode);
 
     // FramelessScrollView
-    virtual void paint(blink::GraphicsContext*, const blink::IntRect&) OVERRIDE;
+    virtual void paint(GraphicsContext*, const IntRect&) OVERRIDE;
     virtual void hide() OVERRIDE;
-    virtual bool handleMouseDownEvent(const blink::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleMouseMoveEvent(const blink::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleMouseReleaseEvent(const blink::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleWheelEvent(const blink::PlatformWheelEvent&) OVERRIDE;
-    virtual bool handleKeyEvent(const blink::PlatformKeyboardEvent&) OVERRIDE;
-    virtual bool handleTouchEvent(const blink::PlatformTouchEvent&) OVERRIDE;
-    virtual bool handleGestureEvent(const blink::PlatformGestureEvent&) OVERRIDE;
+    virtual bool handleMouseDownEvent(const PlatformMouseEvent&) OVERRIDE;
+    virtual bool handleMouseMoveEvent(const PlatformMouseEvent&) OVERRIDE;
+    virtual bool handleMouseReleaseEvent(const PlatformMouseEvent&) OVERRIDE;
+    virtual bool handleWheelEvent(const PlatformWheelEvent&) OVERRIDE;
+    virtual bool handleKeyEvent(const PlatformKeyboardEvent&) OVERRIDE;
+    virtual bool handleTouchEvent(const PlatformTouchEvent&) OVERRIDE;
+    virtual bool handleGestureEvent(const PlatformGestureEvent&) OVERRIDE;
 
     // PopupContainer methods
 
     // Show the popup
-    void showPopup(blink::FrameView*);
+    void showPopup(FrameView*);
 
     // Show the popup in the specified rect for the specified frame.
     // Note: this code was somehow arbitrarily factored-out of the Popup class
     // so WebViewImpl can create a PopupContainer. This method is used for
     // displaying auto complete popup menus on Mac Chromium, and for all
     // popups on other platforms.
-    void showInRect(const blink::FloatQuad& controlPosition, const blink::IntSize& controlSize, blink::FrameView*, int index);
+    void showInRect(const FloatQuad& controlPosition, const IntSize& controlSize, FrameView*, int index);
 
     // Hides the popup.
     void hidePopup();
@@ -91,7 +89,7 @@ public:
     int selectedIndex() const;
 
     // Refresh the popup values from the PopupMenuClient.
-    blink::IntRect refresh(const blink::IntRect& targetControlRect);
+    IntRect refresh(const IntRect& targetControlRect);
 
     // The menu per-item data.
     const Vector<PopupItem*>& popupData() const;
@@ -103,36 +101,36 @@ public:
     int menuItemFontSize() const;
 
     // The style of the menu being used.
-    blink::PopupMenuStyle menuStyle() const;
+    PopupMenuStyle menuStyle() const;
 
     // While hovering popup menu window, we want to show tool tip message.
     String getSelectedItemToolTip();
 
     // This is public for testing.
-    static blink::IntRect layoutAndCalculateWidgetRectInternal(blink::IntRect widgetRectInScreen, int targetControlHeight, const blink::FloatRect& windowRect, const blink::FloatRect& screen, bool isRTL, const int rtlOffset, const int verticalOffset, const blink::IntSize& transformOffset, PopupContent*, bool& needToResizeView);
+    static IntRect layoutAndCalculateWidgetRectInternal(IntRect widgetRectInScreen, int targetControlHeight, const FloatRect& windowRect, const FloatRect& screen, bool isRTL, const int rtlOffset, const int verticalOffset, const IntSize& transformOffset, PopupContent*, bool& needToResizeView);
 
 private:
     friend class WTF::RefCounted<PopupContainer>;
 
-    PopupContainer(blink::PopupMenuClient*, bool deviceSupportsTouch);
+    PopupContainer(PopupMenuClient*, bool deviceSupportsTouch);
     virtual ~PopupContainer();
 
     // Paint the border.
-    void paintBorder(blink::GraphicsContext*, const blink::IntRect&);
+    void paintBorder(GraphicsContext*, const IntRect&);
 
     // Layout and calculate popup widget size and location and returns it as IntRect.
-    blink::IntRect layoutAndCalculateWidgetRect(int targetControlHeight, const blink::IntSize& transformOffset, const blink::IntPoint& popupInitialCoordinate);
+    IntRect layoutAndCalculateWidgetRect(int targetControlHeight, const IntSize& transformOffset, const IntPoint& popupInitialCoordinate);
 
     void fitToListBox();
 
-    void popupOpened(const blink::IntRect& bounds);
+    void popupOpened(const IntRect& bounds);
     void getPopupMenuInfo(WebPopupMenuInfo*);
 
     // Returns the ChromeClient of the page this popup is associated with.
-    blink::ChromeClient& chromeClient();
+    ChromeClient& chromeClient();
 
     RefPtr<PopupListBox> m_listBox;
-    RefPtr<blink::FrameView> m_frameView;
+    RefPtr<FrameView> m_frameView;
 
     // m_controlPosition contains the transformed position of the
     // <select>/<input> associated with this popup. m_controlSize is the size
@@ -146,8 +144,8 @@ private:
     //       of m_controlPosition (p3)
     //       If the popup is positioned up it will align with the top right of
     //       m_controlPosition (p2)
-    blink::FloatQuad m_controlPosition;
-    blink::IntSize m_controlSize;
+    FloatQuad m_controlPosition;
+    IntSize m_controlSize;
 
     // Whether the popup is currently open.
     bool m_popupOpen;

third_party/WebKit/Source/web/PopupListBox.h

@@ -37,6 +37,7 @@
 #include "wtf/text/WTFString.h"
 
 namespace blink {
+
 class Font;
 class GraphicsContext;
 class IntRect;
@@ -46,10 +47,6 @@ class PlatformGestureEvent;
 class PlatformTouchEvent;
 class PlatformWheelEvent;
 class PopupMenuClient;
-}
-
-namespace blink {
-
 typedef unsigned long long TimeStamp;
 
 class PopupContent {
@@ -79,7 +76,7 @@ struct PopupItem {
     String label;
     Type type;
     int yOffset; // y offset of this item, relative to the top of the popup.
-    blink::TextDirection textDirection;
+    TextDirection textDirection;
     bool hasTextDirectionOverride;
     bool enabled;
     bool displayNone;
@@ -87,25 +84,25 @@ struct PopupItem {
 
 // This class uses WebCore code to paint and handle events for a drop-down list
 // box ("combobox" on Windows).
-class PopupListBox FINAL : public blink::FramelessScrollView, public PopupContent {
+class PopupListBox FINAL : public FramelessScrollView, public PopupContent {
 public:
-    static PassRefPtr<PopupListBox> create(blink::PopupMenuClient* client, bool deviceSupportsTouch)
+    static PassRefPtr<PopupListBox> create(PopupMenuClient* client, bool deviceSupportsTouch)
     {
         return adoptRef(new PopupListBox(client, deviceSupportsTouch));
     }
 
     // FramelessScrollView
-    virtual void paint(blink::GraphicsContext*, const blink::IntRect&) OVERRIDE;
-    virtual bool handleMouseDownEvent(const blink::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleMouseMoveEvent(const blink::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleMouseReleaseEvent(const blink::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleWheelEvent(const blink::PlatformWheelEvent&) OVERRIDE;
-    virtual bool handleKeyEvent(const blink::PlatformKeyboardEvent&) OVERRIDE;
-    virtual bool handleTouchEvent(const blink::PlatformTouchEvent&) OVERRIDE;
-    virtual bool handleGestureEvent(const blink::PlatformGestureEvent&) OVERRIDE;
+    virtual void paint(GraphicsContext*, const IntRect&) OVERRIDE;
+    virtual bool handleMouseDownEvent(const PlatformMouseEvent&) OVERRIDE;
+    virtual bool handleMouseMoveEvent(const PlatformMouseEvent&) OVERRIDE;
+    virtual bool handleMouseReleaseEvent(const PlatformMouseEvent&) OVERRIDE;
+    virtual bool handleWheelEvent(const PlatformWheelEvent&) OVERRIDE;
+    virtual bool handleKeyEvent(const PlatformKeyboardEvent&) OVERRIDE;
+    virtual bool handleTouchEvent(const PlatformTouchEvent&) OVERRIDE;
+    virtual bool handleGestureEvent(const PlatformGestureEvent&) OVERRIDE;
 
     // ScrollView
-    virtual blink::HostWindow* hostWindow() const OVERRIDE;
+    virtual HostWindow* hostWindow() const OVERRIDE;
     virtual bool shouldPlaceVerticalScrollbarOnLeft() const OVERRIDE;
 
     // PopupListBox methods
@@ -166,7 +163,7 @@ private:
     friend class PopupContainer;
     friend class RefCounted<PopupListBox>;
 
-    PopupListBox(blink::PopupMenuClient*, bool deviceSupportsTouch);
+    PopupListBox(PopupMenuClient*, bool deviceSupportsTouch);
 
     virtual ~PopupListBox()
     {
@@ -199,22 +196,22 @@ private:
     void invalidateRow(int index);
 
     // Get the bounds of a row.
-    blink::IntRect getRowBounds(int index);
+    IntRect getRowBounds(int index);
 
     // Converts a point to an index of the row the point is over
-    int pointToRowIndex(const blink::IntPoint&);
+    int pointToRowIndex(const IntPoint&);
 
     // Paint an individual row
-    void paintRow(blink::GraphicsContext*, const blink::IntRect&, int rowIndex);
+    void paintRow(GraphicsContext*, const IntRect&, int rowIndex);
 
     // Test if the given point is within the bounds of the popup window.
-    bool isPointInBounds(const blink::IntPoint&);
+    bool isPointInBounds(const IntPoint&);
 
     // Called when the user presses a text key. Does a prefix-search of the items.
-    void typeAheadFind(const blink::PlatformKeyboardEvent&);
+    void typeAheadFind(const PlatformKeyboardEvent&);
 
     // Returns the font to use for the given row
-    blink::Font getRowFont(int index);
+    Font getRowFont(int index);
 
     // Moves the selection down/up one item, taking care of looping back to the
     // first/last element if m_loopSelectionNavigation is true.
@@ -255,14 +252,14 @@ private:
     Vector<PopupItem*> m_items;
 
     // The <select> PopupMenuClient that opened us.
-    blink::PopupMenuClient* m_popupClient;
+    PopupMenuClient* m_popupClient;
 
     // The scrollbar which has mouse capture. Mouse events go straight to this
     // if not null.
-    RefPtr<blink::Scrollbar> m_capturingScrollbar;
+    RefPtr<Scrollbar> m_capturingScrollbar;
 
     // The last scrollbar that the mouse was over. Used for mouseover highlights.
-    RefPtr<blink::Scrollbar> m_lastScrollbarUnderMouse;
+    RefPtr<Scrollbar> m_lastScrollbarUnderMouse;
 
     // The string the user has typed so far into the popup. Used for typeAheadFind.
     String m_typedString;
@@ -277,7 +274,7 @@ private:
     int m_maxWindowWidth;
 
     // To forward last mouse release event.
-    RefPtrWillBePersistent<blink::Element> m_focusedElement;
+    RefPtrWillBePersistent<Element> m_focusedElement;
 };
 
 } // namespace blink

third_party/WebKit/Source/web/PopupMenuChromium.h

@@ -35,28 +35,25 @@
 #include "wtf/RefPtr.h"
 
 namespace blink {
+
 class LocalFrame;
 class FrameView;
-class PopupMenuClient;
-}
-
-namespace blink {
-
 class PopupContainer;
+class PopupMenuClient;
 
-class PopupMenuChromium FINAL : public blink::PopupMenu {
+class PopupMenuChromium FINAL : public PopupMenu {
 public:
-    PopupMenuChromium(blink::LocalFrame&, blink::PopupMenuClient*);
+    PopupMenuChromium(LocalFrame&, PopupMenuClient*);
     virtual ~PopupMenuChromium();
 
-    virtual void show(const blink::FloatQuad& controlPosition, const blink::IntSize& controlSize, int index) OVERRIDE;
+    virtual void show(const FloatQuad& controlPosition, const IntSize& controlSize, int index) OVERRIDE;
     virtual void hide() OVERRIDE;
     virtual void updateFromElement() OVERRIDE;
     virtual void disconnectClient() OVERRIDE;
 
 private:
-    blink::PopupMenuClient* m_popupClient;
-    RefPtr<blink::FrameView> m_frameView;
+    PopupMenuClient* m_popupClient;
+    RefPtr<FrameView> m_frameView;
     RefPtr<PopupContainer> m_popup;
 };
 

third_party/WebKit/Source/web/ScrollbarGroup.h

@@ -30,56 +30,53 @@
 
 #include "wtf/RefPtr.h"
 
-namespace blink {
-class FrameView;
-}
-
 namespace blink {
 
+class FrameView;
 class WebPluginScrollbarImpl;
 
-class ScrollbarGroup FINAL : public blink::ScrollableArea {
+class ScrollbarGroup FINAL : public ScrollableArea {
 public:
-    ScrollbarGroup(blink::FrameView*, const blink::IntRect& frameRect);
+    ScrollbarGroup(FrameView*, const IntRect& frameRect);
     virtual ~ScrollbarGroup();
 
     void scrollbarCreated(WebPluginScrollbarImpl*);
     void scrollbarDestroyed(WebPluginScrollbarImpl*);
-    void setLastMousePosition(const blink::IntPoint&);
-    void setFrameRect(const blink::IntRect&);
+    void setLastMousePosition(const IntPoint&);
+    void setFrameRect(const IntRect&);
 
-    // blink::ScrollableArea methods
-    virtual int scrollSize(blink::ScrollbarOrientation) const OVERRIDE;
-    virtual void setScrollOffset(const blink::IntPoint&) OVERRIDE;
-    virtual void invalidateScrollbarRect(blink::Scrollbar*, const blink::IntRect&) OVERRIDE;
-    virtual void invalidateScrollCornerRect(const blink::IntRect&) OVERRIDE;
+    // ScrollableArea methods
+    virtual int scrollSize(ScrollbarOrientation) const OVERRIDE;
+    virtual void setScrollOffset(const IntPoint&) OVERRIDE;
+    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) OVERRIDE;
+    virtual void invalidateScrollCornerRect(const IntRect&) OVERRIDE;
     virtual bool isActive() const OVERRIDE;
-    virtual blink::IntRect scrollCornerRect() const OVERRIDE { return blink::IntRect(); }
+    virtual IntRect scrollCornerRect() const OVERRIDE { return IntRect(); }
     virtual bool isScrollCornerVisible() const OVERRIDE;
-    virtual void getTickmarks(Vector<blink::IntRect>&) const OVERRIDE;
-    virtual blink::IntPoint convertFromContainingViewToScrollbar(const blink::Scrollbar*, const blink::IntPoint& parentPoint) const OVERRIDE;
-    virtual blink::Scrollbar* horizontalScrollbar() const OVERRIDE;
-    virtual blink::Scrollbar* verticalScrollbar() const OVERRIDE;
-    virtual blink::IntPoint scrollPosition() const OVERRIDE;
-    virtual blink::IntPoint minimumScrollPosition() const OVERRIDE;
-    virtual blink::IntPoint maximumScrollPosition() const OVERRIDE;
+    virtual void getTickmarks(Vector<IntRect>&) const OVERRIDE;
+    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint& parentPoint) const OVERRIDE;
+    virtual Scrollbar* horizontalScrollbar() const OVERRIDE;
+    virtual Scrollbar* verticalScrollbar() const OVERRIDE;
+    virtual IntPoint scrollPosition() const OVERRIDE;
+    virtual IntPoint minimumScrollPosition() const OVERRIDE;
+    virtual IntPoint maximumScrollPosition() const OVERRIDE;
     virtual int visibleHeight() const OVERRIDE;
     virtual int visibleWidth() const OVERRIDE;
-    virtual blink::IntSize contentsSize() const OVERRIDE;
-    virtual blink::IntSize overhangAmount() const OVERRIDE;
-    virtual blink::IntPoint lastKnownMousePosition() const OVERRIDE;
+    virtual IntSize contentsSize() const OVERRIDE;
+    virtual IntSize overhangAmount() const OVERRIDE;
+    virtual IntPoint lastKnownMousePosition() const OVERRIDE;
     virtual bool shouldSuspendScrollAnimations() const OVERRIDE;
     virtual void scrollbarStyleChanged() OVERRIDE;
     virtual bool scrollbarsCanBeActive() const OVERRIDE;
-    virtual blink::IntRect scrollableAreaBoundingBox() const OVERRIDE;
-    virtual bool userInputScrollable(blink::ScrollbarOrientation) const OVERRIDE;
+    virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;
+    virtual bool userInputScrollable(ScrollbarOrientation) const OVERRIDE;
     virtual bool shouldPlaceVerticalScrollbarOnLeft() const OVERRIDE;
-    virtual int pageStep(blink::ScrollbarOrientation) const OVERRIDE;
+    virtual int pageStep(ScrollbarOrientation) const OVERRIDE;
 
 private:
-    blink::FrameView* m_frameView;
-    blink::IntPoint m_lastMousePosition;
-    blink::IntRect m_frameRect;
+    FrameView* m_frameView;
+    IntPoint m_lastMousePosition;
+    IntRect m_frameRect;
     WebPluginScrollbarImpl* m_horizontalScrollbar;
     WebPluginScrollbarImpl* m_verticalScrollbar;
 };

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeClientImpl.h

@@ -40,10 +40,10 @@ namespace blink {
 class WebServiceWorkerContextClient;
 class WebURL;
 
-class ServiceWorkerGlobalScopeClientImpl FINAL : public NoBaseWillBeGarbageCollectedFinalized<ServiceWorkerGlobalScopeClientImpl>, public blink::ServiceWorkerGlobalScopeClient {
+class ServiceWorkerGlobalScopeClientImpl FINAL : public NoBaseWillBeGarbageCollectedFinalized<ServiceWorkerGlobalScopeClientImpl>, public ServiceWorkerGlobalScopeClient {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(ServiceWorkerGlobalScopeClientImpl);
 public:
-    static PassOwnPtrWillBeRawPtr<blink::ServiceWorkerGlobalScopeClient> create(WebServiceWorkerContextClient&);
+    static PassOwnPtrWillBeRawPtr<ServiceWorkerGlobalScopeClient> create(WebServiceWorkerContextClient&);
     virtual ~ServiceWorkerGlobalScopeClientImpl();
 
     virtual void getClients(WebServiceWorkerClientsCallbacks*);
@@ -52,11 +52,11 @@ public:
 
     virtual void didHandleActivateEvent(int eventID, WebServiceWorkerEventResult) OVERRIDE;
     virtual void didHandleInstallEvent(int installEventID, WebServiceWorkerEventResult) OVERRIDE;
-    virtual void didHandleFetchEvent(int fetchEventID, PassRefPtrWillBeRawPtr<blink::Response>) OVERRIDE;
+    virtual void didHandleFetchEvent(int fetchEventID, PassRefPtrWillBeRawPtr<Response>) OVERRIDE;
     virtual void didHandleSyncEvent(int syncEventID) OVERRIDE;
     virtual void postMessageToClient(int clientID, const WebString& message, PassOwnPtr<WebMessagePortChannelArray>) OVERRIDE;
 
-    virtual void trace(blink::Visitor* visitor) OVERRIDE { blink::ServiceWorkerGlobalScopeClient::trace(visitor); }
+    virtual void trace(Visitor* visitor) OVERRIDE { ServiceWorkerGlobalScopeClient::trace(visitor); }
 
 private:
     explicit ServiceWorkerGlobalScopeClientImpl(WebServiceWorkerContextClient&);

third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.h

@@ -40,7 +40,7 @@ namespace blink {
 
 class WebSharedWorkerRepositoryClient;
 
-class SharedWorkerRepositoryClientImpl FINAL : public blink::SharedWorkerRepositoryClient {
+class SharedWorkerRepositoryClientImpl FINAL : public SharedWorkerRepositoryClient {
     WTF_MAKE_NONCOPYABLE(SharedWorkerRepositoryClientImpl);
 public:
     static PassOwnPtr<SharedWorkerRepositoryClientImpl> create(WebSharedWorkerRepositoryClient* client)
@@ -50,8 +50,8 @@ public:
 
     virtual ~SharedWorkerRepositoryClientImpl() { }
 
-    virtual void connect(PassRefPtrWillBeRawPtr<blink::SharedWorker>, PassOwnPtr<WebMessagePortChannel>, const blink::KURL&, const String& name, blink::ExceptionState&) OVERRIDE;
-    virtual void documentDetached(blink::Document*) OVERRIDE;
+    virtual void connect(PassRefPtrWillBeRawPtr<SharedWorker>, PassOwnPtr<WebMessagePortChannel>, const KURL&, const String& name, ExceptionState&) OVERRIDE;
+    virtual void documentDetached(Document*) OVERRIDE;
 
 private:
     explicit SharedWorkerRepositoryClientImpl(WebSharedWorkerRepositoryClient*);

third_party/WebKit/Source/web/SpellCheckerClientImpl.h

@@ -35,14 +35,12 @@
 #include "platform/text/TextCheckerClient.h"
 
 namespace blink {
+
 class LocalFrame;
 class HTMLInputElement;
-}
-
-namespace blink {
 class WebViewImpl;
 
-class SpellCheckerClientImpl FINAL : public blink::SpellCheckerClient, public blink::TextCheckerClient {
+class SpellCheckerClientImpl FINAL : public SpellCheckerClient, public TextCheckerClient {
 public:
     explicit SpellCheckerClientImpl(WebViewImpl*);
 
@@ -51,17 +49,17 @@ public:
     virtual bool isContinuousSpellCheckingEnabled() OVERRIDE;
     virtual void toggleContinuousSpellChecking() OVERRIDE;
     virtual bool isGrammarCheckingEnabled() OVERRIDE;
-    virtual bool shouldEraseMarkersAfterChangeSelection(blink::TextCheckingType) const OVERRIDE;
+    virtual bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const OVERRIDE;
     virtual void checkSpellingOfString(const String&, int* misspellingLocation, int* misspellingLength) OVERRIDE;
-    virtual void checkGrammarOfString(const String&, WTF::Vector<blink::GrammarDetail>&,
+    virtual void checkGrammarOfString(const String&, WTF::Vector<GrammarDetail>&,
         int* badGrammarLocation, int* badGrammarLength) OVERRIDE;
     virtual WTF::String getAutoCorrectSuggestionForMisspelledWord(const WTF::String&) OVERRIDE;
     virtual void updateSpellingUIWithMisspelledWord(const WTF::String&) OVERRIDE;
     virtual void showSpellingUI(bool show) OVERRIDE;
     virtual bool spellingUIIsShowing() OVERRIDE;
-    virtual void requestCheckingOfString(WTF::PassRefPtr<blink::TextCheckingRequest>) OVERRIDE;
+    virtual void requestCheckingOfString(WTF::PassRefPtr<TextCheckingRequest>) OVERRIDE;
 
-    virtual blink::TextCheckerClient& textChecker() OVERRIDE { return *this; }
+    virtual TextCheckerClient& textChecker() OVERRIDE { return *this; }
 
 private:
     // Returns whether or not the focused control needs spell-checking.

third_party/WebKit/Source/web/StorageClientImpl.h

@@ -11,12 +11,12 @@ namespace blink {
 
 class WebViewImpl;
 
-class StorageClientImpl : public blink::StorageClient {
+class StorageClientImpl : public StorageClient {
 public:
     explicit StorageClientImpl(WebViewImpl*);
 
-    virtual PassOwnPtr<blink::StorageNamespace> createSessionStorageNamespace() OVERRIDE;
-    virtual bool canAccessStorage(blink::LocalFrame*, blink::StorageType) const OVERRIDE;
+    virtual PassOwnPtr<StorageNamespace> createSessionStorageNamespace() OVERRIDE;
+    virtual bool canAccessStorage(LocalFrame*, StorageType) const OVERRIDE;
 
 private:
     WebViewImpl* m_webView;

third_party/WebKit/Source/web/StorageQuotaClientImpl.h

@@ -36,17 +36,17 @@
 
 namespace blink {
 
-class StorageQuotaClientImpl : public NoBaseWillBeGarbageCollectedFinalized<StorageQuotaClientImpl>, public blink::StorageQuotaClient {
+class StorageQuotaClientImpl : public NoBaseWillBeGarbageCollectedFinalized<StorageQuotaClientImpl>, public StorageQuotaClient {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(StorageQuotaClientImpl);
 public:
     static PassOwnPtrWillBeRawPtr<StorageQuotaClientImpl> create();
 
     virtual ~StorageQuotaClientImpl();
 
-    virtual void requestQuota(blink::ExecutionContext*, WebStorageQuotaType, unsigned long long newQuotaInBytes, PassOwnPtr<blink::StorageQuotaCallback>, PassOwnPtr<blink::StorageErrorCallback>) OVERRIDE;
-    virtual blink::ScriptPromise requestPersistentQuota(blink::ScriptState*, unsigned long long newQuotaInBytes) OVERRIDE;
+    virtual void requestQuota(ExecutionContext*, WebStorageQuotaType, unsigned long long newQuotaInBytes, PassOwnPtr<StorageQuotaCallback>, PassOwnPtr<StorageErrorCallback>) OVERRIDE;
+    virtual ScriptPromise requestPersistentQuota(ScriptState*, unsigned long long newQuotaInBytes) OVERRIDE;
 
-    virtual void trace(blink::Visitor* visitor) OVERRIDE { blink::StorageQuotaClient::trace(visitor); }
+    virtual void trace(Visitor* visitor) OVERRIDE { StorageQuotaClient::trace(visitor); }
 
 private:
     StorageQuotaClientImpl();

third_party/WebKit/Source/web/TextFinder.h

@@ -44,10 +44,8 @@
 #include "wtf/text/WTFString.h"
 
 namespace blink {
-class Range;
-}
 
-namespace blink {
+class Range;
 class WebLocalFrameImpl;
 
 template <typename T> class WebVector;
@@ -78,7 +76,7 @@ public:
 
     // Returns the active match in the current frame. Could be a null range if
     // the local frame has no active match.
-    blink::Range* activeMatch() const { return m_activeMatch.get(); }
+    Range* activeMatch() const { return m_activeMatch.get(); }
 
     void flushCurrentScoping();
 
@@ -93,18 +91,18 @@ public:
     class FindMatch {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
-        RefPtrWillBeMember<blink::Range> m_range;
+        RefPtrWillBeMember<Range> m_range;
 
         // 1-based index within this frame.
         int m_ordinal;
 
         // In find-in-page coordinates.
         // Lazily calculated by updateFindMatchRects.
-        blink::FloatRect m_rect;
+        FloatRect m_rect;
 
-        FindMatch(PassRefPtrWillBeRawPtr<blink::Range>, int ordinal);
+        FindMatch(PassRefPtrWillBeRawPtr<Range>, int ordinal);
 
-        void trace(blink::Visitor*);
+        void trace(Visitor*);
     };
 
 private:
@@ -127,7 +125,7 @@ private:
     // Return the index in the find-in-page cache of the match closest to the
     // provided point in find-in-page coordinates, or -1 in case of error.
     // The squared distance to the closest match is returned in the distanceSquared parameter.
-    int nearestFindMatch(const blink::FloatPoint&, float& distanceSquared);
+    int nearestFindMatch(const FloatPoint&, float& distanceSquared);
 
     // Select a find-in-page match marker in the current frame using a cache
     // match index returned by nearestFindMatch. Returns the ordinal of the new
@@ -144,10 +142,10 @@ private:
     void appendFindMatchRects(Vector<WebFloatRect>& frameRects);
 
     // Add a WebKit TextMatch-highlight marker to nodes in a range.
-    void addMarker(blink::Range*, bool activeMatch);
+    void addMarker(Range*, bool activeMatch);
 
     // Sets the markers within a range as active or inactive.
-    void setMarkerActive(blink::Range*, bool active);
+    void setMarkerActive(Range*, bool active);
 
     // Returns the ordinal of the first match in the frame specified. This
     // function enumerates the frames, starting with the main frame and up to (but
@@ -197,7 +195,7 @@ private:
     WebLocalFrameImpl* m_currentActiveMatchFrame;
 
     // The range of the active match for the current frame.
-    RefPtrWillBePersistent<blink::Range> m_activeMatch;
+    RefPtrWillBePersistent<Range> m_activeMatch;
 
     // The index of the active match for the current frame.
     int m_activeMatchIndexInCurrentFrame;
@@ -207,7 +205,7 @@ private:
     //
     // This range is collapsed to the start position of the last successful
     // search; the new search should start from the next adjacent position.
-    RefPtrWillBePersistent<blink::Range> m_resumeScopingFromRange;
+    RefPtrWillBePersistent<Range> m_resumeScopingFromRange;
 
     // Keeps track of the last string this frame searched for. This is used for
     // short-circuiting searches in the following scenarios: When a frame has
@@ -250,7 +248,7 @@ private:
 
     // Contents size when find-in-page match rects were last computed for this
     // frame's cache.
-    blink::IntSize m_contentsSizeForCurrentFindMatchRects;
+    IntSize m_contentsSizeForCurrentFindMatchRects;
 
     // This flag is used by the scoping effort to determine if we need to figure
     // out which rectangle is the active match. Once we find the active

third_party/WebKit/Source/web/ViewportAnchor.h

@@ -39,12 +39,10 @@
 #include "wtf/RefCounted.h"
 
 namespace blink {
+
 class EventHandler;
 class IntSize;
 class Node;
-}
-
-namespace blink {
 
 // ViewportAnchor provides a way to anchor a viewport origin to a DOM node.
 // In particular, the user supplies the current viewport (in CSS coordinates)
@@ -56,22 +54,22 @@ namespace blink {
 class ViewportAnchor {
     STACK_ALLOCATED();
 public:
-    explicit ViewportAnchor(blink::EventHandler* eventHandler);
+    explicit ViewportAnchor(EventHandler*);
 
-    void setAnchor(const blink::IntRect& viewRect, const blink::FloatSize& anchorInViewCoords);
+    void setAnchor(const IntRect& viewRect, const FloatSize& anchorInViewCoords);
 
-    blink::IntPoint computeOrigin(const blink::IntSize& currentViewSize) const;
+    IntPoint computeOrigin(const IntSize& currentViewSize) const;
 
 private:
-    RawPtrWillBeMember<blink::EventHandler> m_eventHandler;
+    RawPtrWillBeMember<EventHandler> m_eventHandler;
 
-    blink::IntRect m_viewRect;
+    IntRect m_viewRect;
 
-    RefPtrWillBeMember<blink::Node> m_anchorNode;
-    blink::LayoutRect m_anchorNodeBounds;
+    RefPtrWillBeMember<Node> m_anchorNode;
+    LayoutRect m_anchorNodeBounds;
 
-    blink::FloatSize m_anchorInViewCoords;
-    blink::FloatSize m_anchorInNodeCoords;
+    FloatSize m_anchorInViewCoords;
+    FloatSize m_anchorInNodeCoords;
 };
 
 } // namespace blink