Separate preload matching from MemoryCache

third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp

Index: third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp
diff --git a/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp b/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp
index 6b3047689356e9cb628ceb566dd552ee86c0ff1a..13638fc15d3dec5318932fa6d19a7db4b7227d27 100644
--- a/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp
+++ b/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp
@@ -493,18 +493,22 @@ TEST_F(ResourceFetcherTest, PreloadResourceTwice) {
 
   FetchParameters fetch_params_original =
       FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
+  fetch_params_original.SetLinkPreload(true);
   Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
   ASSERT_TRUE(resource);
+  EXPECT_TRUE(resource->IsLinkPreload());
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource));
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
-  fetcher->PreloadStarted(resource);
 
   FetchParameters fetch_params =
       FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
+  fetch_params.SetLinkPreload(true);
   Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
   EXPECT_EQ(resource, new_resource);
-  fetcher->PreloadStarted(resource);
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource));
 
   fetcher->ClearPreloads(ResourceFetcher::kClearAllPreloads);
+  EXPECT_FALSE(fetcher->ContainsAsPreload(resource));
   EXPECT_FALSE(GetMemoryCache()->Contains(resource));
   EXPECT_FALSE(resource->IsPreloaded());
 }
@@ -523,7 +527,6 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
-  fetcher->PreloadStarted(resource);
 
   // Resource created by preload scanner
   FetchParameters fetch_params_preload_scanner =
@@ -532,7 +535,6 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
       MockResource::Fetch(fetch_params_preload_scanner, fetcher);
   EXPECT_EQ(resource, preload_scanner_resource);
   EXPECT_FALSE(resource->IsLinkPreload());
-  fetcher->PreloadStarted(resource);
 
   // Resource created by parser
   FetchParameters fetch_params =
@@ -548,7 +550,29 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
   EXPECT_FALSE(resource->IsPreloaded());
 }
 
-TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndUse) {
+TEST_F(ResourceFetcherTest, PreloadMatchWithBypassingCache) {
+  ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
+  KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.png");
+  RegisterMockedURLLoad(url);
+
+  FetchParameters fetch_params_original =
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
+  fetch_params_original.SetLinkPreload(true);
+  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  ASSERT_TRUE(resource);
+  EXPECT_TRUE(resource->IsLinkPreload());
+  Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
+
+  FetchParameters fetch_params_second =
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
+  fetch_params_second.MutableResourceRequest().SetCachePolicy(
+      WebCachePolicy::kBypassingCache);
+  Resource* second_resource = MockResource::Fetch(fetch_params_second, fetcher);
+  EXPECT_EQ(resource, second_resource);
+  EXPECT_FALSE(resource->IsLinkPreload());
+}
+
+TEST_F(ResourceFetcherTest, CrossFramePreloadMatchIsNotAllowed) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
   ResourceFetcher* fetcher2 = ResourceFetcher::Create(Context());
 
@@ -562,73 +586,116 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndUse) {
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
-  fetcher->PreloadStarted(resource);
 
   FetchParameters fetch_params_second =
       FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
-  fetch_params_second.SetLinkPreload(true);
+  fetch_params_second.MutableResourceRequest().SetCachePolicy(
+      WebCachePolicy::kBypassingCache);
   Resource* second_resource =
       MockResource::Fetch(fetch_params_second, fetcher2);
-  ASSERT_TRUE(second_resource);
-  EXPECT_TRUE(second_resource->IsLinkPreload());
-  Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
-  fetcher2->PreloadStarted(second_resource);
 
-  // Link rel preload scanner
-  FetchParameters fetch_params_link_preload_scanner =
-      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
-  fetch_params_link_preload_scanner.SetLinkPreload(true);
-  Resource* link_preload_scanner_resource =
-      MockResource::Fetch(fetch_params_link_preload_scanner, fetcher);
-  EXPECT_EQ(resource, link_preload_scanner_resource);
+  EXPECT_NE(resource, second_resource);
   EXPECT_TRUE(resource->IsLinkPreload());
-  fetcher->PreloadStarted(resource);
+}
 
