Rename WebCore namespace to blink in bindings and web

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 18 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 WebCore {
+namespace blink {
 class Font;
 class GraphicsContext;
 class IntRect;
 class PlatformKeyboardEvent;
 class PlatformMouseEvent;
 class PlatformGestureEvent;
 class PlatformTouchEvent;
 class PlatformWheelEvent;
 class PopupMenuClient;
 }
@@ skipping 22 matching lines @@
 
     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.
-    WebCore::TextDirection textDirection;
+    blink::TextDirection textDirection;
     bool hasTextDirectionOverride;
     bool enabled;
 };
 
 // This class uses WebCore code to paint and handle events for a drop-down list
 // box ("combobox" on Windows).
-class PopupListBox FINAL : public WebCore::FramelessScrollView, public PopupContent {
+class PopupListBox FINAL : public blink::FramelessScrollView, public PopupContent {
 public:
-    static PassRefPtr<PopupListBox> create(WebCore::PopupMenuClient* client, bool deviceSupportsTouch)
+    static PassRefPtr<PopupListBox> create(blink::PopupMenuClient* client, bool deviceSupportsTouch)
     {
         return adoptRef(new PopupListBox(client, deviceSupportsTouch));
     }
 
     // FramelessScrollView
-    virtual void paint(WebCore::GraphicsContext*, const WebCore::IntRect&) OVERRIDE;
-    virtual bool handleMouseDownEvent(const WebCore::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleMouseMoveEvent(const WebCore::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleMouseReleaseEvent(const WebCore::PlatformMouseEvent&) OVERRIDE;
-    virtual bool handleWheelEvent(const WebCore::PlatformWheelEvent&) OVERRIDE;
-    virtual bool handleKeyEvent(const WebCore::PlatformKeyboardEvent&) OVERRIDE;
-    virtual bool handleTouchEvent(const WebCore::PlatformTouchEvent&) OVERRIDE;
-    virtual bool handleGestureEvent(const WebCore::PlatformGestureEvent&) OVERRIDE;
+    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;
 
     // ScrollView
-    virtual WebCore::HostWindow* hostWindow() const OVERRIDE;
+    virtual blink::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 38 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(WebCore::PopupMenuClient*, bool deviceSupportsTouch);
+    PopupListBox(blink::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.
-    WebCore::IntRect getRowBounds(int index);
+    blink::IntRect getRowBounds(int index);
 
     // Converts a point to an index of the row the point is over
-    int pointToRowIndex(const WebCore::IntPoint&);
+    int pointToRowIndex(const blink::IntPoint&);
 
     // Paint an individual row
-    void paintRow(WebCore::GraphicsContext*, const WebCore::IntRect&, int rowIndex);
+    void paintRow(blink::GraphicsContext*, const blink::IntRect&, int rowIndex);
 
     // Test if the given point is within the bounds of the popup window.
-    bool isPointInBounds(const WebCore::IntPoint&);
+    bool isPointInBounds(const blink::IntPoint&);
 
     // Called when the user presses a text key. Does a prefix-search of the items.
-    void typeAheadFind(const WebCore::PlatformKeyboardEvent&);
+    void typeAheadFind(const blink::PlatformKeyboardEvent&);
 
     // Returns the font to use for the given row
-    WebCore::Font getRowFont(int index);
+    blink::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.
-    WebCore::PopupMenuClient* m_popupClient;
+    blink::PopupMenuClient* m_popupClient;
 
     // The scrollbar which has mouse capture. Mouse events go straight to this
     // if not null.
-    RefPtr<WebCore::Scrollbar> m_capturingScrollbar;
+    RefPtr<blink::Scrollbar> m_capturingScrollbar;
 
     // The last scrollbar that the mouse was over. Used for mouseover highlights.
-    RefPtr<WebCore::Scrollbar> m_lastScrollbarUnderMouse;
+    RefPtr<blink::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<WebCore::Element> m_focusedElement;
+    RefPtrWillBePersistent<blink::Element> m_focusedElement;
 };
 
 } // namespace blink
 
 #endif