platform/testing/{URL|Unit}TestHelpers improvements

third_party/WebKit/Source/web/tests/WebViewTest.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 216 matching lines @@
   WebViewTest()
       : ScopedRootLayerScrollingForTest(GetParam()),
         m_baseURL("http://www.test.com/") {}
 
   void TearDown() override {
     Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs();
     WebCache::clear();
   }
 
  protected:
-  void registerMockedHttpURLLoad(const std::string& fileName) {
-    URLTestHelpers::registerMockedURLFromBaseURL(
-        WebString::fromUTF8(m_baseURL.c_str()),
-        WebString::fromUTF8(fileName.c_str()));
+  std::string registerMockedHttpURLLoad(const std::string& fileName) {
+    return URLTestHelpers::registerMockedURLLoadFromBase(
+               WebString::fromUTF8(m_baseURL), testing::webTestDataPath(),
+               WebString::fromUTF8(fileName))
+        .string()
+        .utf8();
   }
 
   void testAutoResize(const WebSize& minAutoResize,
                       const WebSize& maxAutoResize,
                       const std::string& pageWidth,
                       const std::string& pageHeight,
                       int expectedWidth,
                       int expectedHeight,
                       HorizontalScrollbarState expectedHorizontalState,
                       VerticalScrollbarState expectedVerticalState);
@@ skipping 17 matching lines @@
 
 static std::string hitTestElementId(WebView* view, int x, int y) {
   WebPoint hitPoint(x, y);
   WebHitTestResult hitTestResult = view->hitTestResultAt(hitPoint);
   return hitTestResult.node().to<WebElement>().getAttribute("id").utf8();
 }
 
 INSTANTIATE_TEST_CASE_P(All, WebViewTest, ::testing::Bool());
 
 TEST_P(WebViewTest, HitTestContentEditableImageMaps) {
-  std::string url = m_baseURL + "content-editable-image-maps.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url),
-                                        "content-editable-image-maps.html");
+  std::string url =
+      registerMockedHttpURLLoad("content-editable-image-maps.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(500, 500));
 
   EXPECT_EQ("areaANotEditable", hitTestElementId(webView, 25, 25));
   EXPECT_FALSE(hitTestIsContentEditable(webView, 25, 25));
   EXPECT_EQ("imageANotEditable", hitTestElementId(webView, 75, 25));
   EXPECT_FALSE(hitTestIsContentEditable(webView, 75, 25));
 
   EXPECT_EQ("areaBNotEditable", hitTestElementId(webView, 25, 125));
   EXPECT_FALSE(hitTestIsContentEditable(webView, 25, 125));
@@ skipping 17 matching lines @@
   return hitTestResult.absoluteImageURL().string().utf8();
 }
 
 static WebElement hitTestUrlElement(WebView* view, int x, int y) {
   WebPoint hitPoint(x, y);
   WebHitTestResult hitTestResult = view->hitTestResultAt(hitPoint);
   return hitTestResult.urlElement();
 }
 
 TEST_P(WebViewTest, ImageMapUrls) {
-  std::string url = m_baseURL + "image-map.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "image-map.html");
+  std::string url = registerMockedHttpURLLoad("image-map.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(400, 400));
 
   std::string imageUrl =
       "data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=";
 
   EXPECT_EQ("area", hitTestElementId(webView, 25, 25));
   EXPECT_EQ("area",
             hitTestUrlElement(webView, 25, 25).getAttribute("id").utf8());
   EXPECT_EQ(imageUrl, hitTestAbsoluteUrl(webView, 25, 25));
 
   EXPECT_EQ("image", hitTestElementId(webView, 75, 25));
   EXPECT_TRUE(hitTestUrlElement(webView, 75, 25).isNull());
   EXPECT_EQ(imageUrl, hitTestAbsoluteUrl(webView, 75, 25));
 }
 
 TEST_P(WebViewTest, BrokenImage) {
   URLTestHelpers::registerMockedErrorURLLoad(
       KURL(toKURL(m_baseURL), "non_existent.png"));
-  std::string url = m_baseURL + "image-broken.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "image-broken.html");
+  std::string url = registerMockedHttpURLLoad("image-broken.html");
 
   WebView* webView = m_webViewHelper.initialize();
   webView->settings()->setLoadsImagesAutomatically(true);
   loadFrame(webView->mainFrame(), url);
   webView->resize(WebSize(400, 400));
 
   std::string imageUrl = "http://www.test.com/non_existent.png";
 
   EXPECT_EQ("image", hitTestElementId(webView, 25, 25));
   EXPECT_TRUE(hitTestUrlElement(webView, 25, 25).isNull());
   EXPECT_EQ(imageUrl, hitTestAbsoluteUrl(webView, 25, 25));
 }
 
 TEST_P(WebViewTest, BrokenInputImage) {
   URLTestHelpers::registerMockedErrorURLLoad(
       KURL(toKURL(m_baseURL), "non_existent.png"));
-  std::string url = m_baseURL + "input-image-broken.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "input-image-broken.html");
+  std::string url = registerMockedHttpURLLoad("input-image-broken.html");
 
   WebView* webView = m_webViewHelper.initialize();
   webView->settings()->setLoadsImagesAutomatically(true);
   loadFrame(webView->mainFrame(), url);
   webView->resize(WebSize(400, 400));
 
   std::string imageUrl = "http://www.test.com/non_existent.png";
 
   EXPECT_EQ("image", hitTestElementId(webView, 25, 25));
   EXPECT_TRUE(hitTestUrlElement(webView, 25, 25).isNull());
@@ skipping 111 matching lines @@
                           PaintLayerPaintingCompositingAllPhases);
   pictureBuilder.endRecording()->playback(&canvas);
 
   // The result should be a blend of red and green.
   SkColor color = bitmap.getColor(kWidth / 2, kHeight / 2);
   EXPECT_TRUE(redChannel(color));
   EXPECT_TRUE(greenChannel(color));
 }
 
 TEST_P(WebViewTest, FocusIsInactive) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), "visible_iframe.html");
+  registerMockedHttpURLLoad("visible_iframe.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "visible_iframe.html");
 
   webView->setFocus(true);
   webView->setIsActive(true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   EXPECT_TRUE(frame->frame()->document()->isHTMLDocument());
 
   Document* document = frame->frame()->document();
   EXPECT_TRUE(document->hasFocus());
   webView->setFocus(false);
   webView->setIsActive(false);
   EXPECT_FALSE(document->hasFocus());
   webView->setFocus(true);
   webView->setIsActive(true);
   EXPECT_TRUE(document->hasFocus());
   webView->setFocus(true);
   webView->setIsActive(false);
   EXPECT_FALSE(document->hasFocus());
   webView->setFocus(false);
   webView->setIsActive(true);
   EXPECT_FALSE(document->hasFocus());
 }
 
 TEST_P(WebViewTest, ActiveState) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), "visible_iframe.html");
