Add referrerpolicy support to link prefetch

third_party/WebKit/Source/core/loader/LinkLoaderTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/LinkLoader.h"
 
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/Settings.h"
 #include "core/html/LinkRelAttribute.h"
@@ skipping 234 matching lines @@
           }
         }
       }
       dummyPageHolder->document().fetcher()->clearPreloads();
     }
     memoryCache()->evictResources();
     Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs();
   }
 }
 
+TEST(LinkLoaderTest, Prefetch) {
+  struct TestCase {
+    const char* href;
+    // TODO(yoav): Add support for type and media crbug.com/662687
+    const char* type;
+    const char* media;
+    const ReferrerPolicy referrerPolicy;
+    const bool linkLoaderShouldLoadValue;
+    const bool expectingLoad;
+    const ReferrerPolicy expectedReferrerPolicy;
+  } cases[] = {
+      // Referrer Policy
+      {"http://example.test/cat.jpg", "image/jpg", "", ReferrerPolicyOrigin,
+       true, true, ReferrerPolicyOrigin},
+      {"http://example.test/cat.jpg", "image/jpg", "",
+       ReferrerPolicyOriginWhenCrossOrigin, true, true,
+       ReferrerPolicyOriginWhenCrossOrigin},
+      {"http://example.test/cat.jpg", "image/jpg", "", ReferrerPolicyNever,
+       true, true, ReferrerPolicyNever},
+  };
+
+  // Test the cases with a single header
+  for (const auto& testCase : cases) {
+    std::unique_ptr<DummyPageHolder> dummyPageHolder =
+        DummyPageHolder::create(IntSize(500, 500));
+    dummyPageHolder->frame().settings()->setScriptEnabled(true);
+    Persistent<MockLinkLoaderClient> loaderClient =
+        MockLinkLoaderClient::create(testCase.linkLoaderShouldLoadValue);
+    LinkLoader* loader = LinkLoader::create(loaderClient.get());
+    KURL hrefURL = KURL(KURL(), testCase.href);
+    URLTestHelpers::registerMockedErrorURLLoad(hrefURL);
+    loader->loadLink(LinkRelAttribute("prefetch"), CrossOriginAttributeNotSet,
+                     testCase.type, "", testCase.media, testCase.referrerPolicy,
+                     hrefURL, dummyPageHolder->document(), NetworkHintsMock());
+    ASSERT_TRUE(dummyPageHolder->document().fetcher());
+    Resource* resource = loader->resource();
+    if (testCase.expectingLoad) {
+      EXPECT_TRUE(resource);
+    } else {
+      EXPECT_FALSE(resource);
+    }
+    if (resource) {
+      if (testCase.expectedReferrerPolicy != ReferrerPolicyDefault) {
+        EXPECT_EQ(testCase.expectedReferrerPolicy,
+                  resource->resourceRequest().getReferrerPolicy());
+      }
+    }
+    Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs();
+  }
+}
+
 TEST(LinkLoaderTest, DNSPrefetch) {
   struct {
     const char* href;
     const bool shouldLoad;
   } cases[] = {
       {"http://example.com/", true},
       {"https://example.com/", true},
       {"//example.com/", true},
+      {"//example.com/", false},
   };
 
-  // TODO(yoav): Test (and fix) shouldLoad = false
-
   // Test the cases with a single header
   for (const auto& testCase : cases) {
     std::unique_ptr<DummyPageHolder> dummyPageHolder =
         DummyPageHolder::create(IntSize(500, 500));
     dummyPageHolder->document().settings()->setDNSPrefetchingEnabled(true);
     Persistent<MockLinkLoaderClient> loaderClient =
         MockLinkLoaderClient::create(testCase.shouldLoad);
     LinkLoader* loader = LinkLoader::create(loaderClient.get());
     KURL hrefURL =
         KURL(KURL(ParsedURLStringTag(), String("http://example.com")),
@@ skipping 13 matching lines @@
     const char* href;
     CrossOriginAttributeValue crossOrigin;
     const bool shouldLoad;
     const bool isHTTPS;
     const bool isCrossOrigin;
   } cases[] = {
       {"http://example.com/", CrossOriginAttributeNotSet, true, false, false},
       {"https://example.com/", CrossOriginAttributeNotSet, true, true, false},
       {"http://example.com/", CrossOriginAttributeAnonymous, true, false, true},
       {"//example.com/", CrossOriginAttributeNotSet, true, false, false},
+      {"http://example.com/", CrossOriginAttributeNotSet, false, false, false},
   };
 
   // Test the cases with a single header
   for (const auto& testCase : cases) {
     std::unique_ptr<DummyPageHolder> dummyPageHolder =
         DummyPageHolder::create(IntSize(500, 500));
     Persistent<MockLinkLoaderClient> loaderClient =
         MockLinkLoaderClient::create(testCase.shouldLoad);
     LinkLoader* loader = LinkLoader::create(loaderClient.get());
     KURL hrefURL =
         KURL(KURL(ParsedURLStringTag(), String("http://example.com")),
              testCase.href);
     NetworkHintsMock networkHints;
     loader->loadLink(LinkRelAttribute("preconnect"), testCase.crossOrigin,
                      String(), String(), String(), ReferrerPolicyDefault,
                      hrefURL, dummyPageHolder->document(), networkHints);
     EXPECT_EQ(testCase.shouldLoad, networkHints.didPreconnect());
     EXPECT_EQ(testCase.isHTTPS, networkHints.isHTTPS());
     EXPECT_EQ(testCase.isCrossOrigin, networkHints.isCrossOrigin());
   }
 }
 
 }  // namespace blink