Cleanup namespace usage in Source/web/Web[I-Z]*.cpp

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 151 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 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;
 static const float doubleTapZoomAlreadyLegibleRatio = 1.2f;
@@ skipping 42 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 | blink::PlatformEvent::ShiftKey;
+        platformEventKeyState = platformEventKeyState | PlatformEvent::ShiftKey;
     if (webInputEventKeyState & WebInputEvent::ControlKey)
-        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::CtrlKey;
+        platformEventKeyState = platformEventKeyState | PlatformEvent::CtrlKey;
     if (webInputEventKeyState & WebInputEvent::AltKey)
-        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::AltKey;
+        platformEventKeyState = platformEventKeyState | PlatformEvent::AltKey;
     if (webInputEventKeyState & WebInputEvent::MetaKey)
-        platformEventKeyState = platformEventKeyState | blink::PlatformEvent::MetaKey;
+        platformEventKeyState = platformEventKeyState | PlatformEvent::MetaKey;
     return platformEventKeyState;
 }
 
 namespace {
 
 class UserGestureNotifier {
 public:
     // If a UserGestureIndicator is created for a user gesture since the last
     // page load and *userGestureObserved is false, the UserGestureNotifier
     // will notify the client and set *userGestureObserved to true.
@@ skipping 330 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 = blink::WheelEvent::TickMultiplier;
+        const float tickDivisor = 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 839 matching lines @@
 #endif
     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,
-                                      blink::ScrollDirection* scrollDirection,
-                                      blink::ScrollGranularity* scrollGranularity)
+bool WebViewImpl::mapKeyCodeForScroll(
+    int keyCode,
+    ScrollDirection* scrollDirection,
+    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 (blink::Frame* frame = page()->mainFrame(); frame; frame = frame->tree().traverseNext()) {
+    for (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 152 matching lines @@
 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
 {
     // This should only be used when compositing is not being used for this
     // WebView, and it is painting into the recording of its parent.
     ASSERT(!isAcceleratedCompositingActive());
 
     double paintStart = currentTime();
     PageWidgetDelegate::paint(m_page.get(), pageOverlays(), canvas, rect, isTransparent() ? PageWidgetDelegate::Translucent : PageWidgetDelegate::Opaque);
     double paintEnd = currentTime();
     double pixelsPerSec = (rect.width * rect.height) / (paintEnd - paintStart);
-    blink::Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintDurationMS", (paintEnd - paintStart) * 1000, 0, 120, 30);
-    blink::Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintMegapixPerSecond", pixelsPerSec / 1000000, 10, 210, 30);
+    Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintDurationMS", (paintEnd - paintStart) * 1000, 0, 120, 30);
+    Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintMegapixPerSecond", pixelsPerSec / 1000000, 10, 210, 30);
 }
 
 #if OS(ANDROID)
 void WebViewImpl::paintCompositedDeprecated(WebCanvas* canvas, const WebRect& rect)
 {
     // Note: This method exists on OS(ANDROID) and will hopefully be
     //       removed once the link disambiguation feature renders using
     //       the compositor.
     ASSERT(isAcceleratedCompositingActive());
 
@@ skipping 28 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(blink::Element* element)
+void WebViewImpl::enterFullScreenForElement(Element* element)
 {
     m_fullscreenController->enterFullScreenForElement(element);
 }
 
-void WebViewImpl::exitFullScreenForElement(blink::Element* element)
+void WebViewImpl::exitFullScreenForElement(Element* element)
 {
     m_fullscreenController->exitFullScreenForElement(element);
 }
 
 void WebViewImpl::clearCompositedSelectionBounds()
 {
     if (m_layerTreeView)
         m_layerTreeView->clearSelection();
 }
 
@@ skipping 1439 matching lines @@
 {
     if (!m_page)
         return;
 
     KURL url = hitTestResultForWindowPos(point).absoluteImageURLIncludingCanvasDataURL();
 
     if (url.isEmpty())
         return;
 
     ResourceRequest request(url);
-    request.setRequestContext(blink::WebURLRequest::RequestContextDownload);
+    request.setRequestContext(WebURLRequest::RequestContextDownload);
     m_page->deprecatedLocalMainFrame()->loader().client()->loadURLExternally(
         request, NavigationPolicyDownloadTo, WebString());
 }
 
 void WebViewImpl::dragSourceEndedAt(
     const WebPoint& clientPoint,
     const WebPoint& screenPoint,
     WebDragOperation operation)
 {
     PlatformMouseEvent pme(clientPoint,
@@ skipping 251 matching lines @@
     if (LocalFrame* focusedFrame = toLocalFrame(page()->focusController().focusedOrMainFrame()))
         focusedFrame->eventHandler().sendContextMenuEventForKey();
     m_contextMenuAllowed = false;
 }
 
 void WebViewImpl::extractSmartClipData(WebRect rect, WebString& clipText, WebString& clipHtml, WebRect& clipRect)
 {
     LocalFrame* localFrame = toLocalFrame(focusedWebCoreFrame());
     if (!localFrame)
         return;
-    SmartClipData clipData = blink::SmartClip(localFrame).dataForRect(rect);
+    SmartClipData clipData = 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 230 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(blink::GraphicsLayer* layer)
+void WebViewImpl::setOverlayLayer(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);
 }
 
-blink::GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
+GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
 {
     return m_graphicsLayerFactory.get();
 }
 
-blink::RenderLayerCompositor* WebViewImpl::compositor() const
+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);
 }
 
-blink::GraphicsLayer* WebViewImpl::rootGraphicsLayer()
+GraphicsLayer* WebViewImpl::rootGraphicsLayer()
 {
     return m_rootGraphicsLayer;
 }
 
 void WebViewImpl::scheduleAnimation()
 {
     if (isAcceleratedCompositingActive()) {
         ASSERT(m_layerTreeView);
         m_layerTreeView->setNeedsAnimate();
         return;
@@ skipping 18 matching lines @@
 
 void WebViewImpl::setIsAcceleratedCompositingActive(bool active)
 {
     // In the middle of shutting down; don't try to spin back up a compositor.
     // FIXME: compositing startup/shutdown should be refactored so that it
     // turns on explicitly rather than lazily, which causes this awkwardness.
     if (m_layerTreeViewClosed)
         return;
 
     ASSERT(!active || m_layerTreeView);
-    blink::Platform::current()->histogramEnumeration("GPU.setIsAcceleratedCompositingActive", active * 2 + m_isAcceleratedCompositingActive, 4);
+    Platform::current()->histogramEnumeration("GPU.setIsAcceleratedCompositingActive", active * 2 + m_isAcceleratedCompositingActive, 4);
 
     if (m_isAcceleratedCompositingActive == active)
         return;
 
     if (!m_client)
         return;
 
     if (!active) {
         m_isAcceleratedCompositingActive = false;
         if (!m_layerTreeViewCommitsDeferred) {
@@ skipping 117 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) {
-        blink::TransformationMatrix transform;
+        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