+  registerMockedHttpURLLoad("visible_iframe.html");
   WebView* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "visible_iframe.html");
 
   ASSERT_TRUE(webView);
 
   webView->setIsActive(true);
   EXPECT_TRUE(webView->isActive());
 
   webView->setIsActive(false);
   EXPECT_FALSE(webView->isActive());
 
   webView->setIsActive(true);
   EXPECT_TRUE(webView->isActive());
 }
 
 TEST_P(WebViewTest, HitTestResultAtWithPageScale) {
   std::string url = m_baseURL + "specify_size.html?" + "50px" + ":" + "50px";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL(url), testing::webTestDataPath("specify_size.html"));
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(100, 100));
   WebPoint hitPoint(75, 75);
 
   // Image is at top left quandrant, so should not hit it.
   WebHitTestResult negativeResult = webView->hitTestResultAt(hitPoint);
   EXPECT_FALSE(negativeResult.node().to<WebElement>().hasHTMLTagName("img"));
   negativeResult.reset();
 
   // Scale page up 2x so image should occupy the whole viewport.
   webView->setPageScaleFactor(2.0f);
   WebHitTestResult positiveResult = webView->hitTestResultAt(hitPoint);
   EXPECT_TRUE(positiveResult.node().to<WebElement>().hasHTMLTagName("img"));
   positiveResult.reset();
 }
 
 TEST_P(WebViewTest, HitTestResultAtWithPageScaleAndPan) {
   std::string url = m_baseURL + "specify_size.html?" + "50px" + ":" + "50px";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL(url), testing::webTestDataPath("specify_size.html"));
   WebView* webView = m_webViewHelper.initialize(true);
   loadFrame(webView->mainFrame(), url);
   webView->resize(WebSize(100, 100));
   WebPoint hitPoint(75, 75);
 
   // Image is at top left quandrant, so should not hit it.
   WebHitTestResult negativeResult = webView->hitTestResultAt(hitPoint);
   EXPECT_FALSE(negativeResult.node().to<WebElement>().hasHTMLTagName("img"));
   negativeResult.reset();
 
   // Scale page up 2x so image should occupy the whole viewport.
   webView->setPageScaleFactor(2.0f);
   WebHitTestResult positiveResult = webView->hitTestResultAt(hitPoint);
   EXPECT_TRUE(positiveResult.node().to<WebElement>().hasHTMLTagName("img"));
   positiveResult.reset();
 
   // Pan around the zoomed in page so the image is not visible in viewport.
   webView->setVisualViewportOffset(WebFloatPoint(100, 100));
   WebHitTestResult negativeResult2 = webView->hitTestResultAt(hitPoint);
   EXPECT_FALSE(negativeResult2.node().to<WebElement>().hasHTMLTagName("img"));
   negativeResult2.reset();
 }
 
 TEST_P(WebViewTest, HitTestResultForTapWithTapArea) {
-  std::string url = m_baseURL + "hit_test.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "hit_test.html");
+  std::string url = registerMockedHttpURLLoad("hit_test.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true, 0);
   webView->resize(WebSize(100, 100));
   WebPoint hitPoint(55, 55);
 
   // Image is at top left quandrant, so should not hit it.
   WebHitTestResult negativeResult = webView->hitTestResultAt(hitPoint);
   EXPECT_FALSE(negativeResult.node().to<WebElement>().hasHTMLTagName("img"));
   negativeResult.reset();
 
   // The tap area is 20 by 20 square, centered at 55, 55.
   WebSize tapArea(20, 20);
   WebHitTestResult positiveResult =
       webView->hitTestResultForTap(hitPoint, tapArea);
   EXPECT_TRUE(positiveResult.node().to<WebElement>().hasHTMLTagName("img"));
   positiveResult.reset();
 
   // Move the hit point the image is just outside the tapped area now.
   hitPoint = WebPoint(61, 61);
   WebHitTestResult negativeResult2 =
       webView->hitTestResultForTap(hitPoint, tapArea);
   EXPECT_FALSE(negativeResult2.node().to<WebElement>().hasHTMLTagName("img"));
   negativeResult2.reset();
 }
 
 TEST_P(WebViewTest, HitTestResultForTapWithTapAreaPageScaleAndPan) {
-  std::string url = m_baseURL + "hit_test.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "hit_test.html");
+  std::string url = registerMockedHttpURLLoad("hit_test.html");
   WebView* webView = m_webViewHelper.initialize(true);
   loadFrame(webView->mainFrame(), url);
   webView->resize(WebSize(100, 100));
   WebPoint hitPoint(55, 55);
 
   // Image is at top left quandrant, so should not hit it.
   WebHitTestResult negativeResult = webView->hitTestResultAt(hitPoint);
   EXPECT_FALSE(negativeResult.node().to<WebElement>().hasHTMLTagName("img"));
   negativeResult.reset();
 
@@ skipping 18 matching lines @@
     const WebSize& maxAutoResize,
     const std::string& pageWidth,
     const std::string& pageHeight,
     int expectedWidth,
     int expectedHeight,
     HorizontalScrollbarState expectedHorizontalState,
     VerticalScrollbarState expectedVerticalState) {
   AutoResizeWebViewClient client;
   std::string url =
       m_baseURL + "specify_size.html?" + pageWidth + ":" + pageHeight;
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL(url), testing::webTestDataPath("specify_size.html"));
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(url, true, 0, &client);
   client.testData().setWebView(webView);
 
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   FrameView* frameView = frame->frame()->view();
   frameView->layout();
   EXPECT_FALSE(frameView->layoutPending());
   EXPECT_FALSE(frameView->needsLayout());
 
@@ skipping 88 matching lines @@
   std::string pageHeight = "300px";
   int expectedWidth = 200;
   int expectedHeight = 300;
   testAutoResize(minAutoResize, maxAutoResize, pageWidth, pageHeight,
                  expectedWidth, expectedHeight, NoHorizontalScrollbar,
                  NoVerticalScrollbar);
 }
 
 void WebViewTest::testTextInputType(WebTextInputType expectedType,
                                     const std::string& htmlFile) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8(htmlFile.c_str()));
+  registerMockedHttpURLLoad(htmlFile);
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + htmlFile);
   WebInputMethodControllerImpl* controller =
       webView->mainFrameImpl()->inputMethodController();
   EXPECT_EQ(WebTextInputTypeNone, controller->textInputType());
   EXPECT_EQ(WebTextInputTypeNone, controller->textInputInfo().type);
   webView->setInitialFocus(false);
   EXPECT_EQ(expectedType, controller->textInputType());
   EXPECT_EQ(expectedType, controller->textInputInfo().type);
   webView->clearFocusedElement();
@@ skipping 41 matching lines @@
 
   // This should not DCHECK.
   EXPECT_EQ(WebTextInputTypeText, webViewImpl->mainFrameImpl()
                                       ->inputMethodController()
                                       ->textInputInfo()
                                       .type);
 }
 
 void WebViewTest::testInputMode(WebTextInputMode expectedInputMode,
                                 const std::string& htmlFile) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8(htmlFile.c_str()));
+  registerMockedHttpURLLoad(htmlFile);
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + htmlFile);
   webViewImpl->setInitialFocus(false);
   EXPECT_EQ(expectedInputMode, webViewImpl->mainFrameImpl()
                                    ->inputMethodController()
                                    ->textInputInfo()
                                    .inputMode);
 }
 
 TEST_P(WebViewTest, InputMode) {
@@ skipping 27 matching lines @@
                 "input_mode_type_numeric.html");
   testInputMode(WebTextInputMode::kWebTextInputModeTel,
                 "input_mode_type_tel.html");
   testInputMode(WebTextInputMode::kWebTextInputModeEmail,
                 "input_mode_type_email.html");
   testInputMode(WebTextInputMode::kWebTextInputModeUrl,
                 "input_mode_type_url.html");
 }
 
 TEST_P(WebViewTest, TextInputInfoWithReplacedElements) {
-  std::string url = m_baseURL + "div_with_image.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "div_with_image.html");
-  URLTestHelpers::registerMockedURLLoad(toKURL("http://www.test.com/foo.png"),
-                                        "white-1x1.png");
+  std::string url = registerMockedHttpURLLoad("div_with_image.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL("http://www.test.com/foo.png"),
+      testing::webTestDataPath("white-1x1.png"));
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(url);
   webViewImpl->setInitialFocus(false);
   WebTextInputInfo info =
       webViewImpl->mainFrameImpl()->inputMethodController()->textInputInfo();
 
   EXPECT_EQ("foo\xef\xbf\xbc", info.value.utf8());
 }
 
 TEST_P(WebViewTest, SetEditableSelectionOffsetsAndTextInputInfo) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   WebInputMethodControllerImpl* activeInputMethodController =
       frame->inputMethodController();
   frame->setEditableSelectionOffsets(5, 13);
   EXPECT_EQ("56789abc", frame->selectionAsText());
   WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz", info.value);
   EXPECT_EQ(5, info.selectionStart);
   EXPECT_EQ(13, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("content_editable_populated.html"));
+  registerMockedHttpURLLoad("content_editable_populated.html");
   webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_editable_populated.html");
   webView->setInitialFocus(false);
   frame = webView->mainFrameImpl();
   activeInputMethodController = frame->inputMethodController();
   frame->setEditableSelectionOffsets(8, 19);
   EXPECT_EQ("89abcdefghi", frame->selectionAsText());
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz", info.value);
   EXPECT_EQ(8, info.selectionStart);
   EXPECT_EQ(19, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 // Regression test for crbug.com/663645
 TEST_P(WebViewTest, FinishComposingTextDoesNotAssert) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_default.html"));
+  registerMockedHttpURLLoad("input_field_default.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_default.html");
   webView->setInitialFocus(false);
 
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   // The test requires non-empty composition.
   std::string compositionText("hello");
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 5, 5);
 
   // Do arbitrary change to make layout dirty.
   Document& document = *webView->mainFrameImpl()->frame()->document();
   Element* br = document.createElement("br");
   document.body()->appendChild(br);
 
   // Should not hit assertion when calling
   // WebInputMethodController::finishComposingText with non-empty composition
   // and dirty layout.
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
 }
 
 TEST_P(WebViewTest, FinishComposingTextCursorPositionChange) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
 
   // Set up a composition that needs to be committed.
   std::string compositionText("hello");
 
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
@@ skipping 29 matching lines @@
   activeInputMethodController->finishComposingText(
       WebInputMethodController::DoNotKeepSelection);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(8, info.selectionStart);
   EXPECT_EQ(8, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionForNewCaretPositions) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
@@ skipping 86 matching lines @@
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 100, 100);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
   EXPECT_EQ(13, info.selectionStart);
   EXPECT_EQ(13, info.selectionEnd);
   EXPECT_EQ(5, info.compositionStart);
   EXPECT_EQ(8, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionWithEmptyText) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
@@ skipping 19 matching lines @@
                                               emptyUnderlines, -2, -2);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("hello", std::string(info.value.utf8().data()));
   EXPECT_EQ(3, info.selectionStart);
   EXPECT_EQ(3, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, CommitTextForNewCaretPositions) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
