Rename WebCore namespace to blink in bindings and web

Source/web/WebViewImpl.h

 /*
  * Copyright (C) 2010 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 42 matching lines @@
 #include "web/MediaKeysClientImpl.h"
 #include "web/PageOverlayList.h"
 #include "web/PageScaleConstraintsSet.h"
 #include "web/PageWidgetDelegate.h"
 #include "web/SpellCheckerClientImpl.h"
 #include "web/StorageClientImpl.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 
-namespace WebCore {
+namespace blink {
 class DataObject;
 class Frame;
 class RenderLayerCompositor;
 class UserGestureToken;
 }
 
 namespace blink {
 class LinkHighlight;
 class PopupContainer;
 class WebActiveGestureAnimation;
 class WebDevToolsAgentPrivate;
 class WebLocalFrameImpl;
 class WebImage;
 class WebPagePopupImpl;
 class WebPlugin;
 class WebSettingsImpl;
 class FullscreenController;
 
 class WebViewImpl FINAL : public WebView
     , public RefCounted<WebViewImpl>
     , public WebGestureCurveTarget
-    , public WebCore::PagePopupDriver
+    , public blink::PagePopupDriver
     , public PageWidgetEventHandler {
 public:
     static WebViewImpl* create(WebViewClient*);
 
     // WebWidget methods:
     virtual void close() OVERRIDE;
     virtual WebSize size() OVERRIDE;
     virtual void willStartLiveResize() OVERRIDE;
     virtual void resize(const WebSize&) OVERRIDE;
     virtual void resizePinchViewport(const WebSize&) OVERRIDE;
@@ skipping 159 matching lines @@
     virtual void setShowPaintRects(bool) OVERRIDE;
     void setShowDebugBorders(bool);
     virtual void setShowFPSCounter(bool) OVERRIDE;
     virtual void setContinuousPaintingEnabled(bool) OVERRIDE;
     virtual void setShowScrollBottleneckRects(bool) OVERRIDE;
     virtual void getSelectionRootBounds(WebRect& bounds) const OVERRIDE;
     virtual void acceptLanguagesChanged() OVERRIDE;
 
     // WebViewImpl
 
-    WebCore::HitTestResult coreHitTestResultAt(const WebPoint&);
+    blink::HitTestResult coreHitTestResultAt(const WebPoint&);
     void suppressInvalidations(bool enable);
-    void invalidateRect(const WebCore::IntRect&);
+    void invalidateRect(const blink::IntRect&);
 
     void setIgnoreInputEvents(bool newValue);
     void setBackgroundColorOverride(WebColor);
     void setZoomFactorOverride(float);
     WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
 
-    WebCore::Color baseBackgroundColor() const { return m_baseBackgroundColor; }
+    blink::Color baseBackgroundColor() const { return m_baseBackgroundColor; }
 
     PageOverlayList* pageOverlays() const { return m_pageOverlays.get(); }
 
-    void setOverlayLayer(WebCore::GraphicsLayer*);
+    void setOverlayLayer(blink::GraphicsLayer*);
 
     const WebPoint& lastMouseDownPoint() const
     {
         return m_lastMouseDownPoint;
     }
 
-    WebCore::Frame* focusedWebCoreFrame() const;
+    blink::Frame* focusedWebCoreFrame() const;
 
     // Returns the currently focused Element or null if no element has focus.
-    WebCore::Element* focusedElement() const;
+    blink::Element* focusedElement() const;
 
-    static WebViewImpl* fromPage(WebCore::Page*);
+    static WebViewImpl* fromPage(blink::Page*);
 
     WebViewClient* client()
     {
         return m_client;
     }
 
     WebAutofillClient* autofillClient()
     {
         return m_autofillClient;
     }
 
     WebSpellCheckClient* spellCheckClient()
     {
         return m_spellCheckClient;
     }
 
     // Returns the page object associated with this view. This may be null when
     // the page is shutting down, but will be valid at all other times.
-    WebCore::Page* page() const
+    blink::Page* page() const
     {
         return m_page.get();
     }
 
     // Returns the main frame associated with this view. This may be null when
     // the page is shutting down, but will be valid at all other times.
     WebLocalFrameImpl* mainFrameImpl();
 
     // FIXME: Temporary method to accommodate out-of-process frame ancestors;
     // will be removed when there can be multiple WebWidgets for a single page.
     WebLocalFrameImpl* localFrameRootTemporary() const;
 
     // Event related methods:
     void mouseContextMenu(const WebMouseEvent&);
     void mouseDoubleClick(const WebMouseEvent&);
 
     bool detectContentOnTouch(const WebPoint&);
-    bool startPageScaleAnimation(const WebCore::IntPoint& targetPosition, bool useAnchor, float newScale, double durationInSeconds);
+    bool startPageScaleAnimation(const blink::IntPoint& targetPosition, bool useAnchor, float newScale, double durationInSeconds);
 
     void hasTouchEventHandlers(bool);
 
     // WebGestureCurveTarget implementation for fling.
     virtual bool scrollBy(const WebFloatSize& delta, const WebFloatSize& velocity) OVERRIDE;
 
     // Handles context menu events orignated via the the keyboard. These
     // include the VK_APPS virtual key and the Shift+F10 combine. Code is
     // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
     // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
     // significant change in this function is the code to convert from a
     // Keyboard event to the Right Mouse button down event.
     bool sendContextMenuEvent(const WebKeyboardEvent&);
 
-    void showContextMenuAtPoint(float x, float y, PassRefPtr<WebCore::ContextMenuProvider>);
+    void showContextMenuAtPoint(float x, float y, PassRefPtr<blink::ContextMenuProvider>);
 
     // Notifies the WebView that a load has been committed. isNewNavigation
     // will be true if a new session history item should be created for that
     // load. isNavigationWithinPage will be true if the navigation does
     // not take the user away from the current page.
     void didCommitLoad(bool isNewNavigation, bool isNavigationWithinPage);
 
     // Indicates two things:
     //   1) This view may have a new layout now.
     //   2) Calling layout() is a no-op.
@@ skipping 12 matching lines @@
     bool contextMenuAllowed() const
     {
         return m_contextMenuAllowed;
     }
 
     bool shouldAutoResize() const
     {
         return m_shouldAutoResize;
     }
 
-    WebCore::IntSize minAutoSize() const
+    blink::IntSize minAutoSize() const
     {
         return m_minAutoSize;
     }
 
-    WebCore::IntSize maxAutoSize() const
+    blink::IntSize maxAutoSize() const
     {
         return m_maxAutoSize;
     }
 
     void updateMainFrameLayoutSize();
-    void updatePageDefinedViewportConstraints(const WebCore::ViewportDescription&);
+    void updatePageDefinedViewportConstraints(const blink::ViewportDescription&);
 
     // Start a system drag and drop operation.
     void startDragging(
-        WebCore::LocalFrame*,
+        blink::LocalFrame*,
         const WebDragData& dragData,
         WebDragOperationsMask mask,
         const WebImage& dragImage,
         const WebPoint& dragImageOffset);
 
     // Notification that a popup was opened/closed.
     void popupOpened(PopupContainer*);
     void popupClosed(PopupContainer*);
     // PagePopupDriver functions.
-    virtual WebCore::PagePopup* openPagePopup(WebCore::PagePopupClient*, const WebCore::IntRect& originBoundsInRootView) OVERRIDE;
-    virtual void closePagePopup(WebCore::PagePopup*) OVERRIDE;
+    virtual blink::PagePopup* openPagePopup(blink::PagePopupClient*, const blink::IntRect& originBoundsInRootView) OVERRIDE;
+    virtual void closePagePopup(blink::PagePopup*) OVERRIDE;
 
     // Returns the input event we're currently processing. This is used in some
     // cases where the WebCore DOM event doesn't have the information we need.
     static const WebInputEvent* currentInputEvent()
     {
         return m_currentInputEvent;
     }
 
-    WebCore::GraphicsLayer* rootGraphicsLayer();
-    void setRootGraphicsLayer(WebCore::GraphicsLayer*);
+    blink::GraphicsLayer* rootGraphicsLayer();
+    void setRootGraphicsLayer(blink::GraphicsLayer*);
     void scheduleCompositingLayerSync();
     void scrollRootLayer();
-    WebCore::GraphicsLayerFactory* graphicsLayerFactory() const;
-    WebCore::RenderLayerCompositor* compositor() const;
+    blink::GraphicsLayerFactory* graphicsLayerFactory() const;
+    blink::RenderLayerCompositor* compositor() const;
     void registerForAnimations(WebLayer*);
     void scheduleAnimation();
 
     virtual void setVisibilityState(WebPageVisibilityState, bool) OVERRIDE;
 
     PopupContainer* selectPopup() const { return m_selectPopup.get(); }
     bool hasOpenedPopup() const { return m_selectPopup || m_pagePopup; }
 
     // Returns true if the event leads to scrolling.
     static bool mapKeyCodeForScroll(int keyCode,
-                                   WebCore::ScrollDirection* scrollDirection,
-                                   WebCore::ScrollGranularity* scrollGranularity);
+                                   blink::ScrollDirection* scrollDirection,
+                                   blink::ScrollGranularity* scrollGranularity);
 
     // Called by a full frame plugin inside this view to inform it that its
     // zoom level has been updated.  The plugin should only call this function
     // if the zoom change was triggered by the browser, it's only needed in case
     // a plugin can update its own zoom, say because of its own UI.
     void fullFramePluginZoomLevelChanged(double zoomLevel);
 
     void computeScaleAndScrollForBlockRect(const WebPoint& hitPoint, const WebRect& blockRect, float padding, float defaultScaleWhenAlreadyLegible, float& scale, WebPoint& scroll);
-    WebCore::Node* bestTapNode(const WebCore::PlatformGestureEvent& tapEvent);
-    void enableTapHighlightAtPoint(const WebCore::PlatformGestureEvent& tapEvent);
-    void enableTapHighlights(WillBeHeapVector<RawPtrWillBeMember<WebCore::Node> >&);
-    void computeScaleAndScrollForFocusedNode(WebCore::Node* focusedNode, float& scale, WebCore::IntPoint& scroll, bool& needAnimation);
+    blink::Node* bestTapNode(const blink::PlatformGestureEvent& tapEvent);
+    void enableTapHighlightAtPoint(const blink::PlatformGestureEvent& tapEvent);
+    void enableTapHighlights(WillBeHeapVector<RawPtrWillBeMember<blink::Node> >&);
+    void computeScaleAndScrollForFocusedNode(blink::Node* focusedNode, float& scale, blink::IntPoint& scroll, bool& needAnimation);
 
-    void animateDoubleTapZoom(const WebCore::IntPoint&);
+    void animateDoubleTapZoom(const blink::IntPoint&);
 
     void enableFakePageScaleAnimationForTesting(bool);
     bool fakeDoubleTapAnimationPendingForTesting() const { return m_doubleTapZoomPending; }
-    WebCore::IntPoint fakePageScaleAnimationTargetPositionForTesting() const { return m_fakePageScaleAnimationTargetPosition; }
+    blink::IntPoint fakePageScaleAnimationTargetPositionForTesting() const { return m_fakePageScaleAnimationTargetPosition; }
     float fakePageScaleAnimationPageScaleForTesting() const { return m_fakePageScaleAnimationPageScaleFactor; }
     bool fakePageScaleAnimationUseAnchorForTesting() const { return m_fakePageScaleAnimationUseAnchor; }
 
-    void enterFullScreenForElement(WebCore::Element*);
-    void exitFullScreenForElement(WebCore::Element*);
+    void enterFullScreenForElement(blink::Element*);
+    void exitFullScreenForElement(blink::Element*);
 
     void clearCompositedSelectionBounds();
 
     // Exposed for the purpose of overriding device metrics.
     void sendResizeEventAndRepaint();
 
     // Exposed for testing purposes.
     bool hasHorizontalScrollbar();
     bool hasVerticalScrollbar();
 
     // Pointer Lock calls allow a page to capture all mouse events and
     // disable the system cursor.
     bool requestPointerLock();
     void requestPointerUnlock();
     bool isPointerLocked();
 
     // Heuristic-based function for determining if we should disable workarounds
     // for viewing websites that are not optimized for mobile devices.
     bool shouldDisableDesktopWorkarounds();
 
     // Exposed for tests.
     unsigned numLinkHighlights() { return m_linkHighlights.size(); }
     LinkHighlight* linkHighlight(int i) { return m_linkHighlights[i].get(); }
 
     WebSettingsImpl* settingsImpl();
 
     // Returns the bounding box of the block type node touched by the WebRect.
     WebRect computeBlockBounds(const WebRect&, bool ignoreClipping);
 
-    WebCore::IntPoint clampOffsetAtScale(const WebCore::IntPoint& offset, float scale);
+    blink::IntPoint clampOffsetAtScale(const blink::IntPoint& offset, float scale);
 
     // Exposed for tests.
     WebVector<WebCompositionUnderline> compositionUnderlines() const;
 
     WebLayerTreeView* layerTreeView() const { return m_layerTreeView; }
 
     bool pinchVirtualViewportEnabled() const;
 
     bool matchesHeuristicsForGpuRasterizationForTesting() const { return m_matchesHeuristicsForGpuRasterization; }
 
 private:
     // TODO(bokan): Remains for legacy pinch. Remove once it's gone. Made private to
     // prevent external usage
     virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin) OVERRIDE;
 
     float legibleScale() const;
     void refreshPageScaleFactorAfterLayout();
     void resumeTreeViewCommits();
-    void setUserAgentPageScaleConstraints(WebCore::PageScaleConstraints newConstraints);
+    void setUserAgentPageScaleConstraints(blink::PageScaleConstraints newConstraints);
     float clampPageScaleFactorToLimits(float) const;
-    WebCore::IntSize contentsSize() const;
+    blink::IntSize contentsSize() const;
 
     void resetSavedScrollAndScaleState();
 
-    void updateMainFrameScrollPosition(const WebCore::IntPoint& scrollPosition, bool programmaticScroll);
+    void updateMainFrameScrollPosition(const blink::IntPoint& scrollPosition, bool programmaticScroll);
 
     void performResize();
 
     friend class WebView;  // So WebView::Create can call our constructor
     friend class WTF::RefCounted<WebViewImpl>;
     friend void setCurrentInputEventForTest(const WebInputEvent*);
 
     enum DragAction {
       DragEnter,
       DragOver
@@ skipping 11 matching lines @@
 
     bool confirmComposition(const WebString& text, ConfirmCompositionBehavior);
 
     // Returns true if the view was scrolled.
     bool scrollViewWithKeyboard(int keyCode, int modifiers);
 
     void hideSelectPopup();
 
     // Converts |pos| from window coordinates to contents coordinates and gets
     // the HitTestResult for it.
-    WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&);
+    blink::HitTestResult hitTestResultForWindowPos(const blink::IntPoint&);
 
     // Consolidate some common code between starting a drag over a target and
     // updating a drag over a target. If we're starting a drag, |isEntering|
     // should be true.
     WebDragOperation dragTargetDragEnterOrOver(const WebPoint& clientPoint,
                                                const WebPoint& screenPoint,
                                                DragAction,
                                                int keyModifiers);
 
     void configureAutoResizeMode();
 
     void setIsAcceleratedCompositingActive(bool);
     void doComposite();
     void reallocateRenderer();
     void updateLayerTreeViewport();
     void updateLayerTreeBackgroundColor();
     void updateRootLayerTransform();
     void updateLayerTreeDeviceScaleFactor();
 
     // Helper function: Widens the width of |source| by the specified margins
     // while keeping it smaller than page width.
     WebRect widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin);
 
     void pointerLockMouseEvent(const WebInputEvent&);
 
     // PageWidgetEventHandler functions
-    virtual void handleMouseLeave(WebCore::LocalFrame&, const WebMouseEvent&) OVERRIDE;
-    virtual void handleMouseDown(WebCore::LocalFrame&, const WebMouseEvent&) OVERRIDE;
-    virtual void handleMouseUp(WebCore::LocalFrame&, const WebMouseEvent&) OVERRIDE;
-    virtual bool handleMouseWheel(WebCore::LocalFrame&, const WebMouseWheelEvent&) OVERRIDE;
+    virtual void handleMouseLeave(blink::LocalFrame&, const WebMouseEvent&) OVERRIDE;
+    virtual void handleMouseDown(blink::LocalFrame&, const WebMouseEvent&) OVERRIDE;
+    virtual void handleMouseUp(blink::LocalFrame&, const WebMouseEvent&) OVERRIDE;
+    virtual bool handleMouseWheel(blink::LocalFrame&, const WebMouseWheelEvent&) OVERRIDE;
     virtual bool handleGestureEvent(const WebGestureEvent&) OVERRIDE;
     virtual bool handleKeyEvent(const WebKeyboardEvent&) OVERRIDE;
     virtual bool handleCharEvent(const WebKeyboardEvent&) OVERRIDE;
 
-    WebCore::InputMethodContext* inputMethodContext();
-    WebPlugin* focusedPluginIfInputMethodSupported(WebCore::LocalFrame*);
+    blink::InputMethodContext* inputMethodContext();
+    WebPlugin* focusedPluginIfInputMethodSupported(blink::LocalFrame*);
 
     WebViewClient* m_client; // Can be 0 (e.g. unittests, shared workers, etc.)
     WebAutofillClient* m_autofillClient;
     WebSpellCheckClient* m_spellCheckClient;
 
     ChromeClientImpl m_chromeClientImpl;
     ContextMenuClientImpl m_contextMenuClientImpl;
     DragClientImpl m_dragClientImpl;
     EditorClientImpl m_editorClientImpl;
     InspectorClientImpl m_inspectorClientImpl;
     BackForwardClientImpl m_backForwardClientImpl;
     SpellCheckerClientImpl m_spellCheckerClientImpl;
     StorageClientImpl m_storageClientImpl;
 
     WebSize m_size;
     bool m_fixedLayoutSizeLock;
     // If true, automatically resize the render view around its content.
     bool m_shouldAutoResize;
     // The lower bound on the size when auto-resizing.
-    WebCore::IntSize m_minAutoSize;
+    blink::IntSize m_minAutoSize;
     // The upper bound on the size when auto-resizing.
-    WebCore::IntSize m_maxAutoSize;
+    blink::IntSize m_maxAutoSize;
 
-    OwnPtrWillBePersistent<WebCore::Page> m_page;
+    OwnPtrWillBePersistent<blink::Page> m_page;
 
     // An object that can be used to manipulate m_page->settings() without linking
     // against WebCore. This is lazily allocated the first time GetWebSettings()
     // is called.
     OwnPtr<WebSettingsImpl> m_webSettings;
 
     // A copy of the web drop data object we received from the browser.
-    RefPtrWillBePersistent<WebCore::DataObject> m_currentDragData;
+    RefPtrWillBePersistent<blink::DataObject> m_currentDragData;
 
     // The point relative to the client area where the mouse was last pressed
     // down. This is used by the drag client to determine what was under the
     // mouse when the drag was initiated. We need to track this here in
     // WebViewImpl since DragClient::startDrag does not pass the position the
     // mouse was at when the drag was initiated, only the current point, which
     // can be misleading as it is usually not over the element the user actually
     // dragged by the time a drag is initiated.
     WebPoint m_lastMouseDownPoint;
 
     // Keeps track of the current zoom level. 0 means no zoom, positive numbers
     // mean zoom in, negative numbers mean zoom out.
     double m_zoomLevel;
 
     double m_minimumZoomLevel;
 
     double m_maximumZoomLevel;
 
     PageScaleConstraintsSet m_pageScaleConstraintsSet;
 
     // The scale moved to by the latest double tap zoom, if any.
     float m_doubleTapZoomPageScaleFactor;
     // Have we sent a double-tap zoom and not yet heard back the scale?
     bool m_doubleTapZoomPending;
 
     // Used for testing purposes.
     bool m_enableFakePageScaleAnimationForTesting;
-    WebCore::IntPoint m_fakePageScaleAnimationTargetPosition;
+    blink::IntPoint m_fakePageScaleAnimationTargetPosition;
     float m_fakePageScaleAnimationPageScaleFactor;
     bool m_fakePageScaleAnimationUseAnchor;
 
     bool m_contextMenuAllowed;
 
     bool m_doingDragAndDrop;
 
     bool m_ignoreInputEvents;
 
     float m_compositorDeviceScaleFactorOverride;
@@ skipping 32 matching lines @@
     // Whether the user can press tab to focus links.
     bool m_tabsToLinks;
 
     // Inspector settings.
     WebString m_inspectorSettings;
 
     typedef HashMap<WTF::String, WTF::String> SettingsMap;
     OwnPtr<SettingsMap> m_inspectorSettingsMap;
 
     // If set, the (plugin) node which has mouse capture.
-    RefPtrWillBePersistent<WebCore::Node> m_mouseCaptureNode;
-    RefPtr<WebCore::UserGestureToken> m_mouseCaptureGestureToken;
+    RefPtrWillBePersistent<blink::Node> m_mouseCaptureNode;
+    RefPtr<blink::UserGestureToken> m_mouseCaptureGestureToken;
 
-    WebCore::IntRect m_rootLayerScrollDamage;
+    blink::IntRect m_rootLayerScrollDamage;
     WebLayerTreeView* m_layerTreeView;
     WebLayer* m_rootLayer;
-    WebCore::GraphicsLayer* m_rootGraphicsLayer;
-    WebCore::GraphicsLayer* m_rootTransformLayer;
-    OwnPtr<WebCore::GraphicsLayerFactory> m_graphicsLayerFactory;
+    blink::GraphicsLayer* m_rootGraphicsLayer;
+    blink::GraphicsLayer* m_rootTransformLayer;
+    OwnPtr<blink::GraphicsLayerFactory> m_graphicsLayerFactory;
     bool m_isAcceleratedCompositingActive;
     bool m_layerTreeViewCommitsDeferred;
     bool m_layerTreeViewClosed;
     bool m_matchesHeuristicsForGpuRasterization;
     // If true, the graphics context is being restored.
     bool m_recreatingGraphicsContext;
     static const WebInputEvent* m_currentInputEvent;
 
     MediaKeysClientImpl m_mediaKeysClientImpl;
     OwnPtr<WebActiveGestureAnimation> m_gestureAnimation;
@@ skipping 16 matching lines @@
     bool m_userGestureObserved;
 };
 
 // We have no ways to check if the specified WebView is an instance of
 // WebViewImpl because WebViewImpl is the only implementation of WebView.
 DEFINE_TYPE_CASTS(WebViewImpl, WebView, webView, true, true);
 
 } // namespace blink
 
 #endif