-  // Resource created by preload scanner
-  FetchParameters fetch_params_preload_scanner =
-      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
-  Resource* preload_scanner_resource =
-      MockResource::Fetch(fetch_params_preload_scanner, fetcher);
-  EXPECT_EQ(resource, preload_scanner_resource);
-  EXPECT_FALSE(resource->IsLinkPreload());
-  fetcher->PreloadStarted(resource);
+TEST_F(ResourceFetcherTest, RepetitiveLinkPreloadShouldBeMerged) {
+  ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
 
-  // Resource created by preload scanner on the second fetcher
-  FetchParameters fetch_params_preload_scanner2 =
-      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
-  Resource* preload_scanner_resource2 =
-      MockResource::Fetch(fetch_params_preload_scanner2, fetcher2);
-  EXPECT_EQ(resource, preload_scanner_resource2);
-  EXPECT_FALSE(resource->IsLinkPreload());
-  fetcher2->PreloadStarted(resource);
+  KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.png");
+  RegisterMockedURLLoad(url);
 
-  // Resource created by parser
-  FetchParameters fetch_params =
+  FetchParameters fetch_params_for_request =
       FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
-  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
-  Persistent<MockResourceClient> client = new MockResourceClient(new_resource);
-  EXPECT_EQ(resource, new_resource);
-  EXPECT_FALSE(resource->IsLinkPreload());
+  FetchParameters fetch_params_for_preload = fetch_params_for_request;
+  fetch_params_for_preload.SetLinkPreload(true);
 
-  // Resource created by parser on the second fetcher
-  FetchParameters fetch_params2 =
+  Resource* resource1 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  ASSERT_TRUE(resource1);
+  EXPECT_TRUE(resource1->IsPreloaded());
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
+  Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
+
+  // The second preload fetch returnes the first preload.
+  Resource* resource2 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
+  EXPECT_TRUE(resource1->IsPreloaded());
+  EXPECT_EQ(resource1, resource2);
+
+  // preload matching
+  Resource* resource3 = MockResource::Fetch(fetch_params_for_request, fetcher);
+  EXPECT_EQ(resource1, resource3);
+  EXPECT_FALSE(fetcher->ContainsAsPreload(resource1));
+  EXPECT_FALSE(resource1->IsPreloaded());
+}
+
+TEST_F(ResourceFetcherTest, RepetitiveSpeculativePreloadShouldBeMerged) {
+  ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
+
+  KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.png");
+  RegisterMockedURLLoad(url);
+
+  FetchParameters fetch_params_for_request =
       FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
-  Resource* new_resource2 = MockResource::Fetch(fetch_params, fetcher2);
-  Persistent<MockResourceClient> client2 =
-      new MockResourceClient(new_resource2);
-  EXPECT_EQ(resource, new_resource2);
-  EXPECT_FALSE(resource->IsLinkPreload());
+  FetchParameters fetch_params_for_preload = fetch_params_for_request;
+  fetch_params_for_preload.SetSpeculativePreloadType(
+      FetchParameters::SpeculativePreloadType::kInDocument);
+
+  Resource* resource1 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  ASSERT_TRUE(resource1);
+  EXPECT_TRUE(resource1->IsPreloaded());
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
+  Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
 
-  // DCL reached on first fetcher
-  EXPECT_TRUE(resource->IsPreloaded());
-  fetcher->ClearPreloads(ResourceFetcher::kClearSpeculativeMarkupPreloads);
-  EXPECT_TRUE(GetMemoryCache()->Contains(resource));
-  EXPECT_TRUE(resource->IsPreloaded());
+  // The second preload fetch returnes the first preload.
+  Resource* resource2 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
+  EXPECT_TRUE(resource1->IsPreloaded());
+  EXPECT_EQ(resource1, resource2);
+
+  // preload matching
+  Resource* resource3 = MockResource::Fetch(fetch_params_for_request, fetcher);
+  EXPECT_EQ(resource1, resource3);
+  EXPECT_FALSE(fetcher->ContainsAsPreload(resource1));
+  EXPECT_FALSE(resource1->IsPreloaded());
+}
 
-  // DCL reached on second fetcher
-  fetcher2->ClearPreloads(ResourceFetcher::kClearSpeculativeMarkupPreloads);
-  EXPECT_TRUE(GetMemoryCache()->Contains(resource));
-  EXPECT_FALSE(resource->IsPreloaded());
+TEST_F(ResourceFetcherTest, SpeculativePreloadShouldBePromotedToLinkePreload) {
+  ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
+
+  KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.png");
+  RegisterMockedURLLoad(url);
+
+  FetchParameters fetch_params_for_request =
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
+  FetchParameters fetch_params_for_speculative_preload =
+      fetch_params_for_request;
+  fetch_params_for_speculative_preload.SetSpeculativePreloadType(
+      FetchParameters::SpeculativePreloadType::kInDocument);
+  FetchParameters fetch_params_for_link_preload = fetch_params_for_request;
+  fetch_params_for_link_preload.SetLinkPreload(true);
+
+  Resource* resource1 =
+      MockResource::Fetch(fetch_params_for_speculative_preload, fetcher);
+  ASSERT_TRUE(resource1);
+  EXPECT_TRUE(resource1->IsPreloaded());
+  EXPECT_FALSE(resource1->IsLinkPreload());
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
+  Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
+
+  // The second preload fetch returnes the first preload.
+  Resource* resource2 =
+      MockResource::Fetch(fetch_params_for_link_preload, fetcher);
+  EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
+  EXPECT_TRUE(resource1->IsPreloaded());
+  EXPECT_TRUE(resource1->IsLinkPreload());
+  EXPECT_EQ(resource1, resource2);
+
+  // preload matching
+  Resource* resource3 = MockResource::Fetch(fetch_params_for_request, fetcher);
+  EXPECT_EQ(resource1, resource3);
+  EXPECT_FALSE(fetcher->ContainsAsPreload(resource1));
+  EXPECT_FALSE(resource1->IsPreloaded());
+  EXPECT_FALSE(resource1->IsLinkPreload());
 }
 
 TEST_F(ResourceFetcherTest, Revalidate304) {
@@ -670,7 +737,6 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) {
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   EXPECT_FALSE(fetcher->IsFetching());
-  fetcher->PreloadStarted(resource);
 
   // Resource created by parser on the second fetcher
   FetchParameters fetch_params2 =