@@ skipping 46 matching lines @@
   activeInputMethodController->commitText("jk", emptyUnderlines, 100);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("jkgcadefbhi", std::string(info.value.utf8().data()));
   EXPECT_EQ(11, info.selectionStart);
   EXPECT_EQ(11, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, CommitTextWhileComposing) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->setComposition(WebString::fromUTF8("abc"),
@@ skipping 46 matching lines @@
   activeInputMethodController->commitText("", emptyUnderlines, 5);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("helloworld", std::string(info.value.utf8().data()));
   EXPECT_EQ(10, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, FinishCompositionDoesNotRevealSelection) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("form_with_input.html"));
+  registerMockedHttpURLLoad("form_with_input.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form_with_input.html");
   webView->resize(WebSize(800, 600));
   webView->setInitialFocus(false);
   EXPECT_EQ(0, webView->mainFrame()->getScrollOffset().width);
   EXPECT_EQ(0, webView->mainFrame()->getScrollOffset().height);
 
   // Set up a composition from existing text that needs to be committed.
   Vector<CompositionUnderline> emptyUnderlines;
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
@@ skipping 13 matching lines @@
 
   // Verify that the input field is not scrolled back into the viewport.
   frame->frameWidget()
       ->getActiveWebInputMethodController()
       ->finishComposingText(WebInputMethodController::DoNotKeepSelection);
   EXPECT_EQ(0, webView->mainFrame()->getScrollOffset().width);
   EXPECT_EQ(offsetHeight, webView->mainFrame()->getScrollOffset().height);
 }
 
 TEST_P(WebViewTest, InsertNewLinePlacementAfterFinishComposingText) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("text_area_populated.html"));
+  registerMockedHttpURLLoad("text_area_populated.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "text_area_populated.html");
   webView->setInitialFocus(false);
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   WebInputMethodController* activeInputMethodController =
       frame->inputMethodController();
   frame->setEditableSelectionOffsets(4, 4);
@@ skipping 21 matching lines @@
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(5, info.selectionStart);
   EXPECT_EQ(5, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
   EXPECT_EQ("0123\n456789abcdefghijklmnopqrstuvwxyz",
             std::string(info.value.utf8().data()));
 }
 
 TEST_P(WebViewTest, ExtendSelectionAndDelete) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   webView->setInitialFocus(false);
   frame->setEditableSelectionOffsets(10, 10);
   frame->extendSelectionAndDelete(5, 8);
   WebInputMethodController* activeInputMethodController =
       frame->inputMethodController();
   WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("01234ijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
   EXPECT_EQ(5, info.selectionStart);
   EXPECT_EQ(5, info.selectionEnd);
   frame->extendSelectionAndDelete(10, 0);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("ijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
 }
 
 TEST_P(WebViewTest, DeleteSurroundingText) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   WebLocalFrameImpl* frame = toWebLocalFrameImpl(webView->mainFrame());
   WebInputMethodController* activeInputMethodController =
       frame->inputMethodController();
   webView->setInitialFocus(false);
 
   frame->setEditableSelectionOffsets(10, 10);
   frame->deleteSurroundingText(5, 8);
   WebTextInputInfo info = activeInputMethodController->textInputInfo();
@@ skipping 22 matching lines @@
   EXPECT_EQ(0, info.selectionEnd);
 
   frame->deleteSurroundingText(10, 10);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("", std::string(info.value.utf8().data()));
   EXPECT_EQ(0, info.selectionStart);
   EXPECT_EQ(0, info.selectionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingText) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   WebInputMethodController* activeInputMethodController =
       frame->inputMethodController();
   frame->setEditableSelectionOffsets(4, 10);
   frame->setCompositionFromExistingText(8, 12, underlines);
   WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(8, info.compositionStart);
   EXPECT_EQ(12, info.compositionEnd);
   WebVector<WebCompositionUnderline> emptyUnderlines;
   frame->setCompositionFromExistingText(0, 0, emptyUnderlines);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingTextInTextArea) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("text_area_populated.html"));
+  registerMockedHttpURLLoad("text_area_populated.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "text_area_populated.html");
   webView->setInitialFocus(false);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   WebInputMethodController* activeInputMethodController =
       frame->frameWidget()->getActiveWebInputMethodController();
   frame->setEditableSelectionOffsets(27, 27);
   std::string newLineText("\n");
@@ skipping 20 matching lines @@
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopq\nrsyoloxyz",
             std::string(info.value.utf8().data()));
   EXPECT_EQ(34, info.selectionStart);
   EXPECT_EQ(34, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingTextInRichText) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("content_editable_rich_text.html"));
+  registerMockedHttpURLLoad("content_editable_rich_text.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_editable_rich_text.html");
   webView->setInitialFocus(false);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setEditableSelectionOffsets(1, 1);
   WebDocument document = webView->mainFrame()->document();
   EXPECT_FALSE(document.getElementById("bold").isNull());
   frame->setCompositionFromExistingText(0, 4, underlines);
   EXPECT_FALSE(document.getElementById("bold").isNull());
 }
 
 TEST_P(WebViewTest, SetEditableSelectionOffsetsKeepsComposition) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
 
   std::string compositionTextFirst("hello ");
   std::string compositionTextSecond("world");
   WebVector<WebCompositionUnderline> emptyUnderlines;
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
@@ skipping 47 matching lines @@
   frame->setEditableSelectionOffsets(2, 2);
   info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("hello world", std::string(info.value.utf8().data()));
   EXPECT_EQ(2, info.selectionStart);
   EXPECT_EQ(2, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, IsSelectionAnchorFirst) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   WebLocalFrame* frame = webView->mainFrameImpl();
 
   webView->setInitialFocus(false);
   frame->setEditableSelectionOffsets(4, 10);
   EXPECT_TRUE(webView->isSelectionAnchorFirst());
   WebRect anchor;
   WebRect focus;
   webView->selectionBounds(anchor, focus);
   frame->selectRange(WebPoint(focus.x, focus.y), WebPoint(anchor.x, anchor.y));
   EXPECT_FALSE(webView->isSelectionAnchorFirst());
 }
 
 TEST_P(WebViewTest, ExitingDeviceEmulationResetsPageScale) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("200-by-300.html"));
+  registerMockedHttpURLLoad("200-by-300.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html");
   webViewImpl->resize(WebSize(200, 300));
 
   float pageScaleExpected = webViewImpl->pageScaleFactor();
 
   WebDeviceEmulationParams params;
   params.screenPosition = WebDeviceEmulationParams::Desktop;
   params.deviceScaleFactor = 0;
   params.fitToView = false;
   params.offset = WebFloatPoint();
   params.scale = 1;
 
   webViewImpl->enableDeviceEmulation(params);
 
   webViewImpl->setPageScaleFactor(2);
 
   webViewImpl->disableDeviceEmulation();
 
   EXPECT_EQ(pageScaleExpected, webViewImpl->pageScaleFactor());
 }
 
 TEST_P(WebViewTest, HistoryResetScrollAndScaleState) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("200-by-300.html"));
+  registerMockedHttpURLLoad("200-by-300.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html");
   webViewImpl->resize(WebSize(100, 150));
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().width);
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().height);
 
   // Make the page scale and scroll with the given paremeters.
   webViewImpl->setPageScaleFactor(2.0f);
   webViewImpl->mainFrame()->setScrollOffset(WebSize(94, 111));
@@ skipping 14 matching lines @@
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().width);
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().height);
   EXPECT_EQ(1.0f, mainFrameLocal->loader().currentItem()->pageScaleFactor());
   EXPECT_EQ(0,
             mainFrameLocal->loader().currentItem()->getScrollOffset().width());
   EXPECT_EQ(0,
             mainFrameLocal->loader().currentItem()->getScrollOffset().height());
 }
 
 TEST_P(WebViewTest, BackForwardRestoreScroll) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("back_forward_restore_scroll.html"));
+  registerMockedHttpURLLoad("back_forward_restore_scroll.html");
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(
       m_baseURL + "back_forward_restore_scroll.html");
   webViewImpl->resize(WebSize(640, 480));
   webViewImpl->updateAllLifecyclePhases();
 
   // Emulate a user scroll
   webViewImpl->mainFrame()->setScrollOffset(WebSize(0, 900));
   LocalFrame* mainFrameLocal = toLocalFrame(webViewImpl->page()->mainFrame());
   Persistent<HistoryItem> item1 = mainFrameLocal->loader().currentItem();
 
@@ skipping 38 matching lines @@
           nullptr, FrameLoader::resourceRequestFromHistoryItem(
                        item3.get(), WebCachePolicy::UseProtocolCachePolicy)),
       FrameLoadTypeBackForward, item3.get(), HistorySameDocumentLoad);
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().width);
   EXPECT_GT(webViewImpl->mainFrame()->getScrollOffset().height, 2000);
 }
 
 // Tests that we restore scroll and scale *after* the fullscreen styles are
 // removed and the page is laid out. http://crbug.com/625683.
 TEST_P(WebViewTest, FullscreenResetScrollAndScaleFullscreenStyles) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("fullscreen_style.html"));
