Cleanup namespace usage in Source/web/.

Source/web/tests/WebFrameTest.cpp

 /*
  * 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 89 matching lines @@
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/Forward.h"
 #include "wtf/dtoa/utils.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <map>
 #include <v8.h>
 
-using namespace blink;
-using blink::Document;
-using blink::DocumentMarker;
-using blink::Element;
-using blink::FloatRect;
-using blink::HitTestRequest;
-using blink::Range;
+namespace {
+
 using blink::URLTestHelpers::toKURL;
 using blink::FrameTestHelpers::runPendingTasks;
-
-namespace {
+using namespace blink;
 
 const int touchPointPadding = 32;
 
 #define EXPECT_EQ_RECT(a, b) \
     EXPECT_EQ(a.x(), b.x()); \
     EXPECT_EQ(a.y(), b.y()); \
     EXPECT_EQ(a.width(), b.width()); \
     EXPECT_EQ(a.height(), b.height());
 
 class FakeCompositingWebViewClient : public FrameTestHelpers::TestWebViewClient {
@@ skipping 19 matching lines @@
         URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(fileName.c_str()));
     }
 
     void registerMockedChromeURLLoad(const std::string& fileName)
     {
         URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_chromeURL.c_str()), WebString::fromUTF8(fileName.c_str()));
     }
 
     void applyViewportStyleOverride(FrameTestHelpers::WebViewHelper* webViewHelper)
     {
-        RefPtrWillBeRawPtr<blink::StyleSheetContents> styleSheet = blink::StyleSheetContents::create(blink::CSSParserContext(blink::UASheetMode, 0));
+        RefPtrWillBeRawPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(CSSParserContext(UASheetMode, 0));
         styleSheet->parseString(String(blink::viewportAndroidCss, sizeof(blink::viewportAndroidCss)));
-        OwnPtrWillBeRawPtr<blink::RuleSet> ruleSet = blink::RuleSet::create();
-        ruleSet->addRulesFromSheet(styleSheet.get(), blink::MediaQueryEvaluator("screen"));
+        OwnPtrWillBeRawPtr<RuleSet> ruleSet = RuleSet::create();
+        ruleSet->addRulesFromSheet(styleSheet.get(), MediaQueryEvaluator("screen"));
 
         Document* document = toLocalFrame(webViewHelper->webViewImpl()->page()->mainFrame())->document();
-        document->ensureStyleResolver().viewportStyleResolver()->collectViewportRules(ruleSet.get(), blink::ViewportStyleResolver::UserAgentOrigin);
+        document->ensureStyleResolver().viewportStyleResolver()->collectViewportRules(ruleSet.get(), ViewportStyleResolver::UserAgentOrigin);
         document->ensureStyleResolver().viewportStyleResolver()->resolve();
     }
 
     static void configueCompositingWebView(WebSettings* settings)
     {
         settings->setAcceleratedCompositingEnabled(true);
         settings->setPreferCompositingToLCDTextEnabled(true);
     }
 
     static void configureLoadsImagesAutomatically(WebSettings* settings)
     {
         settings->setLoadsImagesAutomatically(true);
     }
 
     void initializeTextSelectionWebView(const std::string& url, FrameTestHelpers::WebViewHelper* webViewHelper)
     {
         webViewHelper->initializeAndLoad(url, true);
         webViewHelper->webView()->settings()->setDefaultFontSize(12);
         webViewHelper->webView()->resize(WebSize(640, 480));
     }
 
-    PassOwnPtr<blink::DragImage> nodeImageTestSetup(FrameTestHelpers::WebViewHelper* webViewHelper, const std::string& testcase)
+    PassOwnPtr<DragImage> nodeImageTestSetup(FrameTestHelpers::WebViewHelper* webViewHelper, const std::string& testcase)
     {
         registerMockedHttpURLLoad("nodeimage.html");
         webViewHelper->initializeAndLoad(m_baseURL + "nodeimage.html");
         webViewHelper->webView()->resize(WebSize(640, 480));
         webViewHelper->webView()->layout();
-        RefPtr<blink::LocalFrame> frame = toLocalFrame(webViewHelper->webViewImpl()->page()->mainFrame());
-        blink::Element* element = frame->document()->getElementById(testcase.c_str());
+        RefPtr<LocalFrame> frame = toLocalFrame(webViewHelper->webViewImpl()->page()->mainFrame());
+        Element* element = frame->document()->getElementById(testcase.c_str());
         return frame->nodeImage(*element);
     }
 
     std::string m_baseURL;
     std::string m_chromeURL;
 };
 
 class UseMockScrollbarSettings {
 public:
     UseMockScrollbarSettings()
     {
-        blink::Settings::setMockScrollbarsEnabled(true);
-        blink::RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(true);
-        EXPECT_TRUE(blink::ScrollbarTheme::theme()->usesOverlayScrollbars());
+        Settings::setMockScrollbarsEnabled(true);
+        RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(true);
+        EXPECT_TRUE(ScrollbarTheme::theme()->usesOverlayScrollbars());
     }
 
     ~UseMockScrollbarSettings()
     {
-        blink::Settings::setMockScrollbarsEnabled(false);
-        blink::RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(false);
+        Settings::setMockScrollbarsEnabled(false);
+        RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(false);
     }
 };
 
 TEST_F(WebFrameTest, ContentText)
 {
     registerMockedHttpURLLoad("iframes_test.html");
     registerMockedHttpURLLoad("visible_iframe.html");
     registerMockedHttpURLLoad("invisible_iframe.html");
     registerMockedHttpURLLoad("zero_sized_iframe.html");
 
@@ skipping 414 matching lines @@
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_NE(std::string::npos, content.find("Message 1."));
     EXPECT_EQ(std::string::npos, content.find("Message 2."));
 }
 
 TEST_F(WebFrameTest, PostMessageThenDetach)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
 
-    RefPtr<blink::LocalFrame> frame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
-    blink::NonThrowableExceptionState exceptionState;
-    frame->domWindow()->postMessage(blink::SerializedScriptValue::create("message"), 0, "*", frame->domWindow(), exceptionState);
+    RefPtr<LocalFrame> frame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
+    NonThrowableExceptionState exceptionState;
+    frame->domWindow()->postMessage(SerializedScriptValue::create("message"), 0, "*", frame->domWindow(), exceptionState);
     webViewHelper.reset();
     EXPECT_FALSE(exceptionState.hadException());
 
     // Success is not crashing.
     runPendingTasks();
 }
 
 class FixedLayoutTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
  public:
     virtual WebScreenInfo screenInfo() OVERRIDE { return m_screenInfo; }
@@ skipping 19 matching lines @@
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     // Make sure we initialize to minimum scale, even if the window size
     // only becomes available after the load begins.
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
-    webViewHelper.webViewImpl()->setFixedLayoutSize(blink::IntSize(100, 100));
+    webViewHelper.webViewImpl()->setFixedLayoutSize(IntSize(100, 100));
     EXPECT_TRUE(webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->needsLayout());
 
     int prevLayoutCount = webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutCount();
-    webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->setFrameRect(blink::IntRect(0, 0, 641, 481));
+    webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->setFrameRect(IntRect(0, 0, 641, 481));
     EXPECT_EQ(prevLayoutCount, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutCount());
 
     webViewHelper.webViewImpl()->layout();
 }
 
 // Helper function to check or set text autosizing multipliers on a document.
 static bool checkOrSetTextAutosizingMultiplier(Document* document, float multiplier, bool setMultiplier)
 {
     bool multiplierCheckedOrSetAtLeastOnce = false;
-    for (blink::RenderObject* renderer = document->renderView(); renderer; renderer = renderer->nextInPreOrder()) {
+    for (RenderObject* renderer = document->renderView(); renderer; renderer = renderer->nextInPreOrder()) {
         if (renderer->style()) {
             if (setMultiplier)
                 renderer->style()->setTextAutosizingMultiplier(multiplier);
             EXPECT_EQ(multiplier, renderer->style()->textAutosizingMultiplier());
             multiplierCheckedOrSetAtLeastOnce = true;
         }
     }
     return multiplierCheckedOrSetAtLeastOnce;
 
 }
@@ skipping 13 matching lines @@
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
 
-    blink::Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
+    Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
     webViewHelper.webViewImpl()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webViewImpl()->layout();
 
     EXPECT_TRUE(setTextAutosizingMultiplier(document, 2));
 
-    blink::ViewportDescription description = document->viewportDescription();
+    ViewportDescription description = document->viewportDescription();
     // Choose a width that's not going match the viewport width of the loaded document.
-    description.minWidth = blink::Length(100, blink::Fixed);
-    description.maxWidth = blink::Length(100, blink::Fixed);
+    description.minWidth = Length(100, blink::Fixed);
+    description.maxWidth = Length(100, blink::Fixed);
     webViewHelper.webViewImpl()->updatePageDefinedViewportConstraints(description);
 
     EXPECT_TRUE(checkTextAutosizingMultiplier(document, 1));
 }
 
 TEST_F(WebFrameTest, SetFrameRectInvalidatesTextAutosizingMultipliers)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("iframe_reload.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
     FixedLayoutTestWebViewClient client;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_reload.html", true, 0, &client, enableViewportSettings);
 
-    blink::LocalFrame* mainFrame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
-    blink::Document* document = mainFrame->document();
-    blink::FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    LocalFrame* mainFrame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
+    Document* document = mainFrame->document();
+    FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     document->settings()->setTextAutosizingEnabled(true);
     EXPECT_TRUE(document->settings()->textAutosizingEnabled());
     webViewHelper.webViewImpl()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webViewImpl()->layout();
 
-    for (blink::Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext()) {
+    for (Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
         EXPECT_TRUE(setTextAutosizingMultiplier(toLocalFrame(frame)->document(), 2));
-        for (blink::RenderObject* renderer = toLocalFrame(frame)->document()->renderView(); renderer; renderer = renderer->nextInPreOrder()) {
+        for (RenderObject* renderer = toLocalFrame(frame)->document()->renderView(); renderer; renderer = renderer->nextInPreOrder()) {
             if (renderer->isText())
                 EXPECT_FALSE(renderer->needsLayout());
         }
     }
 
-    frameView->setFrameRect(blink::IntRect(0, 0, 200, 200));
-    for (blink::Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext()) {
+    frameView->setFrameRect(IntRect(0, 0, 200, 200));
+    for (Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
-        for (blink::RenderObject* renderer = toLocalFrame(frame)->document()->renderView(); renderer; renderer = renderer->nextInPreOrder()) {
+        for (RenderObject* renderer = toLocalFrame(frame)->document()->renderView(); renderer; renderer = renderer->nextInPreOrder()) {
             if (renderer->isText())
                 EXPECT_TRUE(renderer->needsLayout());
         }
     }
 }
 
 TEST_F(WebFrameTest, FixedLayoutSizeStopsResizeFromChangingLayoutSize)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
@@ skipping 246 matching lines @@
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "viewport-auto-initial-scale.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(0.25f, webViewHelper.webView()->pageScaleFactor());
 
-    blink::Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
-    blink::ViewportDescription description = document->viewportDescription();
+    Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
+    ViewportDescription description = document->viewportDescription();
     description.zoom = 2;
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(2, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, setLoadWithOverviewModeToFalse)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-auto-initial-scale.html");
@@ skipping 461 matching lines @@
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport/viewport-30.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(600, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(800, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 
     // The magic number to snap to device-width is 320, so test that 321 is
     // respected.
-    blink::Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
-    blink::ViewportDescription description = document->viewportDescription();
-    description.minWidth = blink::Length(321, blink::Fixed);
-    description.maxWidth = blink::Length(321, blink::Fixed);
+    Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
+    ViewportDescription description = document->viewportDescription();
+    description.minWidth = Length(321, blink::Fixed);
+    description.maxWidth = Length(321, blink::Fixed);
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(321, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
 
-    description.minWidth = blink::Length(320, blink::Fixed);
-    description.maxWidth = blink::Length(320, blink::Fixed);
+    description.minWidth = Length(320, blink::Fixed);
+    description.maxWidth = Length(320, blink::Fixed);
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(600, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
 
     description = document->viewportDescription();
-    description.maxHeight = blink::Length(1000, blink::Fixed);
+    description.maxHeight = Length(1000, blink::Fixed);
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(1000, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 
-    description.maxHeight = blink::Length(320, blink::Fixed);
+    description.maxHeight = Length(320, blink::Fixed);
     document->setViewportDescription(description);
     webViewHelper.webView()->layout();
     EXPECT_EQ(800, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
 }
 
 TEST_F(WebFrameTest, ZeroValuesQuirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-zero-values.html");
 
@@ skipping 26 matching lines @@
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
-    blink::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
-    EXPECT_FALSE(view->userInputScrollable(blink::VerticalScrollbar));
+    FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    EXPECT_FALSE(view->userInputScrollable(VerticalScrollbar));
 }
 
 TEST_F(WebFrameTest, IgnoreOverflowHiddenQuirk)
 {
     registerMockedHttpURLLoad("body-overflow-hidden.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client);
     webViewHelper.webView()->settings()->setIgnoreMainFrameOverflowHiddenQuirk(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
-    blink::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
-    EXPECT_TRUE(view->userInputScrollable(blink::VerticalScrollbar));
+    FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    EXPECT_TRUE(view->userInputScrollable(VerticalScrollbar));
 }
 
 TEST_F(WebFrameTest, NonZeroValuesNoQuirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-nonzero-values.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
@@ skipping 109 matching lines @@
     client.m_screenInfo.deviceScaleFactor = 1;
     // Small viewport to ensure there are always scrollbars.
     int viewportWidth = 64;
     int viewportHeight = 48;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "large-div.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
-    blink::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     int viewportWidthMinusScrollbar = viewportWidth - (view->verticalScrollbar()->isOverlayScrollbar() ? 0 : 15);
     int viewportHeightMinusScrollbar = viewportHeight - (view->horizontalScrollbar()->isOverlayScrollbar() ? 0 : 15);
 
     webViewHelper.webView()->setPageScaleFactor(2);
 
-    blink::IntSize unscaledSize = view->unscaledVisibleContentSize(blink::IncludeScrollbars);
+    IntSize unscaledSize = view->unscaledVisibleContentSize(IncludeScrollbars);
     EXPECT_EQ(viewportWidth, unscaledSize.width());
     EXPECT_EQ(viewportHeight, unscaledSize.height());
 
-    blink::IntSize unscaledSizeMinusScrollbar = view->unscaledVisibleContentSize(blink::ExcludeScrollbars);
+    IntSize unscaledSizeMinusScrollbar = view->unscaledVisibleContentSize(ExcludeScrollbars);
     EXPECT_EQ(viewportWidthMinusScrollbar, unscaledSizeMinusScrollbar.width());
     EXPECT_EQ(viewportHeightMinusScrollbar, unscaledSizeMinusScrollbar.height());
 
-    blink::IntSize scaledSize = view->visibleContentRect().size();
+    IntSize scaledSize = view->visibleContentRect().size();
     EXPECT_EQ(ceil(viewportWidthMinusScrollbar / 2.0), scaledSize.width());
     EXPECT_EQ(ceil(viewportHeightMinusScrollbar / 2.0), scaledSize.height());
 }
 
 TEST_F(WebFrameTest, pageScaleFactorDoesNotApplyCssTransform)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
@@ skipping 248 matching lines @@
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_NEAR(1.0f, webViewHelper.webView()->pageScaleFactor(), 0.01f);
     EXPECT_NEAR(1.0f, webViewHelper.webView()->minimumPageScaleFactor(), 0.01f);
     EXPECT_NEAR(5.0f, webViewHelper.webView()->maximumPageScaleFactor(), 0.01f);
 }
 
 class WebFrameResizeTest : public WebFrameTest {
 protected:
 
-    static blink::FloatSize computeRelativeOffset(const blink::IntPoint& absoluteOffset, const blink::LayoutRect& rect)
+    static FloatSize computeRelativeOffset(const IntPoint& absoluteOffset, const LayoutRect& rect)
     {
-        blink::FloatSize relativeOffset = blink::FloatPoint(absoluteOffset) - rect.location();
+        FloatSize relativeOffset = FloatPoint(absoluteOffset) - rect.location();
         relativeOffset.scale(1.f / rect.width(), 1.f / rect.height());
         return relativeOffset;
     }
 
     void testResizeYieldsCorrectScrollAndScale(const char* url,
                                                const float initialPageScaleFactor,
                                                const WebSize scrollOffset,
                                                const WebSize viewportSize,
                                                const bool shouldScaleRelativeToViewportWidth) {
         UseMockScrollbarSettings mockScrollbarSettings;
@@ skipping 34 matching lines @@
         // Generic resize preserves scrollOffset relative to anchor node located
         // the top center of the screen.
         {
             webViewHelper.webViewImpl()->resize(WebSize(viewportSize.height, viewportSize.width));
             float pageScaleFactor = webViewHelper.webViewImpl()->pageScaleFactor();
             webViewHelper.webViewImpl()->resize(WebSize(viewportSize.width, viewportSize.height));
             float expectedPageScaleFactor = pageScaleFactor * (shouldScaleRelativeToViewportWidth ? aspectRatio : 1);
             EXPECT_NEAR(expectedPageScaleFactor, webViewHelper.webViewImpl()->pageScaleFactor(), 0.05f);
             webViewHelper.webViewImpl()->mainFrame()->setScrollOffset(scrollOffset);
 
-            blink::IntPoint anchorPoint = blink::IntPoint(scrollOffset) + blink::IntPoint(viewportSize.width / 2, 0);
-            RefPtrWillBeRawPtr<blink::Node> anchorNode = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(anchorPoint, HitTestRequest::ReadOnly | HitTestRequest::Active).innerNode();
+            IntPoint anchorPoint = IntPoint(scrollOffset) + IntPoint(viewportSize.width / 2, 0);
+            RefPtrWillBeRawPtr<Node> anchorNode = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(anchorPoint, HitTestRequest::ReadOnly | HitTestRequest::Active).innerNode();
             ASSERT(anchorNode);
 
             pageScaleFactor = webViewHelper.webViewImpl()->pageScaleFactor();
-            const blink::FloatSize preResizeRelativeOffset
+            const FloatSize preResizeRelativeOffset
                 = computeRelativeOffset(anchorPoint, anchorNode->boundingBox());
             webViewHelper.webViewImpl()->resize(WebSize(viewportSize.height, viewportSize.width));
-            blink::IntPoint newAnchorPoint = blink::IntPoint(webViewHelper.webViewImpl()->mainFrame()->scrollOffset()) + blink::IntPoint(viewportSize.height / 2, 0);
-            const blink::FloatSize postResizeRelativeOffset
+            IntPoint newAnchorPoint = IntPoint(webViewHelper.webViewImpl()->mainFrame()->scrollOffset()) + IntPoint(viewportSize.height / 2, 0);
+            const FloatSize postResizeRelativeOffset
                 = computeRelativeOffset(newAnchorPoint, anchorNode->boundingBox());
             EXPECT_NEAR(preResizeRelativeOffset.width(), postResizeRelativeOffset.width(), 0.15f);
             expectedPageScaleFactor = pageScaleFactor * (shouldScaleRelativeToViewportWidth ? 1 / aspectRatio : 1);
             EXPECT_NEAR(expectedPageScaleFactor, webViewHelper.webViewImpl()->pageScaleFactor(), 0.05f);
         }
     }
 };
 
 TEST_F(WebFrameResizeTest, ResizeYieldsCorrectScrollAndScaleForWidthEqualsDeviceWidth)
 {
@@ skipping 72 matching lines @@
 
     // Set <1 page scale so that the clip rect should be larger than
     // the viewport size as passed into resize().
     webViewHelper.webView()->setPageScaleFactor(0.5);
 
     SkBitmap bitmap;
     ASSERT_TRUE(bitmap.allocN32Pixels(200, 200));
     bitmap.eraseColor(0);
     SkCanvas canvas(bitmap);
 
-    blink::GraphicsContext context(&canvas);
+    GraphicsContext context(&canvas);
     context.setRegionTrackingMode(GraphicsContext::RegionTrackingOpaque);
 
-    EXPECT_EQ_RECT(blink::IntRect(0, 0, 0, 0), context.opaqueRegion().asRect());
+    EXPECT_EQ_RECT(IntRect(0, 0, 0, 0), context.opaqueRegion().asRect());
 
-    blink::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
-    blink::IntRect paintRect(0, 0, 200, 200);
+    FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    IntRect paintRect(0, 0, 200, 200);
     view->paint(&context, paintRect);
 
     // FIXME: This test broke in release builds when changing the FixedLayoutTestWebViewClient
     // to return a non-null layerTreeView, which is what all our shipping configurations do,
     // so this is just exposing an existing bug.
     // crbug.com/365812
 #ifndef NDEBUG
     int viewportWidthMinusScrollbar = 50 - (view->verticalScrollbar()->isOverlayScrollbar() ? 0 : 15);
     int viewportHeightMinusScrollbar = 50 - (view->horizontalScrollbar()->isOverlayScrollbar() ? 0 : 15);
-    blink::IntRect clippedRect(0, 0, viewportWidthMinusScrollbar * 2, viewportHeightMinusScrollbar * 2);
+    IntRect clippedRect(0, 0, viewportWidthMinusScrollbar * 2, viewportHeightMinusScrollbar * 2);
     EXPECT_EQ_RECT(clippedRect, context.opaqueRegion().asRect());
 #endif
 }
 
 TEST_F(WebFrameTest, pageScaleFactorUpdatesScrollbars)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
     webViewHelper.webView()->layout();
 
-    blink::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
-    EXPECT_EQ(view->scrollSize(blink::HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
-    EXPECT_EQ(view->scrollSize(blink::VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
+    FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    EXPECT_EQ(view->scrollSize(HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
+    EXPECT_EQ(view->scrollSize(VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
 
     webViewHelper.webView()->setPageScaleFactor(10);
 
-    EXPECT_EQ(view->scrollSize(blink::HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
-    EXPECT_EQ(view->scrollSize(blink::VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
+    EXPECT_EQ(view->scrollSize(HorizontalScrollbar), view->contentsSize().width() - view->visibleContentRect().width());
+    EXPECT_EQ(view->scrollSize(VerticalScrollbar), view->contentsSize().height() - view->visibleContentRect().height());
 }
 
 TEST_F(WebFrameTest, CanOverrideScaleLimits)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
 
     registerMockedHttpURLLoad("no_scale_for_you.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
@@ skipping 30 matching lines @@
     int viewHeight = 500;
 
     OwnPtr<FakeCompositingWebViewClient> fakeCompositingWebViewClient = adoptPtr(new FakeCompositingWebViewClient());
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, fakeCompositingWebViewClient.get(), &configueCompositingWebView);
 
     webViewHelper.webView()->setPageScaleFactorLimits(1, 1);
     webViewHelper.webView()->resize(WebSize(viewWidth, viewHeight));
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "large-div.html");
 
-    blink::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_TRUE(view->renderView()->compositor()->layerForHorizontalScrollbar());
     EXPECT_TRUE(view->renderView()->compositor()->layerForVerticalScrollbar());
 
     webViewHelper.webView()->resize(WebSize(viewWidth * 10, viewHeight * 10));
     webViewHelper.webView()->layout();
     EXPECT_FALSE(view->renderView()->compositor()->layerForHorizontalScrollbar());
     EXPECT_FALSE(view->renderView()->compositor()->layerForVerticalScrollbar());
 }
 
-void setScaleAndScrollAndLayout(blink::WebView* webView, WebPoint scroll, float scale)
+void setScaleAndScrollAndLayout(WebView* webView, WebPoint scroll, float scale)
 {
     webView->setPageScaleFactor(scale);
     webView->setMainFrameScrollOffset(WebPoint(scroll.x, scroll.y));
     webView->layout();
 }
 
 TEST_F(WebFrameTest, DivAutoZoomParamsTest)
 {
     registerMockedHttpURLLoad("get_scale_for_auto_zoom_into_div_test.html");
 
@@ skipping 47 matching lines @@
     EXPECT_NEAR(tallDiv.y, scroll.y, 20);
 
     // Test for Non-doubletap scaling
     // Test zooming into div.
     webViewHelper.webViewImpl()->computeScaleAndScrollForBlockRect(WebPoint(250, 250), webViewHelper.webViewImpl()->computeBlockBounds(WebRect(250, 250, 10, 10), true), 0, doubleTapZoomAlreadyLegibleScale, scale, scroll);
     EXPECT_NEAR(viewportWidth / (float) wideDiv.width, scale, 0.1);
 }
 
 void simulatePageScale(WebViewImpl* webViewImpl, float& scale)
 {
-    blink::IntSize scrollDelta = webViewImpl->fakePageScaleAnimationTargetPositionForTesting() - webViewImpl->mainFrameImpl()->frameView()->scrollPosition();
+    IntSize scrollDelta = webViewImpl->fakePageScaleAnimationTargetPositionForTesting() - webViewImpl->mainFrameImpl()->frameView()->scrollPosition();
     float scaleDelta = webViewImpl->fakePageScaleAnimationPageScaleForTesting() / webViewImpl->pageScaleFactor();
     webViewImpl->applyScrollAndScale(scrollDelta, scaleDelta);
     scale = webViewImpl->pageScaleFactor();
 }
 
 void simulateMultiTargetZoom(WebViewImpl* webViewImpl, const WebRect& rect, float& scale)
 {
     if (webViewImpl->zoomToMultipleTargetsRect(rect))
         simulatePageScale(webViewImpl, scale);
 }
@@ skipping 313 matching lines @@
     // Test scrolling the focused node
     // The edit box is shorter and narrower than the viewport when legible.
     webViewHelper.webView()->advanceFocus(false);
     // Set the caret to the end of the input box.
     webViewHelper.webView()->mainFrame()->document().getElementById("EditBoxWithText").to<WebInputElement>().setSelectionRange(1000, 1000);
     setScaleAndScrollAndLayout(webViewHelper.webView(), WebPoint(0, 0), 1);
     WebRect rect, caret;
     webViewHelper.webViewImpl()->selectionBounds(caret, rect);
 
     float scale;
-    blink::IntPoint scroll;
+    IntPoint scroll;
     bool needAnimation;
     webViewHelper.webViewImpl()->computeScaleAndScrollForFocusedNode(webViewHelper.webViewImpl()->focusedElement(), scale, scroll, needAnimation);
     EXPECT_TRUE(needAnimation);
     // The edit box should be left aligned with a margin for possible label.
     int hScroll = editBoxWithText.x - leftBoxRatio * viewportWidth / scale;
     EXPECT_NEAR(hScroll, scroll.x(), 1);
     int vScroll = editBoxWithText.y - (viewportHeight / scale - editBoxWithText.height) / 2;
     EXPECT_NEAR(vScroll, scroll.y(), 1);
     EXPECT_NEAR(minReadableCaretHeight / caret.height, scale, 0.1);
 
@@ skipping 51 matching lines @@
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "form.html", false, &webFrameClient);
 
     webViewHelper.webView()->mainFrame()->reload(true);
     // start another reload before request is delivered.
     FrameTestHelpers::reloadFrameIgnoringCache(webViewHelper.webView()->mainFrame());
 }
 
 class ReloadWithOverrideURLTask : public WebThread::Task {
 public:
-    ReloadWithOverrideURLTask(WebFrame* frame, const blink::KURL& url, bool ignoreCache)
+    ReloadWithOverrideURLTask(WebFrame* frame, const KURL& url, bool ignoreCache)
         : m_frame(frame), m_url(url), m_ignoreCache(ignoreCache)
     {
     }
 
     virtual void run() OVERRIDE
     {
         m_frame->reloadWithOverrideURL(m_url, m_ignoreCache);
     }
 
 private:
     WebFrame* const m_frame;
-    const blink::KURL m_url;
+    const KURL m_url;
     const bool m_ignoreCache;
 };
 
 TEST_F(WebFrameTest, ReloadWithOverrideURLPreservesState)
 {
     const std::string firstURL = "find.html";
     const std::string secondURL = "form.html";
     const std::string thirdURL = "history.html";
     const float pageScaleFactor = 1.1684f;
     const int pageWidth = 640;
@@ skipping 345 matching lines @@
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     // We set the size because it impacts line wrapping, which changes the
     // resulting text value.
     webViewHelper.webView()->resize(WebSize(640, 480));
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<div>Foo bar</div><div></div>baz";
-    blink::KURL testURL = toKURL("about:blank");
+    KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
 
     // Make sure it comes out OK.
     const std::string expected("Foo bar\nbaz");
     WebString text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ(expected, text.utf8());
 
     // Try reading the same one with clipping of the text.
     const int length = 5;
     text = frame->contentAsText(length);
@@ skipping 18 matching lines @@
 }
 
 TEST_F(WebFrameTest, GetFullHtmlOfPage)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<p>Hello</p><p>World</p>";
-    blink::KURL testURL = toKURL("about:blank");
+    KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
 
     WebString text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ("Hello\n\nWorld", text.utf8());
 
     const std::string html = frame->contentAsMarkup().utf8();
 
     // Load again with the output html.
     FrameTestHelpers::loadHTMLString(frame, html, testURL);
 
@@ skipping 221 matching lines @@
     webViewHelper.webView()->layout();
     runPendingTasks();
 
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     RefPtr<WebLocalFrameImpl> secondFrame = toWebLocalFrameImpl(mainFrame->traverseNext(false));
-    RefPtr<blink::LocalFrame> holdSecondFrame = secondFrame->frame();
+    RefPtr<LocalFrame> holdSecondFrame = secondFrame->frame();
 
     // Detach the frame before finding.
     EXPECT_TRUE(mainFrame->document().getElementById("frame").remove());
 
     EXPECT_TRUE(mainFrame->find(kFindIdentifier, searchText, options, false, 0));
     EXPECT_FALSE(secondFrame->find(kFindIdentifier, searchText, options, false, 0));
 
     runPendingTasks();
     EXPECT_FALSE(client.findResultsAreReady());
 
@@ skipping 20 matching lines @@
     webViewHelper.webView()->layout();
     runPendingTasks();
 
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     WebLocalFrameImpl* secondFrame = toWebLocalFrameImpl(mainFrame->traverseNext(false));
-    RefPtr<blink::LocalFrame> holdSecondFrame = secondFrame->frame();
+    RefPtr<LocalFrame> holdSecondFrame = secondFrame->frame();
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         EXPECT_TRUE(frame->find(kFindIdentifier, searchText, options, false, 0));
 
     runPendingTasks();
     EXPECT_FALSE(client.findResultsAreReady());
 
     // Detach the frame between finding and scoping.
     EXPECT_TRUE(mainFrame->document().getElementById("frame").remove());
 
@@ skipping 20 matching lines @@
     webViewHelper.webView()->layout();
     runPendingTasks();
 
     static const char* kFindString = "result";
     static const int kFindIdentifier = 12345;
 
     WebFindOptions options;
     WebString searchText = WebString::fromUTF8(kFindString);
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     WebLocalFrameImpl* secondFrame = toWebLocalFrameImpl(mainFrame->traverseNext(false));
-    RefPtr<blink::LocalFrame> holdSecondFrame = secondFrame->frame();
+    RefPtr<LocalFrame> holdSecondFrame = secondFrame->frame();
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
         EXPECT_TRUE(frame->find(kFindIdentifier, searchText, options, false, 0));
 
     runPendingTasks();
     EXPECT_FALSE(client.findResultsAreReady());
 
     mainFrame->resetMatchCount();
 
     for (WebFrame* frame = mainFrame; frame; frame = frame->traverseNext(false))
@@ skipping 58 matching lines @@
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     EXPECT_TRUE(mainFrame->find(kFindIdentifier, searchText, options, false, 0));
 
     mainFrame->resetMatchCount();
     mainFrame->scopeStringMatches(kFindIdentifier, searchText, options, true);
 
     runPendingTasks();
     EXPECT_TRUE(client.findResultsAreReady());
 
     // Get the tickmarks for the original find request.
-    blink::FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
-    RefPtr<blink::Scrollbar> scrollbar = frameView->createScrollbar(blink::HorizontalScrollbar);
-    Vector<blink::IntRect> originalTickmarks;
+    FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    RefPtr<Scrollbar> scrollbar = frameView->createScrollbar(HorizontalScrollbar);
+    Vector<IntRect> originalTickmarks;
     scrollbar->getTickmarks(originalTickmarks);
     EXPECT_EQ(4u, originalTickmarks.size());
 
     // Override the tickmarks.
-    Vector<blink::IntRect> overridingTickmarksExpected;
-    overridingTickmarksExpected.append(blink::IntRect(0, 0, 100, 100));
-    overridingTickmarksExpected.append(blink::IntRect(0, 20, 100, 100));
-    overridingTickmarksExpected.append(blink::IntRect(0, 30, 100, 100));
+    Vector<IntRect> overridingTickmarksExpected;
+    overridingTickmarksExpected.append(IntRect(0, 0, 100, 100));
+    overridingTickmarksExpected.append(IntRect(0, 20, 100, 100));
+    overridingTickmarksExpected.append(IntRect(0, 30, 100, 100));
     mainFrame->setTickmarks(overridingTickmarksExpected);
 
     // Check the tickmarks are overriden correctly.
-    Vector<blink::IntRect> overridingTickmarksActual;
+    Vector<IntRect> overridingTickmarksActual;
     scrollbar->getTickmarks(overridingTickmarksActual);
     EXPECT_EQ(overridingTickmarksExpected, overridingTickmarksActual);
 
     // Reset the tickmark behavior.
-    Vector<blink::IntRect> resetTickmarks;
+    Vector<IntRect> resetTickmarks;
     mainFrame->setTickmarks(resetTickmarks);
 
     // Check that the original tickmarks are returned
-    Vector<blink::IntRect> originalTickmarksAfterReset;
+    Vector<IntRect> originalTickmarksAfterReset;
     scrollbar->getTickmarks(originalTickmarksAfterReset);
     EXPECT_EQ(originalTickmarks, originalTickmarksAfterReset);
 }
 
 static WebPoint topLeft(const WebRect& rect)
 {
     return WebPoint(rect.x, rect.y);
 }
 
 static WebPoint bottomRightMinusOne(const WebRect& rect)
@@ skipping 223 matching lines @@
 
     // If the selection is editable text, we can't extend it into non-editable text.
     frame->executeScript(WebScriptSource("selectElement('editable_1');"));
     EXPECT_EQ("Editable 1.", selectionAsString(frame));
     frame->selectRange(topLeft(elementBounds(frame, "editable_1")), bottomRightMinusOne(elementBounds(frame, "footer_1")));
     // positionForPoint returns the wrong values for contenteditable spans. See
     // http://crbug.com/238334.
     // EXPECT_EQ("Editable 1. Editable 2. ]", selectionAsString(frame));
 }
 
-static int computeOffset(blink::RenderObject* renderer, int x, int y)
+static int computeOffset(RenderObject* renderer, int x, int y)
 {
-    return blink::VisiblePosition(renderer->positionForPoint(blink::LayoutPoint(x, y))).deepEquivalent().computeOffsetInContainerNode();
+    return VisiblePosition(renderer->positionForPoint(LayoutPoint(x, y))).deepEquivalent().computeOffsetInContainerNode();
 }
 
 // positionForPoint returns the wrong values for contenteditable spans. See
 // http://crbug.com/238334.
 TEST_F(WebFrameTest, DISABLED_PositionForPointTest)
 {
     registerMockedHttpURLLoad("select_range_span_editable.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     initializeTextSelectionWebView(m_baseURL + "select_range_span_editable.html", &webViewHelper);
     WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
-    blink::RenderObject* renderer = mainFrame->frame()->selection().rootEditableElement()->renderer();
+    RenderObject* renderer = mainFrame->frame()->selection().rootEditableElement()->renderer();
     EXPECT_EQ(0, computeOffset(renderer, -1, -1));
     EXPECT_EQ(64, computeOffset(renderer, 1000, 1000));
 
     registerMockedHttpURLLoad("select_range_div_editable.html");
     initializeTextSelectionWebView(m_baseURL + "select_range_div_editable.html", &webViewHelper);
     mainFrame = toWebLocalFrameImpl(webViewHelper.webView()->mainFrame());
     renderer = mainFrame->frame()->selection().rootEditableElement()->renderer();
     EXPECT_EQ(0, computeOffset(renderer, -1, -1));
     EXPECT_EQ(64, computeOffset(renderer, 1000, 1000));
 }
@@ skipping 129 matching lines @@
     virtual WebLayerTreeView* layerTreeView() OVERRIDE { return &m_testLayerTreeView; }
 
     CompositedSelectionBoundsTestLayerTreeView& selectionLayerTreeView() { return m_testLayerTreeView; }
 
 private:
     CompositedSelectionBoundsTestLayerTreeView m_testLayerTreeView;
 };
 
 TEST_F(WebFrameTest, CompositedSelectionBoundsCleared)
 {
-    blink::RuntimeEnabledFeatures::setCompositedSelectionUpdatesEnabled(true);
+    RuntimeEnabledFeatures::setCompositedSelectionUpdatesEnabled(true);
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
     int viewWidth = 500;
     int viewHeight = 500;
 
     CompositedSelectionBoundsTestWebViewClient fakeSelectionWebViewClient;
     CompositedSelectionBoundsTestLayerTreeView& fakeSelectionLayerTreeView = fakeSelectionWebViewClient.selectionLayerTreeView();
 
@@ skipping 403 matching lines @@
     EXPECT_FALSE(transitionElement.isNull());
 
     // Check that the inline script was not executed.
     EXPECT_FALSE(transitionElement.hasAttribute("dir"));
 }
 
 class SpellCheckClient : public WebSpellCheckClient {
 public:
     explicit SpellCheckClient(uint32_t hash = 0) : m_numberOfTimesChecked(0), m_hash(hash) { }
     virtual ~SpellCheckClient() { }
-    virtual void requestCheckingOfText(const blink::WebString&, const blink::WebVector<uint32_t>&, const blink::WebVector<unsigned>&, blink::WebTextCheckingCompletion* completion) OVERRIDE
+    virtual void requestCheckingOfText(const WebString&, const WebVector<uint32_t>&, const WebVector<unsigned>&, WebTextCheckingCompletion* completion) OVERRIDE
     {
         ++m_numberOfTimesChecked;
         Vector<WebTextCheckingResult> results;
         const int misspellingStartOffset = 1;
         const int misspellingLength = 8;
         results.append(WebTextCheckingResult(WebTextDecorationTypeSpelling, misspellingStartOffset, misspellingLength, WebString(), m_hash));
         completion->didFinishCheckingText(results);
     }
     int numberOfTimesChecked() const { return m_numberOfTimesChecked; }
 private:
@@ skipping 118 matching lines @@
     EXPECT_EQ(1U, documentMarkers.size());
     EXPECT_EQ(kHash, documentMarkers[0]);
 }
 
 class StubbornSpellCheckClient : public WebSpellCheckClient {
 public:
     StubbornSpellCheckClient() : m_completion(0) { }
     virtual ~StubbornSpellCheckClient() { }
 
     virtual void requestCheckingOfText(
-        const blink::WebString&,
-        const blink::WebVector<uint32_t>&,
-        const blink::WebVector<unsigned>&,
-        blink::WebTextCheckingCompletion* completion) OVERRIDE
+        const WebString&,
+        const WebVector<uint32_t>&,
+        const WebVector<unsigned>&,
+        WebTextCheckingCompletion* completion) OVERRIDE
     {
         m_completion = completion;
     }
 
     void kickNoResults()
     {
         kick(-1, -1, WebTextDecorationTypeSpelling);
     }
 
     void kick()
@@ skipping 16 matching lines @@
     {
         if (!m_completion)
             return;
         Vector<WebTextCheckingResult> results;
         if (misspellingStartOffset >= 0 && misspellingLength > 0)
             results.append(WebTextCheckingResult(type, misspellingStartOffset, misspellingLength));
         m_completion->didFinishCheckingText(results);
         m_completion = 0;
     }
 
-    blink::WebTextCheckingCompletion* m_completion;
+    WebTextCheckingCompletion* m_completion;
 };
 
 TEST_F(WebFrameTest, SlowSpellcheckMarkerPosition)
 {
     registerMockedHttpURLLoad("spell.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "spell.html");
 
     StubbornSpellCheckClient spellcheck;
     webViewHelper.webView()->setSpellCheckClient(&spellcheck);
@@ skipping 288 matching lines @@
     }
     bool wasUserScroll() const { return m_didScrollMainFrame && !m_wasProgrammaticScroll; }
     bool wasProgrammaticScroll() const { return m_didScrollMainFrame && m_wasProgrammaticScroll; }
 
     // WebFrameClient:
     virtual void didChangeScrollOffset(WebLocalFrame* frame) OVERRIDE
     {
         if (frame->parent())
             return;
         EXPECT_FALSE(m_didScrollMainFrame);
-        blink::FrameView* view = toWebLocalFrameImpl(frame)->frameView();
+        FrameView* view = toWebLocalFrameImpl(frame)->frameView();
         // FrameView can be scrolled in FrameView::setFixedVisibleContentRect
         // which is called from LocalFrame::createView (before the frame is associated
         // with the the view).
         if (view) {
             m_didScrollMainFrame = true;
             m_wasProgrammaticScroll = view->inProgrammaticScroll();
         }
     }
 private:
     bool m_didScrollMainFrame;
@@ skipping 110 matching lines @@
     }
 };
 
 TEST_F(WebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
 
-    blink::Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
-    blink::KURL destination = document->url();
+    Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
+    KURL destination = document->url();
     destination.setFragmentIdentifier("test");
 
-    RefPtrWillBeRawPtr<blink::Event> event = blink::MouseEvent::create(blink::EventTypeNames::click, false, false,
+    RefPtrWillBeRawPtr<Event> event = MouseEvent::create(EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, false, false, false, false, 1, nullptr, nullptr);
-    blink::FrameLoadRequest frameRequest(document, blink::ResourceRequest(destination));
+    FrameLoadRequest frameRequest(document, ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().load(frameRequest);
 }
 
 class TestNewWindowWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     virtual WebView* createView(WebLocalFrame*, const WebURLRequest&, const WebWindowFeatures&,
         const WebString&, WebNavigationPolicy, bool) OVERRIDE
     {
         EXPECT_TRUE(false);
@@ skipping 22 matching lines @@
 
 TEST_F(WebFrameTest, ModifiedClickNewWindow)
 {
     registerMockedHttpURLLoad("ctrl_click.html");
     registerMockedHttpURLLoad("hello_world.html");
     TestNewWindowWebViewClient webViewClient;
     TestNewWindowWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "ctrl_click.html", true, &webFrameClient, &webViewClient);
 
-    blink::Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
-    blink::KURL destination = toKURL(m_baseURL + "hello_world.html");
+    Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
+    KURL destination = toKURL(m_baseURL + "hello_world.html");
 
     // ctrl+click event
-    RefPtrWillBeRawPtr<blink::Event> event = blink::MouseEvent::create(blink::EventTypeNames::click, false, false,
+    RefPtrWillBeRawPtr<Event> event = MouseEvent::create(EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, true, false, false, false, 0, nullptr, nullptr);
-    blink::FrameLoadRequest frameRequest(document, blink::ResourceRequest(destination));
+    FrameLoadRequest frameRequest(document, ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
-    blink::UserGestureIndicator gesture(blink::DefinitelyProcessingUserGesture);
+    UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
     toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().load(frameRequest);
     FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     // decidePolicyForNavigation should be called both for the original request and the ctrl+click.
     EXPECT_EQ(2, webFrameClient.decidePolicyCallCount());
 }
 
 TEST_F(WebFrameTest, BackToReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
-    const blink::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
-    RefPtr<blink::HistoryItem> firstItem = mainFrameLoader.currentItem();
+    const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
+    RefPtr<HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
     EXPECT_NE(firstItem.get(), mainFrameLoader.currentItem());
 
     FrameTestHelpers::loadHistoryItem(frame, WebHistoryItem(firstItem.get()), WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
     EXPECT_EQ(firstItem.get(), mainFrameLoader.currentItem());
 
     FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
 }
 
 TEST_F(WebFrameTest, BackDuringChildFrameReload)
 {
     registerMockedHttpURLLoad("page_with_blank_iframe.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "page_with_blank_iframe.html", true);
     WebFrame* mainFrame = webViewHelper.webView()->mainFrame();
-    const blink::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
+    const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     WebFrame* childFrame = mainFrame->firstChild();
     ASSERT_TRUE(childFrame);
 
     // Start a history navigation, then have a different frame commit a navigation.
     // In this case, reload an about:blank frame, which will commit synchronously.
     // After the history navigation completes, both the appropriate document url and
     // the current history item should reflect the history navigation.
     registerMockedHttpURLLoad("white-1x1.png");
     WebHistoryItem item;
     item.initialize();
@@ skipping 23 matching lines @@
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
     EXPECT_EQ(WebNavigationTypeFormResubmitted, frame->dataSource()->navigationType());
 }
 
 TEST_F(WebFrameTest, LoadHistoryItemReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
-    const blink::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
-    RefPtr<blink::HistoryItem> firstItem = mainFrameLoader.currentItem();
+    const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
+    RefPtr<HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
     EXPECT_NE(firstItem.get(), mainFrameLoader.currentItem());
 
     // Cache policy overrides should take.
     FrameTestHelpers::loadHistoryItem(frame, WebHistoryItem(firstItem), WebHistoryDifferentDocumentLoad, WebURLRequest::ReloadIgnoringCacheData);
     EXPECT_EQ(firstItem.get(), mainFrameLoader.currentItem());
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
@@ skipping 89 matching lines @@
 
 class TestSameDocumentWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSameDocumentWebFrameClient()
         : m_frameLoadTypeSameSeen(false)
     {
     }
 
     virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest&, const WebURLResponse&)
     {
-        if (toWebLocalFrameImpl(frame)->frame()->loader().loadType() == blink::FrameLoadTypeSame)
+        if (toWebLocalFrameImpl(frame)->frame()->loader().loadType() == FrameLoadTypeSame)
             m_frameLoadTypeSameSeen = true;
     }
 
     bool frameLoadTypeSameSeen() const { return m_frameLoadTypeSameSeen; }
 
 private:
     bool m_frameLoadTypeSameSeen;
 };
 
 TEST_F(WebFrameTest, NavigateToSame)
 {
     registerMockedHttpURLLoad("navigate_to_same.html");
     TestSameDocumentWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "navigate_to_same.html", true, &client);
     EXPECT_FALSE(client.frameLoadTypeSameSeen());
 
-    blink::FrameLoadRequest frameRequest(0, blink::ResourceRequest(toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document()->url()));
+    FrameLoadRequest frameRequest(0, ResourceRequest(toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document()->url()));
     toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().load(frameRequest);
     FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     EXPECT_TRUE(client.frameLoadTypeSameSeen());
 }
 
 class TestSameDocumentWithImageWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSameDocumentWithImageWebFrameClient()
         : m_numOfImageRequests(0)
@@ skipping 30 matching lines @@
 
 TEST_F(WebFrameTest, WebNodeImageContents)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     static const char bluePNG[] = "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAGElEQVQYV2NkYPj/n4EIwDiqEF8oUT94AFIQE/cCn90IAAAAAElFTkSuQmCC\">";
 
     // Load up the image and test that we can extract the contents.
-    blink::KURL testURL = toKURL("about:blank");
+    KURL testURL = toKURL("about:blank");
     FrameTestHelpers::loadHTMLString(frame, bluePNG, testURL);
 
     WebNode node = frame->document().body().firstChild();
     EXPECT_TRUE(node.isElementNode());
     WebElement element = node.to<WebElement>();
     WebImage image = element.imageContents();
     ASSERT_FALSE(image.isNull());
     EXPECT_EQ(image.size().width, 10);
     EXPECT_EQ(image.size().height, 10);
 //    FIXME: The rest of this test is disabled since the ImageDecodeCache state may be inconsistent when this test runs.
@@ skipping 65 matching lines @@
 private:
     WebHistoryCommitType m_lastCommitType;
 };
 
 TEST_F(WebFrameTest, SameDocumentHistoryNavigationCommitType)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestDidNavigateCommitTypeWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "push_state.html", true, &client);
-    RefPtr<blink::HistoryItem> item = toLocalFrame(webViewImpl->page()->mainFrame())->loader().currentItem();
+    RefPtr<HistoryItem> item = toLocalFrame(webViewImpl->page()->mainFrame())->loader().currentItem();
     runPendingTasks();
 
-    toLocalFrame(webViewImpl->page()->mainFrame())->loader().loadHistoryItem(item.get(), blink::HistorySameDocumentLoad);
+    toLocalFrame(webViewImpl->page()->mainFrame())->loader().loadHistoryItem(item.get(), HistorySameDocumentLoad);
     EXPECT_EQ(WebBackForwardCommit, client.lastCommitType());
 }
 
 class TestHistoryWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestHistoryWebFrameClient()
     {
         m_replacesCurrentHistoryItem = false;
         m_frame = 0;
     }
@@ skipping 65 matching lines @@
 {
     registerMockedHttpURLLoad("non-scrollable.html");
     TestMainFrameUserOrProgrammaticScrollFrameClient client;
     OwnPtr<FakeCompositingWebViewClient> fakeCompositingWebViewClient = adoptPtr(new FakeCompositingWebViewClient());
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, fakeCompositingWebViewClient.get(), &configueCompositingWebView);
 
     webViewHelper.webView()->resize(WebSize(100, 100));
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "non-scrollable.html");
 
-    blink::RenderLayerCompositor* compositor =  webViewHelper.webViewImpl()->compositor();
+    RenderLayerCompositor* compositor =  webViewHelper.webViewImpl()->compositor();
     ASSERT_TRUE(compositor->scrollLayer());
 
     // Verify that the WebLayer is not scrollable initially.
-    blink::GraphicsLayer* scrollLayer = compositor->scrollLayer();
+    GraphicsLayer* scrollLayer = compositor->scrollLayer();
     WebLayer* webScrollLayer = scrollLayer->platformLayer();
     ASSERT_FALSE(webScrollLayer->userScrollableHorizontal());
     ASSERT_FALSE(webScrollLayer->userScrollableVertical());
 
     // Call javascript to make the layer scrollable, and verify it.
     WebLocalFrameImpl* frame = (WebLocalFrameImpl*)webViewHelper.webView()->mainFrame();
     frame->executeScript(WebScriptSource("allowScroll();"));
     webViewHelper.webView()->layout();
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
 // Test that currentHistoryItem reflects the current page, not the provisional load.
 TEST_F(WebFrameTest, CurrentHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
     std::string url = m_baseURL + "fixed_layout.html";
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize();
     WebFrame* frame = webViewHelper.webView()->mainFrame();
-    const blink::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
+    const FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     WebURLRequest request;
     request.initialize();
     request.setURL(toKURL(url));
     frame->loadRequest(request);
 
     // Before commit, there is no history item.
     EXPECT_FALSE(mainFrameLoader.currentItem());
 
     FrameTestHelpers::pumpPendingRequestsDoNotUse(frame);
 
     // After commit, there is.
-    blink::HistoryItem* item = mainFrameLoader.currentItem();
+    HistoryItem* item = mainFrameLoader.currentItem();
     ASSERT_TRUE(item);
     EXPECT_EQ(WTF::String(url.data()), item->urlString());
 }
 
 class FailCreateChildFrame : public FrameTestHelpers::TestWebFrameClient {
 public:
     FailCreateChildFrame() : m_callCount(0) { }
 
     virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString& frameName) OVERRIDE
     {
@@ skipping 54 matching lines @@
     EXPECT_EQ(220, topBottomFixed->offsetHeight());
     EXPECT_EQ(200, rightFixed->offsetLeft() + rightFixed->offsetWidth());
     EXPECT_EQ(200, leftRightFixed->offsetWidth());
 }
 
 TEST_F(WebFrameTest, FrameViewSetFrameRect)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
 
-    blink::FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
-    frameView->setFrameRect(blink::IntRect(0, 0, 200, 200));
-    EXPECT_EQ_RECT(blink::IntRect(0, 0, 200, 200), frameView->frameRect());
-    frameView->setFrameRect(blink::IntRect(100, 100, 200, 200));
-    EXPECT_EQ_RECT(blink::IntRect(100, 100, 200, 200), frameView->frameRect());
+    FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
+    frameView->setFrameRect(IntRect(0, 0, 200, 200));
+    EXPECT_EQ_RECT(IntRect(0, 0, 200, 200), frameView->frameRect());
+    frameView->setFrameRect(IntRect(100, 100, 200, 200));
+    EXPECT_EQ_RECT(IntRect(100, 100, 200, 200), frameView->frameRect());
 }
 
 TEST_F(WebFrameTest, FullscreenLayerNonScrollable)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     int viewportWidth = 640;
     int viewportHeight = 480;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_div.html", true, 0, &client, &configueCompositingWebView);
     webViewImpl->resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->layout();
 
     Document* document = toWebLocalFrameImpl(webViewImpl->mainFrame())->frame()->document();
-    blink::UserGestureIndicator gesture(blink::DefinitelyProcessingUserGesture);
+    UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
     Element* divFullscreen = document->getElementById("div1");
     Fullscreen::from(*document).requestFullscreen(*divFullscreen, Fullscreen::PrefixedRequest);
     webViewImpl->didEnterFullScreen();
     webViewImpl->layout();
 
     // Verify that the main frame is not scrollable.
-    ASSERT_TRUE(blink::Fullscreen::isFullScreen(*document));
+    ASSERT_TRUE(Fullscreen::isFullScreen(*document));
     WebLayer* webScrollLayer = webViewImpl->compositor()->scrollLayer()->platformLayer();
     ASSERT_FALSE(webScrollLayer->scrollable());
 
     // Verify that the main frame is scrollable upon exiting fullscreen.
     webViewImpl->didExitFullScreen();
     webViewImpl->layout();
-    ASSERT_FALSE(blink::Fullscreen::isFullScreen(*document));
+    ASSERT_FALSE(Fullscreen::isFullScreen(*document));
     webScrollLayer = webViewImpl->compositor()->scrollLayer()->platformLayer();
     ASSERT_TRUE(webScrollLayer->scrollable());
 }
 
 TEST_F(WebFrameTest, FullscreenMainFrameScrollable)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     int viewportWidth = 640;
     int viewportHeight = 480;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_div.html", true, 0, &client, &configueCompositingWebView);
     webViewImpl->resize(WebSize(viewportWidth, viewportHeight));
     webViewImpl->layout();
 
     Document* document = toWebLocalFrameImpl(webViewImpl->mainFrame())->frame()->document();
-    blink::UserGestureIndicator gesture(blink::DefinitelyProcessingUserGesture);
+    UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
     Fullscreen::from(*document).requestFullscreen(*document->documentElement(), Fullscreen::PrefixedRequest);
     webViewImpl->didEnterFullScreen();
     webViewImpl->layout();
 
     // Verify that the main frame is still scrollable.
-    ASSERT_TRUE(blink::Fullscreen::isFullScreen(*document));
+    ASSERT_TRUE(Fullscreen::isFullScreen(*document));
     WebLayer* webScrollLayer = webViewImpl->compositor()->scrollLayer()->platformLayer();
     ASSERT_TRUE(webScrollLayer->scrollable());
 }
 
 TEST_F(WebFrameTest, RenderBlockPercentHeightDescendants)
 {
     registerMockedHttpURLLoad("percent-height-descendants.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "percent-height-descendants.html");
 
     WebView* webView = webViewHelper.webView();
     webView->resize(WebSize(800, 800));
     webView->layout();
 
     Document* document = toWebLocalFrameImpl(webView->mainFrame())->frame()->document();
-    blink::RenderBlock* container = blink::toRenderBlock(document->getElementById("container")->renderer());
-    blink::RenderBox* percentHeightInAnonymous = blink::toRenderBox(document->getElementById("percent-height-in-anonymous")->renderer());
-    blink::RenderBox* percentHeightDirectChild = blink::toRenderBox(document->getElementById("percent-height-direct-child")->renderer());
+    RenderBlock* container = toRenderBlock(document->getElementById("container")->renderer());
+    RenderBox* percentHeightInAnonymous = toRenderBox(document->getElementById("percent-height-in-anonymous")->renderer());
+    RenderBox* percentHeightDirectChild = toRenderBox(document->getElementById("percent-height-direct-child")->renderer());
 
-    EXPECT_TRUE(blink::RenderBlock::hasPercentHeightDescendant(percentHeightInAnonymous));
-    EXPECT_TRUE(blink::RenderBlock::hasPercentHeightDescendant(percentHeightDirectChild));
+    EXPECT_TRUE(RenderBlock::hasPercentHeightDescendant(percentHeightInAnonymous));
+    EXPECT_TRUE(RenderBlock::hasPercentHeightDescendant(percentHeightDirectChild));
 
     ASSERT_TRUE(container->percentHeightDescendants());
     ASSERT_TRUE(container->hasPercentHeightDescendants());
     EXPECT_EQ(2U, container->percentHeightDescendants()->size());
     EXPECT_TRUE(container->percentHeightDescendants()->contains(percentHeightInAnonymous));
     EXPECT_TRUE(container->percentHeightDescendants()->contains(percentHeightDirectChild));
 
-    blink::RenderBlock* anonymousBlock = percentHeightInAnonymous->containingBlock();
+    RenderBlock* anonymousBlock = percentHeightInAnonymous->containingBlock();
     EXPECT_TRUE(anonymousBlock->isAnonymous());
     EXPECT_FALSE(anonymousBlock->hasPercentHeightDescendants());
 }
 
 TEST_F(WebFrameTest, HasVisibleContentOnVisibleFrames)
 {
     registerMockedHttpURLLoad("visible_frames.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "visible_frames.html");
     for (WebFrame* frame = webViewImpl->mainFrameImpl()->traverseNext(false); frame; frame = frame->traverseNext(false)) {
@@ skipping 41 matching lines @@
     // Check that a reload ignoring cache on a frame will result in the cache
     // policy of the request being set to ReloadBypassingCache.
     registerMockedHttpURLLoad("foo.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "foo.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     FrameTestHelpers::reloadFrameIgnoringCache(frame);
     EXPECT_EQ(WebURLRequest::ReloadBypassingCache, frame->dataSource()->request().cachePolicy());
 }
 
-static void nodeImageTestValidation(const blink::IntSize& referenceBitmapSize, blink::DragImage* dragImage)
+static void nodeImageTestValidation(const IntSize& referenceBitmapSize, DragImage* dragImage)
 {
     // Prepare the reference bitmap.
     SkBitmap bitmap;
     ASSERT_TRUE(bitmap.allocN32Pixels(referenceBitmapSize.width(), referenceBitmapSize.height()));
     SkCanvas canvas(bitmap);
     canvas.drawColor(SK_ColorGREEN);
 
     EXPECT_EQ(referenceBitmapSize.width(), dragImage->size().width());
     EXPECT_EQ(referenceBitmapSize.height(), dragImage->size().height());
     const SkBitmap& dragBitmap = dragImage->bitmap();
     SkAutoLockPixels lockPixel(dragBitmap);
     EXPECT_EQ(0, memcmp(bitmap.getPixels(), dragBitmap.getPixels(), bitmap.getSize()));
 }
 
 TEST_F(WebFrameTest, NodeImageTestCSSTransform)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
-    OwnPtr<blink::DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-transform"));
+    OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-transform"));
     EXPECT_TRUE(dragImage);
 
-    nodeImageTestValidation(blink::IntSize(40, 40), dragImage.get());
+    nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 TEST_F(WebFrameTest, NodeImageTestCSS3DTransform)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
-    OwnPtr<blink::DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-3dtransform"));
+    OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-css-3dtransform"));
     EXPECT_TRUE(dragImage);
 
-    nodeImageTestValidation(blink::IntSize(20, 40), dragImage.get());
+    nodeImageTestValidation(IntSize(20, 40), dragImage.get());
 }
 
 TEST_F(WebFrameTest, NodeImageTestInlineBlock)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
-    OwnPtr<blink::DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-inlineblock"));
+    OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-inlineblock"));
     EXPECT_TRUE(dragImage);
 
-    nodeImageTestValidation(blink::IntSize(40, 40), dragImage.get());
+    nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 TEST_F(WebFrameTest, NodeImageTestFloatLeft)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
-    OwnPtr<blink::DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-float-left-overflow-hidden"));
+    OwnPtr<DragImage> dragImage = nodeImageTestSetup(&webViewHelper, std::string("case-float-left-overflow-hidden"));
     EXPECT_TRUE(dragImage);
 
-    nodeImageTestValidation(blink::IntSize(40, 40), dragImage.get());
+    nodeImageTestValidation(IntSize(40, 40), dragImage.get());
 }
 
 // Crashes on Android: http://crbug.com/403804
 #if OS(ANDROID)
 TEST_F(WebFrameTest, DISABLED_PrintingBasic)
 #else
 TEST_F(WebFrameTest, PrintingBasic)
 #endif
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
@@ skipping 186 matching lines @@
     FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
     std::string content = localFrame->contentAsText(1024).utf8();
     EXPECT_EQ("hello", content);
 
     // Manually reset to break WebViewHelper's dependency on the stack allocated
     // TestWebFrameClient.
     reset();
     remoteFrame->close();
 }
 
-class MockDocumentThreadableLoaderClient : public blink::DocumentThreadableLoaderClient {
+class MockDocumentThreadableLoaderClient : public DocumentThreadableLoaderClient {
 public:
     MockDocumentThreadableLoaderClient() : m_failed(false) { }
-    virtual void didFail(const blink::ResourceError&) OVERRIDE { m_failed = true;}
+    virtual void didFail(const ResourceError&) OVERRIDE { m_failed = true;}
 
     void reset() { m_failed = false; }
     bool failed() { return m_failed; }
 
     bool m_failed;
 };
 
 // FIXME: This would be better as a unittest on DocumentThreadableLoader but it
 // requires spin-up of a frame. It may be possible to remove that requirement
 // and convert it to a unittest.
 TEST_F(WebFrameTest, LoaderOriginAccess)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
 
-    blink::SchemeRegistry::registerURLSchemeAsDisplayIsolated("chrome");
+    SchemeRegistry::registerURLSchemeAsDisplayIsolated("chrome");
 
     // Cross-origin request.
-    blink::KURL resourceUrl(blink::ParsedURLString, "chrome://test.pdf");
+    KURL resourceUrl(ParsedURLString, "chrome://test.pdf");
     registerMockedChromeURLLoad("test.pdf");
 
-    RefPtr<blink::LocalFrame> frame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
+    RefPtr<LocalFrame> frame = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame());
 
     MockDocumentThreadableLoaderClient client;
-    blink::ThreadableLoaderOptions options;
+    ThreadableLoaderOptions options;
 
     // First try to load the request with regular access. Should fail.
-    options.crossOriginRequestPolicy = blink::UseAccessControl;
-    blink::ResourceLoaderOptions resourceLoaderOptions;
-    blink::DocumentThreadableLoader::loadResourceSynchronously(
-        *frame->document(), blink::ResourceRequest(resourceUrl), client, options, resourceLoaderOptions);
+    options.crossOriginRequestPolicy = UseAccessControl;
+    ResourceLoaderOptions resourceLoaderOptions;
+    DocumentThreadableLoader::loadResourceSynchronously(
+        *frame->document(), ResourceRequest(resourceUrl), client, options, resourceLoaderOptions);
     EXPECT_TRUE(client.failed());
 
     client.reset();
     // Try to load the request with cross origin access. Should succeed.
-    options.crossOriginRequestPolicy = blink::AllowCrossOriginRequests;
-    blink::DocumentThreadableLoader::loadResourceSynchronously(
-        *frame->document(), blink::ResourceRequest(resourceUrl), client, options, resourceLoaderOptions);
+    options.crossOriginRequestPolicy = AllowCrossOriginRequests;
+    DocumentThreadableLoader::loadResourceSynchronously(
+        *frame->document(), ResourceRequest(resourceUrl), client, options, resourceLoaderOptions);
     EXPECT_FALSE(client.failed());
 }
 
 class NavigationTransitionCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     NavigationTransitionCallbackWebFrameClient()
         : m_navigationalDataReceivedCount(0)
         , m_provisionalLoadCount(0)
         , m_wasLastProvisionalLoadATransition(false) { }
 
@@ skipping 13 matching lines @@
     bool wasLastProvisionalLoadATransition() const { return m_wasLastProvisionalLoadATransition; }
 
 private:
     unsigned m_navigationalDataReceivedCount;
     unsigned m_provisionalLoadCount;
     bool m_wasLastProvisionalLoadATransition;
 };
 
 TEST_F(WebFrameTest, NavigationTransitionCallbacks)
 {
-    blink::RuntimeEnabledFeatures::setNavigationTransitionsEnabled(true);
+    RuntimeEnabledFeatures::setNavigationTransitionsEnabled(true);
     FrameTestHelpers::WebViewHelper viewHelper;
     NavigationTransitionCallbackWebFrameClient frameClient;
     WebLocalFrame* localFrame = viewHelper.initialize(true, &frameClient)->mainFrame()->toWebLocalFrame();
 
     const char* transitionHTMLString =
         "<!DOCTYPE html>"
         "<meta name='transition-elements' content='#foo;*'>"
         "<div id='foo'>";
 
     // Initial document load should not be a transition.
@@ skipping 15 matching lines @@
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 
     // Neither should a page reload.
     localFrame->reload();
     EXPECT_EQ(4u, frameClient.provisionalLoadCount());
     EXPECT_FALSE(frameClient.wasLastProvisionalLoadATransition());
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 }
 
 } // namespace