Rename WebCore namespace to blink in bindings and web

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 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 150 matching lines @@
 #include "wtf/TemporaryChange.h"
 
 #if USE(DEFAULT_RENDER_THEME)
 #include "core/rendering/RenderThemeChromiumDefault.h"
 #endif
 
 // Get rid of WTF's pow define so we can use std::pow.
 #undef pow
 #include <cmath> // for std::pow
 
-using namespace WebCore;
+using namespace blink;
 
 // The following constants control parameters for automated scaling of webpages
 // (such as due to a double tap gesture or find in page etc.). These are
 // experimentally determined.
 static const int touchPointPadding = 32;
 static const int nonUserInitiatedPointPadding = 11;
 static const float minScaleDifference = 0.01f;
 static const float doubleTapZoomContentDefaultMargin = 5;
 static const float doubleTapZoomContentMinimumMargin = 2;
 static const double doubleTapZoomAnimationDurationInSeconds = 0.25;
@@ skipping 43 matching lines @@
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationMove);
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete);
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery);
 
 static bool shouldUseExternalPopupMenus = false;
 
 static int webInputEventKeyStateToPlatformEventKeyState(int webInputEventKeyState)
 {
     int platformEventKeyState = 0;
     if (webInputEventKeyState & WebInputEvent::ShiftKey)
-        platformEventKeyState = platformEventKeyState | WebCore::PlatformEvent::ShiftKey;
+        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::ShiftKey;
     if (webInputEventKeyState & WebInputEvent::ControlKey)
-        platformEventKeyState = platformEventKeyState | WebCore::PlatformEvent::CtrlKey;
+        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::CtrlKey;
     if (webInputEventKeyState & WebInputEvent::AltKey)
-        platformEventKeyState = platformEventKeyState | WebCore::PlatformEvent::AltKey;
+        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::AltKey;
     if (webInputEventKeyState & WebInputEvent::MetaKey)
-        platformEventKeyState = platformEventKeyState | WebCore::PlatformEvent::MetaKey;
+        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::MetaKey;
     return platformEventKeyState;
 }
 
 namespace {
 
 class UserGestureNotifier {
 public:
     // If a UserGestureIndicator is created for a user gesture during the
     // lifetime of a UserGestureNotifier and *userGestureObserved is false,
     // the object will notify the client and set *userGestureObserved to true.
@@ skipping 332 matching lines @@
 bool WebViewImpl::handleMouseWheel(LocalFrame& mainFrame, const WebMouseWheelEvent& event)
 {
     hidePopups();
     return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
 }
 
 bool WebViewImpl::scrollBy(const WebFloatSize& delta, const WebFloatSize& velocity)
 {
     if (m_flingSourceDevice == WebGestureDeviceTouchpad) {
         WebMouseWheelEvent syntheticWheel;
-        const float tickDivisor = WebCore::WheelEvent::TickMultiplier;
+        const float tickDivisor = blink::WheelEvent::TickMultiplier;
 
         syntheticWheel.deltaX = delta.width;
         syntheticWheel.deltaY = delta.height;
         syntheticWheel.wheelTicksX = delta.width / tickDivisor;
         syntheticWheel.wheelTicksY = delta.height / tickDivisor;
         syntheticWheel.hasPreciseScrollingDeltas = true;
         syntheticWheel.x = m_positionOnFlingStart.x;
         syntheticWheel.y = m_positionOnFlingStart.y;
         syntheticWheel.globalX = m_globalPositionOnFlingStart.x;
         syntheticWheel.globalY = m_globalPositionOnFlingStart.y;
@@ skipping 822 matching lines @@
     if (!mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity))
         return false;
 
     LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return false;
     return frame->eventHandler().bubblingScroll(scrollDirection, scrollGranularity);
 }
 
 bool WebViewImpl::mapKeyCodeForScroll(int keyCode,
-                                      WebCore::ScrollDirection* scrollDirection,
-                                      WebCore::ScrollGranularity* scrollGranularity)
+                                      blink::ScrollDirection* scrollDirection,
+                                      blink::ScrollGranularity* scrollGranularity)
 {
     switch (keyCode) {
     case VKEY_LEFT:
         *scrollDirection = ScrollLeft;
         *scrollGranularity = ScrollByLine;
         break;
     case VKEY_RIGHT:
         *scrollDirection = ScrollRight;
         *scrollGranularity = ScrollByLine;
         break;
@@ skipping 142 matching lines @@
     page()->frameHost().pinchViewport().setSize(newSize);
 }
 
 WebLocalFrameImpl* WebViewImpl::localFrameRootTemporary() const
 {
     // FIXME: This is a temporary method that finds the first localFrame in a traversal.
     // This is equivalent to mainFrame() if the mainFrame is in-process. We need to create
     // separate WebWidgets to be created by RenderWidgets, which are associated with *all*
     // local frame roots, not just the first one in the tree. Until then, this limits us
     // to having only one functioning connected LocalFrame subtree per process.
-    for (WebCore::Frame* frame = page()->mainFrame(); frame; frame = frame->tree().traverseNext()) {
+    for (blink::Frame* frame = page()->mainFrame(); frame; frame = frame->tree().traverseNext()) {
         if (frame->isLocalRoot())
             return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
     }
     return 0;
 }
 
 void WebViewImpl::performResize()
 {
     m_pageScaleConstraintsSet.didChangeViewSize(m_size);
 
@@ skipping 213 matching lines @@
     if (!page())
         return;
     if (!page()->mainFrame()->isLocalFrame())
         return;
     FrameView* view = page()->deprecatedLocalMainFrame()->view();
 
     WebRect damagedRect(0, 0, m_size.width, m_size.height);
     view->invalidateRect(damagedRect);
 }
 
-void WebViewImpl::enterFullScreenForElement(WebCore::Element* element)
+void WebViewImpl::enterFullScreenForElement(blink::Element* element)
 {
     m_fullscreenController->enterFullScreenForElement(element);
 }
 
-void WebViewImpl::exitFullScreenForElement(WebCore::Element* element)
+void WebViewImpl::exitFullScreenForElement(blink::Element* element)
 {
     m_fullscreenController->exitFullScreenForElement(element);
 }
 
 void WebViewImpl::clearCompositedSelectionBounds()
 {
     if (m_layerTreeView)
         m_layerTreeView->clearSelection();
 }
 
@@ skipping 1710 matching lines @@
     if (LocalFrame* focusedFrame = toLocalFrame(page()->focusController().focusedOrMainFrame()))
         focusedFrame->eventHandler().sendContextMenuEventForKey();
     m_contextMenuAllowed = false;
 }
 
 void WebViewImpl::getSmartClipData(WebRect rect, WebString& clipText, WebRect& clipRect)
 {
     LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return;
-    SmartClipData clipData = WebCore::SmartClip(frame).dataForRect(rect);
+    SmartClipData clipData = blink::SmartClip(frame).dataForRect(rect);
     clipText = clipData.clipData();
     clipRect = clipData.rect();
 }
 
 void WebViewImpl::extractSmartClipData(WebRect rect, WebString& clipText, WebString& clipHtml, WebRect& clipRect)
 {
     LocalFrame* localFrame = toLocalFrame(focusedWebCoreFrame());
     if (!localFrame)
         return;
-    SmartClipData clipData = WebCore::SmartClip(localFrame).dataForRect(rect);
+    SmartClipData clipData = blink::SmartClip(localFrame).dataForRect(rect);
     clipText = clipData.clipData();
     clipRect = clipData.rect();
 
     WebLocalFrameImpl* frame = mainFrameImpl();
     if (!frame)
         return;
     WebPoint startPoint(rect.x, rect.y);
     WebPoint endPoint(rect.x + rect.width, rect.y + rect.height);
     VisiblePosition startVisiblePosition = frame->visiblePositionForWindowPoint(startPoint);
     VisiblePosition endVisiblePosition = frame->visiblePositionForWindowPoint(endPoint);
@@ skipping 84 matching lines @@
     RenderTheme::theme().platformColorsDidChange();
 #endif
 }
 
 void WebView::injectStyleSheet(const WebString& sourceCode, const WebVector<WebString>& patternsIn, WebView::StyleInjectionTarget injectIn)
 {
     Vector<String> patterns;
     for (size_t i = 0; i < patternsIn.size(); ++i)
         patterns.append(patternsIn[i]);
 
-    InjectedStyleSheets::instance().add(sourceCode, patterns, static_cast<WebCore::StyleInjectionTarget>(injectIn));
+    InjectedStyleSheets::instance().add(sourceCode, patterns, static_cast<blink::StyleInjectionTarget>(injectIn));
 }
 
 void WebView::removeInjectedStyleSheets()
 {
     InjectedStyleSheets::instance().removeAll();
 }
 
 void WebViewImpl::didCommitLoad(bool isNewNavigation, bool isNavigationWithinPage)
 {
     if (isNewNavigation && !isNavigationWithinPage)
@@ skipping 112 matching lines @@
 
     m_pageOverlays->add(overlay, zOrder);
 }
 
 void WebViewImpl::removePageOverlay(WebPageOverlay* overlay)
 {
     if (m_pageOverlays && m_pageOverlays->remove(overlay) && m_pageOverlays->empty())
         m_pageOverlays = nullptr;
 }
 
-void WebViewImpl::setOverlayLayer(WebCore::GraphicsLayer* layer)
+void WebViewImpl::setOverlayLayer(blink::GraphicsLayer* layer)
 {
     if (!m_rootGraphicsLayer)
         return;
 
     if (!m_page->mainFrame()->isLocalFrame())
         return;
 
     if (pinchVirtualViewportEnabled()) {
         m_page->deprecatedLocalMainFrame()->view()->renderView()->compositor()->setOverlayLayer(layer);
         return;
@@ skipping 109 matching lines @@
 
 void WebViewImpl::invalidateRect(const IntRect& rect)
 {
     if (m_isAcceleratedCompositingActive) {
         ASSERT(m_layerTreeView);
         updateLayerTreeViewport();
     } else if (m_client)
         m_client->didInvalidateRect(rect);
 }
 
-WebCore::GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
+blink::GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
 {
     return m_graphicsLayerFactory.get();
 }
 
-WebCore::RenderLayerCompositor* WebViewImpl::compositor() const
+blink::RenderLayerCompositor* WebViewImpl::compositor() const
 {
     if (!page() || !page()->mainFrame())
         return 0;
 
     if (!page()->mainFrame()->isLocalFrame())
         return localFrameRootTemporary()->frame()->document()->renderView()->compositor();
 
     if (!page()->deprecatedLocalMainFrame()->document() || !page()->deprecatedLocalMainFrame()->document()->renderView())
         return 0;
 
     return page()->deprecatedLocalMainFrame()->document()->renderView()->compositor();
 }
 
 void WebViewImpl::registerForAnimations(WebLayer* layer)
 {
     if (m_layerTreeView)
         m_layerTreeView->registerForAnimations(layer);
 }
 
-WebCore::GraphicsLayer* WebViewImpl::rootGraphicsLayer()
+blink::GraphicsLayer* WebViewImpl::rootGraphicsLayer()
 {
     return m_rootGraphicsLayer;
 }
 
 void WebViewImpl::scheduleAnimation()
 {
     if (isAcceleratedCompositingActive()) {
         ASSERT(m_layerTreeView);
         m_layerTreeView->setNeedsAnimate();
         return;
@@ skipping 158 matching lines @@
     // or update the transform layer.
     if (!m_rootGraphicsLayer)
         return;
 
     // FIXME(bokan): m_rootTransformLayer is always set here in pinch virtual viewport. This can go away once
     // that's default everywhere.
     if (!m_rootTransformLayer && m_page->mainFrame()->isLocalFrame())
         m_rootTransformLayer = m_page->deprecatedLocalMainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
 
     if (m_rootTransformLayer) {
-        WebCore::TransformationMatrix transform;
+        blink::TransformationMatrix transform;
         transform.translate(m_rootLayerOffset.width, m_rootLayerOffset.height);
         transform = transform.scale(m_rootLayerScale);
         m_rootTransformLayer->setTransform(transform);
     }
 }
 
 bool WebViewImpl::detectContentOnTouch(const WebPoint& position)
 {
     HitTestResult touchHit = hitTestResultForWindowPos(position);
 
@@ skipping 87 matching lines @@
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return false;
 
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace blink