+  registerMockedHttpURLLoad("fullscreen_style.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_style.html");
   webViewImpl->resize(WebSize(800, 600));
   webViewImpl->updateAllLifecyclePhases();
 
   // Scroll the page down.
   webViewImpl->mainFrame()->setScrollOffset(WebSize(0, 2000));
   ASSERT_EQ(2000, webViewImpl->mainFrame()->getScrollOffset().height);
 
   // Enter fullscreen.
@@ skipping 18 matching lines @@
   webViewImpl->didExitFullscreen();
   EXPECT_TRUE(webViewImpl->mainFrameImpl()->frameView()->needsLayout());
   webViewImpl->updateAllLifecyclePhases();
 
   EXPECT_EQ(2000, webViewImpl->mainFrame()->getScrollOffset().height);
 }
 
 // Tests that exiting and immediately reentering fullscreen doesn't cause the
 // scroll and scale restoration to occur when we enter fullscreen again.
 TEST_P(WebViewTest, FullscreenResetScrollAndScaleExitAndReenter) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("fullscreen_style.html"));
+  registerMockedHttpURLLoad("fullscreen_style.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_style.html");
   webViewImpl->resize(WebSize(800, 600));
   webViewImpl->updateAllLifecyclePhases();
 
   // Scroll the page down.
   webViewImpl->mainFrame()->setScrollOffset(WebSize(0, 2000));
   ASSERT_EQ(2000, webViewImpl->mainFrame()->getScrollOffset().height);
 
   // Enter fullscreen.
@@ skipping 27 matching lines @@
                    .height());
 
   // When we exit now, we should restore the original scroll value.
   webViewImpl->didExitFullscreen();
   webViewImpl->updateAllLifecyclePhases();
 
   EXPECT_EQ(2000, webViewImpl->mainFrame()->getScrollOffset().height);
 }
 
 TEST_P(WebViewTest, EnterFullscreenResetScrollAndScaleState) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("200-by-300.html"));
+  registerMockedHttpURLLoad("200-by-300.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html");
   webViewImpl->resize(WebSize(100, 150));
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().width);
   EXPECT_EQ(0, webViewImpl->mainFrame()->getScrollOffset().height);
 
   // Make the page scale and scroll with the given paremeters.
   webViewImpl->setPageScaleFactor(2.0f);
   webViewImpl->mainFrame()->setScrollOffset(WebSize(94, 111));
@@ skipping 37 matching lines @@
   void printPage(WebLocalFrame*) override { m_printCalled = true; }
 
   bool printCalled() const { return m_printCalled; }
 
  private:
   bool m_printCalled;
 };
 
 TEST_P(WebViewTest, PrintWithXHRInFlight) {
   PrintWebViewClient client;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("print_with_xhr_inflight.html"));
+  registerMockedHttpURLLoad("print_with_xhr_inflight.html");
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(
       m_baseURL + "print_with_xhr_inflight.html", true, 0, &client);
 
   ASSERT_TRUE(toLocalFrame(webViewImpl->page()->mainFrame())
                   ->document()
                   ->loadEventFinished());
   EXPECT_TRUE(client.printCalled());
   m_webViewHelper.reset();
 }
 
@@ skipping 10 matching lines @@
   const WebPoint clientPoint(0, 0);
   const WebPoint screenPoint(0, 0);
   WebFrameWidgetBase* widget = webView->mainFrameImpl()->frameWidget();
   widget->dragTargetDragEnter(dragData, clientPoint, screenPoint,
                               WebDragOperationCopy, 0);
   widget->dragTargetDrop(dragData, clientPoint, screenPoint, 0);
   FrameTestHelpers::pumpPendingRequestsForFrameToLoad(webView->mainFrame());
 }
 
 TEST_P(WebViewTest, DragDropURL) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), "foo.html");
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), "bar.html");
+  registerMockedHttpURLLoad("foo.html");
+  registerMockedHttpURLLoad("bar.html");
 
   const std::string fooUrl = m_baseURL + "foo.html";
   const std::string barUrl = m_baseURL + "bar.html";
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(fooUrl);
 
   ASSERT_TRUE(webView);
 
   // Drag and drop barUrl and verify that we've navigated to it.
   DragAndDropURL(webView, barUrl);
@@ skipping 84 matching lines @@
 
 bool WebViewTest::tapElementById(WebInputEvent::Type type,
                                  const WebString& id) {
   DCHECK(m_webViewHelper.webView());
   Element* element = static_cast<Element*>(
       m_webViewHelper.webView()->mainFrame()->document().getElementById(id));
   return tapElement(type, element);
 }
 
 TEST_P(WebViewTest, DetectContentAroundPosition) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("content_listeners.html"));
+  registerMockedHttpURLLoad("content_listeners.html");
 
   ContentDetectorClient client;
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_listeners.html", true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString clickListener = WebString::fromUTF8("clickListener");
   WebString touchstartListener = WebString::fromUTF8("touchstartListener");
@@ skipping 33 matching lines @@
   event.sourceDevice = WebGestureDeviceTouchscreen;
   webView->handleInputEvent(WebCoalescedInputEvent(event));
   runPendingTasks();
   EXPECT_TRUE(client.pendingIntentsCancelled());
 
   // Explicitly reset to break dependency on locally scoped client.
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, ContentDetectionInIframe) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("content_listeners_iframe.html"));
+  registerMockedHttpURLLoad("content_listeners_iframe.html");
 
   ContentDetectorClient client;
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_listeners_iframe.html", true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString noListener = WebString::fromUTF8("noListener");
   WebString frameName = WebString::fromUTF8("innerFrame");
@@ skipping 55 matching lines @@
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 3;
   event.y = 8;
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
   webView->close();
 }
 
 TEST_P(WebViewTest, LongPressEmptyDiv) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_empty_div.html"));
+  registerMockedHttpURLLoad("long_press_empty_div.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_empty_div.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 250;
   event.y = 150;
 
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 }
 
 TEST_P(WebViewTest, LongPressEmptyDivAlwaysShow) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_empty_div.html"));
+  registerMockedHttpURLLoad("long_press_empty_div.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_empty_div.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 250;
   event.y = 150;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 }
 
 TEST_P(WebViewTest, LongPressObject) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_object.html"));
+  registerMockedHttpURLLoad("long_press_object.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_object.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_NE(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 
   HTMLElement* element =
       toHTMLElement(webView->mainFrame()->document().getElementById("obj"));
   EXPECT_FALSE(element->canStartSelection());
 }
 
 TEST_P(WebViewTest, LongPressObjectFallback) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_object_fallback.html"));
+  registerMockedHttpURLLoad("long_press_object_fallback.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_object_fallback.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 
   HTMLElement* element =
       toHTMLElement(webView->mainFrame()->document().getElementById("obj"));
   EXPECT_TRUE(element->canStartSelection());
 }
 
 TEST_P(WebViewTest, LongPressImage) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_image.html"));
+  registerMockedHttpURLLoad("long_press_image.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_image.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 }
 
 TEST_P(WebViewTest, LongPressVideo) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_video.html"));
+  registerMockedHttpURLLoad("long_press_video.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_video.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 }
 
 TEST_P(WebViewTest, LongPressLink) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_link.html"));
+  registerMockedHttpURLLoad("long_press_link.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_link.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 500;
   event.y = 300;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 }
 
 TEST_P(WebViewTest, showContextMenuOnLongPressingLinks) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_links_and_images.html"));
+  registerMockedHttpURLLoad("long_press_links_and_images.html");
 
-  URLTestHelpers::registerMockedURLLoad(toKURL("http://www.test.com/foo.png"),
-                                        "white-1x1.png");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL("http://www.test.com/foo.png"),
+      testing::webTestDataPath("white-1x1.png"));
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_links_and_images.html", true);
 
   webView->settingsImpl()->setTouchDragDropEnabled(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString anchorTagId = WebString::fromUTF8("anchorTag");
   WebString imageTagId = WebString::fromUTF8("imageTag");
 
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureLongPress, anchorTagId));
   EXPECT_STREQ("anchor contextmenu",
                webView->mainFrame()->document().title().utf8().data());
 
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureLongPress, imageTagId));
   EXPECT_STREQ("image contextmenu",
                webView->mainFrame()->document().title().utf8().data());
 }
 
 TEST_P(WebViewTest, LongPressEmptyEditableSelection) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_empty_editable_selection.html"));
+  registerMockedHttpURLLoad("long_press_empty_editable_selection.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_empty_editable_selection.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
 }
 
 TEST_P(WebViewTest, LongPressEmptyNonEditableSelection) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("long_press_image.html"));
+  registerMockedHttpURLLoad("long_press_image.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_image.html", true);
   webView->resize(WebSize(500, 500));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebGestureEvent event(WebInputEvent::GestureLongPress,
                         WebInputEvent::NoModifiers,
                         WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 300;
   event.y = 300;
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(WebCoalescedInputEvent(event)));
   EXPECT_TRUE(frame->selectionAsText().isEmpty());
 }
 
 TEST_P(WebViewTest, LongPressSelection) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("longpress_selection.html"));
