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

Source/web/PopupListBox.h

 /*
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #ifndef PopupListBox_h
 #define PopupListBox_h
 
 #include "core/dom/Element.h"
 #include "platform/scroll/FramelessScrollView.h"
 #include "platform/text/TextDirection.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
+
 class Font;
 class GraphicsContext;
 class IntRect;
 class PlatformKeyboardEvent;
 class PlatformMouseEvent;
 class PlatformGestureEvent;
 class PlatformTouchEvent;
 class PlatformWheelEvent;
 class PopupMenuClient;
-}
-
-namespace blink {
-
 typedef unsigned long long TimeStamp;
 
 class PopupContent {
 public:
     virtual void layout() = 0;
     virtual void setMaxHeight(int) = 0;
     virtual void setMaxWidthAndLayout(int) = 0;
     virtual int popupContentHeight() const = 0;
     virtual ~PopupContent() { };
 };
 
 // A container for the data for each menu item (e.g. represented by <option>
 // or <optgroup> in a <select> widget) and is used by PopupListBox.
 struct PopupItem {
     enum Type {
         TypeOption,
         TypeGroup,
         TypeSeparator
     };
 
     PopupItem(const String& label, Type type)
         : label(label)
         , type(type)
         , yOffset(0)
     {
     }
     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;
 };
 
 // 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
 
     // Closes the popup
     void abandon();
 
     // Updates our internal list to match the client.
     void updateFromElement();
 
@@ skipping 40 matching lines @@
     const Vector<PopupItem*>& items() const { return m_items; }
 
     virtual int popupContentHeight() const OVERRIDE;
 
     static const int defaultMaxHeight;
 
 private:
     friend class PopupContainer;
     friend class RefCounted<PopupListBox>;
 
-    PopupListBox(blink::PopupMenuClient*, bool deviceSupportsTouch);
+    PopupListBox(PopupMenuClient*, bool deviceSupportsTouch);
 
     virtual ~PopupListBox()
     {
         clear();
     }
 
     // Hides the popup. Other classes should not call this. Use abandon instead.
     void hidePopup();
 
     // Returns true if the selection can be changed to index.
@@ skipping 12 matching lines @@
     void clearSelection();
 
     // Scrolls to reveal the given index.
     void scrollToRevealRow(int index);
     void scrollToRevealSelection() { scrollToRevealRow(m_selectedIndex); }
 
     // Invalidates the row at the given index.
     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.
     void selectPreviousRow();
     void selectNextRow();
 
     // If the device is a touch screen we increase the height of menu items
     // to make it easier to unambiguously touch them.
     bool m_deviceSupportsTouch;
 
@@ skipping 20 matching lines @@
     // Our suggested width, not including scrollbar.
     int m_baseWidth;
 
     // The maximum height we can be without being off-screen.
     int m_maxHeight;
 
     // A list of the options contained within the <select>
     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;
 
     // The char the user has hit repeatedly. Used for typeAheadFind.
     UChar m_repeatingChar;
 
     // The last time the user hit a key. Used for typeAheadFind.
     TimeStamp m_lastCharTime;
 
     // If width exeeds screen width, we have to clip it.
     int m_maxWindowWidth;
 
     // To forward last mouse release event.
-    RefPtrWillBePersistent<blink::Element> m_focusedElement;
+    RefPtrWillBePersistent<Element> m_focusedElement;
 };
 
 } // namespace blink
 
 #endif