+  registerMockedHttpURLLoad("longpress_selection.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "longpress_selection.html", true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString target = WebString::fromUTF8("target");
   WebString onselectstartfalse = WebString::fromUTF8("onselectstartfalse");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureLongPress, onselectstartfalse));
   EXPECT_EQ("", std::string(frame->selectionAsText().utf8().data()));
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureLongPress, target));
   EXPECT_EQ("testword", std::string(frame->selectionAsText().utf8().data()));
 }
 
 #if !OS(MACOSX)
 TEST_P(WebViewTest, TouchDoesntSelectEmptyTextarea) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("longpress_textarea.html"));
+  registerMockedHttpURLLoad("longpress_textarea.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "longpress_textarea.html", true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString blanklinestextbox = WebString::fromUTF8("blanklinestextbox");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
@@ skipping 22 matching lines @@
       tapElementById(WebInputEvent::GestureLongPress, blanklinestextbox));
   EXPECT_TRUE(frame->selectionAsText().isEmpty());
 
   // Double-tap past last word of textbox.
   webView->handleInputEvent(WebCoalescedInputEvent(event));
   EXPECT_TRUE(frame->selectionAsText().isEmpty());
 }
 #endif
 
 TEST_P(WebViewTest, LongPressImageTextarea) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("longpress_image_contenteditable.html"));
+  registerMockedHttpURLLoad("longpress_image_contenteditable.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "longpress_image_contenteditable.html", true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString image = WebString::fromUTF8("purpleimage");
 
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureLongPress, image));
   WebRange range = webView->caretOrSelectionRange();
   EXPECT_FALSE(range.isNull());
   EXPECT_EQ(0, range.startOffset());
   EXPECT_EQ(1, range.length());
 }
 
 TEST_P(WebViewTest, BlinkCaretAfterLongPress) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("blink_caret_on_typing_after_long_press.html"));
+  registerMockedHttpURLLoad("blink_caret_on_typing_after_long_press.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "blink_caret_on_typing_after_long_press.html", true);
   webView->resize(WebSize(640, 480));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebString target = WebString::fromUTF8("target");
   WebLocalFrameImpl* mainFrame = webView->mainFrameImpl();
 
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureLongPress, target));
   EXPECT_FALSE(mainFrame->frame()->selection().isCaretBlinkingSuspended());
 }
 
 TEST_P(WebViewTest, BlinkCaretOnClosingContextMenu) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form.html"));
+  registerMockedHttpURLLoad("form.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form.html", true);
 
   webView->setInitialFocus(false);
   runPendingTasks();
 
   // We suspend caret blinking when pressing with mouse right button.
   // Note that we do not send MouseUp event here since it will be consumed
   // by the context menu once it shows up.
   WebMouseEvent mouseEvent(WebInputEvent::MouseDown, WebInputEvent::NoModifiers,
@@ skipping 13 matching lines @@
   webView->showContextMenu();
   EXPECT_TRUE(mainFrame->frame()->selection().isCaretBlinkingSuspended());
 
   // Caret blinking will be resumed only after context menu is closed.
   webView->didCloseContextMenu();
 
   EXPECT_FALSE(mainFrame->frame()->selection().isCaretBlinkingSuspended());
 }
 
 TEST_P(WebViewTest, SelectionOnReadOnlyInput) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("selection_readonly.html"));
+  registerMockedHttpURLLoad("selection_readonly.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "selection_readonly.html", true);
   webView->resize(WebSize(640, 480));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   std::string testWord = "This text should be selected.";
 
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   EXPECT_EQ(testWord, std::string(frame->selectionAsText().utf8().data()));
 
   WebRange range = webView->caretOrSelectionRange();
   EXPECT_FALSE(range.isNull());
   EXPECT_EQ(0, range.startOffset());
   EXPECT_EQ(static_cast<int>(testWord.length()), range.length());
 }
 
 TEST_P(WebViewTest, KeyDownScrollsHandled) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("content-width-1000.html"));
+  registerMockedHttpURLLoad("content-width-1000.html");
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content-width-1000.html", true);
   webView->resize(WebSize(100, 100));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   WebKeyboardEvent keyEvent(WebInputEvent::RawKeyDown,
                             WebInputEvent::NoModifiers,
                             WebInputEvent::TimeStampForTesting);
@@ skipping 156 matching lines @@
 
  private:
   bool m_ignoreTextChanges;
   int m_textChangesFromUserGesture;
   int m_textChangesWhileIgnored;
   int m_textChangesWhileNotIgnored;
   int m_userGestureNotificationsCount;
 };
 
 TEST_P(WebViewTest, LosingFocusDoesNotTriggerAutofillTextChange) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   MockAutofillClient client;
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   // Set up a composition that needs to be committed.
   WebVector<WebCompositionUnderline> emptyUnderlines;
   frame->setEditableSelectionOffsets(4, 10);
@@ skipping 21 matching lines @@
                                           const char* failMessage) {
   WebTextInputInfo info =
       webView->mainFrameImpl()->inputMethodController()->textInputInfo();
   EXPECT_EQ(selectionStart, info.selectionStart) << failMessage;
   EXPECT_EQ(selectionEnd, info.selectionEnd) << failMessage;
   EXPECT_EQ(compositionStart, info.compositionStart) << failMessage;
   EXPECT_EQ(compositionEnd, info.compositionEnd) << failMessage;
 }
 
 TEST_P(WebViewTest, CompositionNotCancelledByBackspace) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("composition_not_cancelled_by_backspace.html"));
+  registerMockedHttpURLLoad("composition_not_cancelled_by_backspace.html");
   MockAutofillClient client;
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "composition_not_cancelled_by_backspace.html");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   // Test both input elements.
   for (int i = 0; i < 2; ++i) {
     // Select composition and do sanity check.
@@ skipping 25 matching lines @@
     keyEvent.setType(WebInputEvent::KeyUp);
     webView->handleInputEvent(WebCoalescedInputEvent(keyEvent));
 
     webView->advanceFocus(false);
   }
 
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FinishComposingTextTriggersAutofillTextChange) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   MockAutofillClient client;
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
   WebInputMethodController* activeInputMethodController =
       frame->frameWidget()->getActiveWebInputMethodController();
   // Set up a composition that needs to be committed.
   std::string compositionText("testingtext");
@@ skipping 12 matching lines @@
   client.clearChangeCounts();
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
   EXPECT_EQ(0, client.textChangesWhileIgnored());
   EXPECT_EQ(1, client.textChangesWhileNotIgnored());
 
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingTextTriggersAutofillTextChange) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   MockAutofillClient client;
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
   client.clearChangeCounts();
@@ skipping 89 matching lines @@
       0, webURLRequestWithTargetStart.toResourceRequest(), "_start");
   toLocalFrame(toWebViewImpl(client.createdWebView())->page()->mainFrame())
       ->loader()
       .load(requestWithTargetStart);
   EXPECT_TRUE(client.didFocusCalled());
 
   m_webViewHelper.reset();  // Remove dependency on locally scoped client.
 }
 
 TEST_P(WebViewTest, DispatchesFocusOutFocusInOnViewToggleFocus) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), "focusout_focusin_events.html");
+  registerMockedHttpURLLoad("focusout_focusin_events.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "focusout_focusin_events.html", true, 0);
 
   webView->setFocus(true);
   webView->setFocus(false);
   webView->setFocus(true);
 
   WebElement element =
       webView->mainFrame()->document().getElementById("message");
   EXPECT_STREQ("focusoutfocusin", element.textContent().utf8().data());
 }
 
 TEST_P(WebViewTest, DispatchesDomFocusOutDomFocusInOnViewToggleFocus) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      "domfocusout_domfocusin_events.html");
+  registerMockedHttpURLLoad("domfocusout_domfocusin_events.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "domfocusout_domfocusin_events.html", true, 0);
 
   webView->setFocus(true);
   webView->setFocus(false);
   webView->setFocus(true);
 
   WebElement element =
       webView->mainFrame()->document().getElementById("message");
   EXPECT_STREQ("DOMFocusOutDOMFocusIn", element.textContent().utf8().data());
@@ skipping 17 matching lines @@
 // TODO(crbug.com/605112) This test is crashing on Android (Nexus 4) bot.
 #if OS(ANDROID)
 TEST_P(WebViewTest, DISABLED_ChooseValueFromDateTimeChooser) {
 #else
 TEST_P(WebViewTest, ChooseValueFromDateTimeChooser) {
 #endif
   bool originalMultipleFieldsFlag =
       RuntimeEnabledFeatures::inputMultipleFieldsUIEnabled();
   RuntimeEnabledFeatures::setInputMultipleFieldsUIEnabled(false);
   DateTimeChooserWebViewClient client;
-  std::string url = m_baseURL + "date_time_chooser.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "date_time_chooser.html");
+  std::string url = registerMockedHttpURLLoad("date_time_chooser.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(url, true, 0, &client);
 
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
 
   HTMLInputElement* inputElement;
 
   inputElement = toHTMLInputElement(document->getElementById("date"));
   openDateTimeChooser(webViewImpl, inputElement);
   client.chooserCompletion()->didChooseValue(0);
@@ skipping 55 matching lines @@
   EXPECT_STREQ("", inputElement->value().utf8().data());
 
   // Clear the WebViewClient from the webViewHelper to avoid use-after-free in
   // the WebViewHelper destructor.
   m_webViewHelper.reset();
   RuntimeEnabledFeatures::setInputMultipleFieldsUIEnabled(
       originalMultipleFieldsFlag);
 }
 
 TEST_P(WebViewTest, DispatchesFocusBlurOnViewToggle) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), "focus_blur_events.html");
+  registerMockedHttpURLLoad("focus_blur_events.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "focus_blur_events.html", true, 0);
 
   webView->setFocus(true);
   webView->setFocus(false);
   webView->setFocus(true);
 
   WebElement element =
       webView->mainFrame()->document().getElementById("message");
   // Expect not to see duplication of events.
@@ skipping 17 matching lines @@
       "color: rgb(0, 0, 0); font-family: myahem; font-size: 8px; font-style: "
       "normal; font-variant-ligatures: normal; font-variant-caps: normal; "
       "font-weight: normal; letter-spacing: normal; orphans: 2; text-align: "
       "start; text-indent: 0px; text-transform: none; white-space: normal; "
       "widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; "
       "text-decoration-style: initial; text-decoration-color: initial;\">Price "
       "10,000,000won</div>";
   WebString clipText;
   WebString clipHtml;
   WebRect clipRect;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("smartclip.html"));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad("smartclip.html");
   WebView* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "smartclip.html");
   webView->resize(WebSize(500, 500));
   webView->updateAllLifecyclePhases();
   WebRect cropRect(300, 125, 152, 50);
   webView->extractSmartClipData(cropRect, clipText, clipHtml, clipRect);
   EXPECT_STREQ(kExpectedClipText, clipText.utf8().c_str());
   EXPECT_STREQ(kExpectedClipHtml, clipHtml.utf8().c_str());
 }
 
@@ skipping 14 matching lines @@
       "color: rgb(0, 0, 0); font-family: myahem; font-size: 8px; font-style: "
       "normal; font-variant-ligatures: normal; font-variant-caps: normal; "
       "font-weight: normal; letter-spacing: normal; orphans: 2; text-align: "
       "start; text-indent: 0px; text-transform: none; white-space: normal; "
       "widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; "
       "text-decoration-style: initial; text-decoration-color: initial;\">Price "
       "10,000,000won</div>";
   WebString clipText;
   WebString clipHtml;
   WebRect clipRect;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("smartclip.html"));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad("smartclip.html");
   WebView* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "smartclip.html");
   webView->resize(WebSize(500, 500));
   webView->updateAllLifecyclePhases();
   webView->setPageScaleFactor(1.5);
   webView->setVisualViewportOffset(WebFloatPoint(167, 100));
   WebRect cropRect(200, 38, 228, 75);
   webView->extractSmartClipData(cropRect, clipText, clipHtml, clipRect);
   EXPECT_STREQ(kExpectedClipText, clipText.utf8().c_str());
   EXPECT_STREQ(kExpectedClipHtml, clipHtml.utf8().c_str());
 }
 
 TEST_P(WebViewTest, SmartClipReturnsEmptyStringsWhenUserSelectIsNone) {
   WebString clipText;
   WebString clipHtml;
   WebRect clipRect;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("smartclip_user_select_none.html"));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad("smartclip_user_select_none.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "smartclip_user_select_none.html");
   webView->resize(WebSize(500, 500));
   webView->updateAllLifecyclePhases();
   WebRect cropRect(0, 0, 100, 100);
   webView->extractSmartClipData(cropRect, clipText, clipHtml, clipRect);
   EXPECT_STREQ("", clipText.utf8().c_str());
   EXPECT_STREQ("", clipHtml.utf8().c_str());
 }
 
 TEST_P(WebViewTest, SmartClipDoesNotCrashPositionReversed) {
   WebString clipText;
   WebString clipHtml;
   WebRect clipRect;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("smartclip_reversed_positions.html"));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad("smartclip_reversed_positions.html");
   WebView* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "smartclip_reversed_positions.html");
   webView->resize(WebSize(500, 500));
   webView->updateAllLifecyclePhases();
   // Left upper corner of the rect will be end position in the DOM hierarchy.
   WebRect cropRect(30, 110, 400, 250);
   // This should not still crash. See crbug.com/589082 for more details.
   webView->extractSmartClipData(cropRect, clipText, clipHtml, clipRect);
 }
 
@@ skipping 20 matching lines @@
     const WebString& name,
     const WebString& uniqueName,
     WebSandboxFlags sandboxFlags,
     const WebFrameOwnerProperties& frameOwnerProperties) {
   ++m_count;
   return TestWebFrameClient::createChildFrame(
       parent, scope, name, uniqueName, sandboxFlags, frameOwnerProperties);
 }
 
 TEST_P(WebViewTest, ChangeDisplayMode) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("display_mode.html"));
+  registerMockedHttpURLLoad("display_mode.html");
   WebView* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "display_mode.html", true);
 
   std::string content =
       WebFrameContentDumper::dumpWebViewAsText(webView, 21).utf8();
   EXPECT_EQ("regular-ui", content);
 
   webView->setDisplayMode(WebDisplayModeMinimalUi);
   content = WebFrameContentDumper::dumpWebViewAsText(webView, 21).utf8();
   EXPECT_EQ("minimal-ui", content);
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, AddFrameInCloseUnload) {
   CreateChildCounterFrameClient frameClient;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("add_frame_in_unload.html"));
+  registerMockedHttpURLLoad("add_frame_in_unload.html");
   m_webViewHelper.initializeAndLoad(m_baseURL + "add_frame_in_unload.html",
                                     true, &frameClient);
   m_webViewHelper.reset();
   EXPECT_EQ(0, frameClient.count());
 }
 
 TEST_P(WebViewTest, AddFrameInCloseURLUnload) {
   CreateChildCounterFrameClient frameClient;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("add_frame_in_unload.html"));
+  registerMockedHttpURLLoad("add_frame_in_unload.html");
   m_webViewHelper.initializeAndLoad(m_baseURL + "add_frame_in_unload.html",
                                     true, &frameClient);
   m_webViewHelper.webView()->mainFrame()->dispatchUnloadEvent();
   EXPECT_EQ(0, frameClient.count());
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, AddFrameInNavigateUnload) {
   CreateChildCounterFrameClient frameClient;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("add_frame_in_unload.html"));
+  registerMockedHttpURLLoad("add_frame_in_unload.html");
   m_webViewHelper.initializeAndLoad(m_baseURL + "add_frame_in_unload.html",
                                     true, &frameClient);
   FrameTestHelpers::loadFrame(m_webViewHelper.webView()->mainFrame(),
                               "about:blank");
   EXPECT_EQ(0, frameClient.count());
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, AddFrameInChildInNavigateUnload) {
   CreateChildCounterFrameClient frameClient;
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("add_frame_in_unload_wrapper.html"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("add_frame_in_unload.html"));
+  registerMockedHttpURLLoad("add_frame_in_unload_wrapper.html");
+  registerMockedHttpURLLoad("add_frame_in_unload.html");
   m_webViewHelper.initializeAndLoad(
       m_baseURL + "add_frame_in_unload_wrapper.html", true, &frameClient);
   FrameTestHelpers::loadFrame(m_webViewHelper.webView()->mainFrame(),
                               "about:blank");
   EXPECT_EQ(1, frameClient.count());
   m_webViewHelper.reset();
 }
 
 class TouchEventHandlerWebWidgetClient
     : public FrameTestHelpers::TestWebWidgetClient {
@@ skipping 18 matching lines @@
 
 // This test verifies that WebWidgetClient::hasTouchEventHandlers is called
 // accordingly for various calls to EventHandlerRegistry::did{Add|Remove|
 // RemoveAll}EventHandler(..., TouchEvent). Verifying that those calls are made
 // correctly is the job of LayoutTests/fast/events/event-handler-count.html.
 TEST_P(WebViewTest, HasTouchEventHandlers) {
   TouchEventHandlerWebWidgetClient client;
   // We need to create a LayerTreeView for the client before loading the page,
   // otherwise ChromeClient will default to assuming there are touch handlers.
   WebLayerTreeView* layerTreeView = client.initializeLayerTreeView();
-  std::string url = m_baseURL + "has_touch_event_handlers.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url),
-                                        "has_touch_event_handlers.html");
+  std::string url = registerMockedHttpURLLoad("has_touch_event_handlers.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(url, true, 0, 0, &client);
   ASSERT_TRUE(layerTreeView);
   const EventHandlerRegistry::EventHandlerClass touchEvent =
       EventHandlerRegistry::TouchStartOrMoveEventBlocking;
 
   // The page is initialized with at least one no-handlers call.
   // In practice we get two such calls because WebViewHelper::initializeAndLoad
   // first initializes an empty frame, and then loads a document into it, so
   // there are two FrameLoader::commitProvisionalLoad calls.
@@ skipping 105 matching lines @@
 
   // Free the webView before the TouchEventHandlerWebViewClient gets freed.
   m_webViewHelper.reset();
 }
 
 // This test checks that deleting nodes which have only non-JS-registered touch
 // handlers also removes them from the event handler registry. Note that this
 // is different from detaching and re-attaching the same node, which is covered
 // by layout tests under fast/events/.
 TEST_P(WebViewTest, DeleteElementWithRegisteredHandler) {
-  std::string url = m_baseURL + "simple_div.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "simple_div.html");
+  std::string url = registerMockedHttpURLLoad("simple_div.html");
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(url, true);
 
   Persistent<Document> document =
       webViewImpl->mainFrameImpl()->frame()->document();
   Element* div = document->getElementById("div");
   EventHandlerRegistry& registry =
       document->frameHost()->eventHandlerRegistry();
 
   registry.didAddEventHandler(*div, EventHandlerRegistry::ScrollEvent);
   EXPECT_TRUE(registry.hasEventHandlers(EventHandlerRegistry::ScrollEvent));
 
   DummyExceptionStateForTesting exceptionState;
   div->remove(exceptionState);
 
   // For oilpan we have to force a GC to ensure the event handlers have been
   // removed when checking below. We do a precise GC (collectAllGarbage does not
   // scan the stack) to ensure the div element dies. This is also why the
   // Document is in a Persistent since we want that to stay around.
   ThreadState::current()->collectAllGarbage();
 
   EXPECT_FALSE(registry.hasEventHandlers(EventHandlerRegistry::ScrollEvent));
 }
 
 // This test verifies the text input flags are correctly exposed to script.
 TEST_P(WebViewTest, TextInputFlags) {
-  std::string url = m_baseURL + "text_input_flags.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "text_input_flags.html");
+  std::string url = registerMockedHttpURLLoad("text_input_flags.html");
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(url, true);
   webViewImpl->setInitialFocus(false);
 
   WebLocalFrameImpl* frame = webViewImpl->mainFrameImpl();
   WebInputMethodControllerImpl* activeInputMethodController =
       frame->inputMethodController();
   Document* document = frame->frame()->document();
 
   // (A) <input>
   // (A.1) Verifies autocorrect/autocomplete/spellcheck flags are Off and
@@ skipping 38 matching lines @@
   EXPECT_FALSE(info1.equals(info2));
   EXPECT_FALSE(info2.equals(info3));
 
   // Free the webView before freeing the NonUserInputTextUpdateWebViewClient.
   m_webViewHelper.reset();
 }
 
 // Check that the WebAutofillClient is correctly notified about first user
 // gestures after load, following various input events.
 TEST_P(WebViewTest, FirstUserGestureObservedKeyEvent) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form.html"));
+  registerMockedHttpURLLoad("form.html");
   MockAutofillClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   EXPECT_EQ(0, client.getUserGestureNotificationsCount());
 
   WebKeyboardEvent keyEvent(WebInputEvent::RawKeyDown,
                             WebInputEvent::NoModifiers,
                             WebInputEvent::TimeStampForTesting);
   keyEvent.domKey = Platform::current()->domKeyEnumFromString(" ");
   keyEvent.windowsKeyCode = VKEY_SPACE;
   webView->handleInputEvent(WebCoalescedInputEvent(keyEvent));
   keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(WebCoalescedInputEvent(keyEvent));
 
   EXPECT_EQ(1, client.getUserGestureNotificationsCount());
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FirstUserGestureObservedMouseEvent) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form.html"));
+  registerMockedHttpURLLoad("form.html");
   MockAutofillClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   EXPECT_EQ(0, client.getUserGestureNotificationsCount());
 
   WebMouseEvent mouseEvent(WebInputEvent::MouseDown, WebInputEvent::NoModifiers,
                            WebInputEvent::TimeStampForTesting);
   mouseEvent.button = WebMouseEvent::Button::Left;
   mouseEvent.x = 1;
   mouseEvent.y = 1;
   mouseEvent.clickCount = 1;
   webView->handleInputEvent(WebCoalescedInputEvent(mouseEvent));
   mouseEvent.setType(WebInputEvent::MouseUp);
   webView->handleInputEvent(WebCoalescedInputEvent(mouseEvent));
 
   EXPECT_EQ(1, client.getUserGestureNotificationsCount());
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FirstUserGestureObservedGestureTap) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("longpress_selection.html"));
+  registerMockedHttpURLLoad("longpress_selection.html");
   MockAutofillClient client;
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "longpress_selection.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   EXPECT_EQ(0, client.getUserGestureNotificationsCount());
 
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureTap, WebString::fromUTF8("target")));
 
   EXPECT_EQ(1, client.getUserGestureNotificationsCount());
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, CompositionIsUserGesture) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_populated.html"));
+  registerMockedHttpURLLoad("input_field_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   MockAutofillClient client;
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   EXPECT_TRUE(
       frame->frameWidget()->getActiveWebInputMethodController()->setComposition(
           WebString::fromUTF8(std::string("hello").c_str()),
           WebVector<WebCompositionUnderline>(), 3, 3));
   EXPECT_EQ(1, client.textChangesFromUserGesture());
   EXPECT_FALSE(UserGestureIndicator::processingUserGesture());
   EXPECT_TRUE(frame->hasMarkedText());
 
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, CompareSelectAllToContentAsText) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("longpress_selection.html"));
+  registerMockedHttpURLLoad("longpress_selection.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "longpress_selection.html", true);
 
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->executeScript(WebScriptSource(
       WebString::fromUTF8("document.execCommand('SelectAll', false, null)")));
   std::string actual = frame->selectionAsText().utf8();
 
   const int kMaxOutputCharacters = 1024;
   std::string expected =
       WebFrameContentDumper::dumpWebViewAsText(webView, kMaxOutputCharacters)
           .utf8();
   EXPECT_EQ(expected, actual);
 }
 
 TEST_P(WebViewTest, AutoResizeSubtreeLayout) {
-  std::string url = m_baseURL + "subtree-layout.html";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "subtree-layout.html");
+  std::string url = registerMockedHttpURLLoad("subtree-layout.html");
   WebView* webView = m_webViewHelper.initialize(true);
 
   webView->enableAutoResizeMode(WebSize(200, 200), WebSize(200, 200));
   loadFrame(webView->mainFrame(), url);
 
   FrameView* frameView =
       m_webViewHelper.webView()->mainFrameImpl()->frameView();
 
   // Auto-resizing used to DCHECK(needsLayout()) in LayoutBlockFlow::layout.
   // This EXPECT is merely a dummy. The real test is that we don't trigger
   // asserts in debug builds.
   EXPECT_FALSE(frameView->needsLayout());
 };
 
 TEST_P(WebViewTest, PreferredSize) {
   std::string url = m_baseURL + "specify_size.html?100px:100px";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL(url), testing::webTestDataPath("specify_size.html"));
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true);
 
   WebSize size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(100, size.width);
   EXPECT_EQ(100, size.height);
 
   webView->setZoomLevel(WebView::zoomFactorToZoomLevel(2.0));
   size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(200, size.width);
   EXPECT_EQ(200, size.height);
 
   // Verify that both width and height are rounded (in this case up)
   webView->setZoomLevel(WebView::zoomFactorToZoomLevel(0.9995));
   size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(100, size.width);
   EXPECT_EQ(100, size.height);
 
   // Verify that both width and height are rounded (in this case down)
   webView->setZoomLevel(WebView::zoomFactorToZoomLevel(1.0005));
   size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(100, size.width);
   EXPECT_EQ(100, size.height);
 
   url = m_baseURL + "specify_size.html?1.5px:1.5px";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL(url), testing::webTestDataPath("specify_size.html"));
   webView = m_webViewHelper.initializeAndLoad(url, true);
 
   webView->setZoomLevel(WebView::zoomFactorToZoomLevel(1));
   size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(2, size.width);
   EXPECT_EQ(2, size.height);
 }
 
 TEST_P(WebViewTest, PreferredSizeDirtyLayout) {
   std::string url = m_baseURL + "specify_size.html?100px:100px";
-  URLTestHelpers::registerMockedURLLoad(toKURL(url), "specify_size.html");
+  URLTestHelpers::registerMockedURLLoad(
+      toKURL(url), testing::webTestDataPath("specify_size.html"));
   WebView* webView = m_webViewHelper.initializeAndLoad(url, true);
   WebElement documentElement =
       webView->mainFrame()->document().documentElement();
 
   WebSize size = webView->contentsPreferredMinimumSize();
   EXPECT_EQ(100, size.width);
   EXPECT_EQ(100, size.height);
 
   documentElement.setAttribute("style", "display: none");
 
@@ skipping 27 matching lines @@
 
  private:
   bool m_wasCalled = false;
   IntPoint m_tappedPosition;
   WebNode m_tappedNode;
   bool m_pageChanged = false;
 };
 
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeeded) {
   std::string testFile = "show_unhandled_tap.html";
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(testFile));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad(testFile);
   UnhandledTapWebViewClient client;
   WebView* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + testFile, true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
   // Scroll the bottom into view so we can distinguish window coordinates from
   // document coordinates.
   EXPECT_TRUE(
@@ skipping 47 matching lines @@
                              WebString::fromUTF8("target")));                 \
   EXPECT_##EXPECT(client.getPageChanged());                                   \
   client.reset();                                                             \
   frame->executeScript(WebScriptSource("setTest('click-" handler "');"));     \
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureTap,                       \
                              WebString::fromUTF8("target")));                 \
   EXPECT_##EXPECT(client.getPageChanged());
 
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeededWithMutateDom) {
   std::string testFile = "show_unhandled_tap.html";
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(testFile));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad(testFile);
   UnhandledTapWebViewClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + testFile, true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   // Test dom mutation.
   TEST_EACH_MOUSEEVENT("mutateDom", TRUE);
 
   // Test without any DOM mutation.
   client.reset();
   frame->executeScript(WebScriptSource("setTest('none');"));
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureTap, WebString::fromUTF8("target")));
   EXPECT_FALSE(client.getPageChanged());
 
   m_webViewHelper.reset();  // Remove dependency on locally scoped client.
 }
 
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeededWithMutateStyle) {
   std::string testFile = "show_unhandled_tap.html";
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(testFile));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad(testFile);
   UnhandledTapWebViewClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + testFile, true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   // Test style mutation.
   TEST_EACH_MOUSEEVENT("mutateStyle", TRUE);
@@ skipping 12 matching lines @@
   frame->executeScript(WebScriptSource("setTest('none');"));
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureTap, WebString::fromUTF8("target")));
   EXPECT_FALSE(client.getPageChanged());
 
   m_webViewHelper.reset();  // Remove dependency on locally scoped client.
 }
 
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeededWithPreventDefault) {
   std::string testFile = "show_unhandled_tap.html";
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("Ahem.ttf"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(testFile));
+  registerMockedHttpURLLoad("Ahem.ttf");
+  registerMockedHttpURLLoad(testFile);
   UnhandledTapWebViewClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + testFile, true, 0, &client);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   // Testswallowing.
   TEST_EACH_MOUSEEVENT("preventDefault", FALSE);
@@ skipping 24 matching lines @@
           "var win = window.open('javascript:false'); win.document"));
   ASSERT_TRUE(v8Value->IsObject());
   Document* document =
       V8Document::toImplWithTypeCheck(v8::Isolate::GetCurrent(), v8Value);
   ASSERT_TRUE(document);
   EXPECT_FALSE(document->frame()->isLoading());
 }
 
 #if OS(MACOSX)
 TEST_P(WebViewTest, WebSubstringUtil) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("content_editable_populated.html"));
+  registerMockedHttpURLLoad("content_editable_populated.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_editable_populated.html");
   webView->settings()->setDefaultFontSize(12);
   webView->resize(WebSize(400, 400));
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   FrameView* frameView = frame->frame()->view();
 
   WebPoint baselinePoint;
   NSAttributedString* result = WebSubstringUtil::attributedSubstringInRange(
       frame, 10, 3, &baselinePoint);
@@ skipping 10 matching lines @@
       WebSubstringUtil::attributedSubstringInRange(frame, 5, 5, &baselinePoint);
   ASSERT_TRUE(!!result);
 
   point = WebPoint(baselinePoint.x, frameView->height() - baselinePoint.y);
   result = WebSubstringUtil::attributedWordAtPoint(frame->frameWidget(), point,
                                                    baselinePoint);
   ASSERT_TRUE(!!result);
 }
 
 TEST_P(WebViewTest, WebSubstringUtilIframe) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("single_iframe.html"));
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("visible_iframe.html"));
+  registerMockedHttpURLLoad("single_iframe.html");
+  registerMockedHttpURLLoad("visible_iframe.html");
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "single_iframe.html");
   webView->settings()->setDefaultFontSize(12);
   webView->settings()->setJavaScriptEnabled(true);
   webView->resize(WebSize(400, 400));
   WebLocalFrameImpl* mainFrame = webView->mainFrameImpl();
   WebLocalFrameImpl* childFrame = WebLocalFrameImpl::fromFrame(
       toLocalFrame(mainFrame->frame()->tree().firstChild()));
 
   WebPoint baselinePoint;
@@ skipping 17 matching lines @@
   result = WebSubstringUtil::attributedWordAtPoint(mainFrame->frameWidget(),
                                                    point, baselinePoint);
   ASSERT_NE(result, nullptr);
 
   EXPECT_EQ(yBeforeChange, baselinePoint.y + 100);
 }
 
 #endif
 
 TEST_P(WebViewTest, PasswordFieldEditingIsUserGesture) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("input_field_password.html"));
+  registerMockedHttpURLLoad("input_field_password.html");
   MockAutofillClient client;
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_password.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
   EXPECT_TRUE(
@@ skipping 100 matching lines @@
   // ...but not yet detached.
   EXPECT_TRUE(mainFrame->host());
 
   {
     ScopedPageSuspender suspender;
     EXPECT_TRUE(page->suspended());
   }
 }
 
 TEST_P(WebViewTest, ForceAndResetViewport) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("200-by-300.html"));
+  registerMockedHttpURLLoad("200-by-300.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html");
   webViewImpl->resize(WebSize(100, 150));
   webViewImpl->layerTreeView()->setViewportSize(WebSize(100, 150));
   VisualViewport* visualViewport =
       &webViewImpl->page()->frameHost().visualViewport();
   DevToolsEmulator* devToolsEmulator = webViewImpl->devToolsEmulator();
 
   TransformationMatrix expectedMatrix;
   expectedMatrix.makeIdentity();
@@ skipping 25 matching lines @@
   // visual viewport clipping.
   devToolsEmulator->resetViewport();
   expectedMatrix.makeIdentity();
   EXPECT_EQ(expectedMatrix,
             webViewImpl->getDeviceEmulationTransformForTesting());
   EXPECT_FALSE(devToolsEmulator->visibleContentRectForPainting());
   EXPECT_TRUE(visualViewport->containerLayer()->masksToBounds());
 }
 
 TEST_P(WebViewTest, ViewportOverrideIntegratesDeviceMetricsOffsetAndScale) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("200-by-300.html"));
+  registerMockedHttpURLLoad("200-by-300.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html");
   webViewImpl->resize(WebSize(100, 150));
 
   TransformationMatrix expectedMatrix;
   expectedMatrix.makeIdentity();
   EXPECT_EQ(expectedMatrix,
             webViewImpl->getDeviceEmulationTransformForTesting());
 
   WebDeviceEmulationParams emulationParams;
   emulationParams.offset = WebFloatPoint(50, 50);
   emulationParams.scale = 2.f;
   webViewImpl->enableDeviceEmulation(emulationParams);
   expectedMatrix.makeIdentity().translate(50, 50).scale(2.f);
   EXPECT_EQ(expectedMatrix,
             webViewImpl->getDeviceEmulationTransformForTesting());
 
   // Device metrics offset and scale are applied before viewport override.
   webViewImpl->devToolsEmulator()->forceViewport(WebFloatPoint(5, 10), 1.5f);
   expectedMatrix.makeIdentity()
       .scale(1.5f)
       .translate(-5, -10)
       .translate(50, 50)
       .scale(2.f);
   EXPECT_EQ(expectedMatrix,
             webViewImpl->getDeviceEmulationTransformForTesting());
 }
 
 TEST_P(WebViewTest, ViewportOverrideAdaptsToScaleAndScroll) {
-  URLTestHelpers::registerMockedURLFromBaseURL(
-      WebString::fromUTF8(m_baseURL.c_str()),
-      WebString::fromUTF8("200-by-300.html"));
+  registerMockedHttpURLLoad("200-by-300.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(m_baseURL + "200-by-300.html");
   webViewImpl->resize(WebSize(100, 150));
   webViewImpl->layerTreeView()->setViewportSize(WebSize(100, 150));
   FrameView* frameView = webViewImpl->mainFrameImpl()->frame()->view();
   DevToolsEmulator* devToolsEmulator = webViewImpl->devToolsEmulator();
 
   TransformationMatrix expectedMatrix;
   expectedMatrix.makeIdentity();
   EXPECT_EQ(expectedMatrix,
@@ skipping 90 matching lines @@
   EXPECT_EQ(expectedWidth, vwElement->offsetWidth());
   EXPECT_EQ(expectedHeight, vwElement->offsetHeight());
 
   webView->resize(WebSize(800, 600));
   frame->printEnd();
 
   EXPECT_EQ(800, vwElement->offsetWidth());
 }
 
 }  // namespace blink