Separate preaload matching from MemoryCache

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

 /*
  * Copyright (c) 2013, 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 475 matching lines @@
 }
 
 TEST_F(ResourceFetcherTest, PreloadResourceTwice) {
   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());
+  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());
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
 
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.png");
   RegisterMockedURLLoad(url);
 
   // Link preload preload scanner
   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();
-  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);
 
   // Resource created by parser
   FetchParameters fetch_params =
       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());
 
   // DCL reached
   fetcher->ClearPreloads(ResourceFetcher::kClearSpeculativeMarkupPreloads);
   EXPECT_TRUE(GetMemoryCache()->Contains(resource));
   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());
 
   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();
-  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());
+
+  EXPECT_NE(resource, second_resource);
+  EXPECT_TRUE(resource->IsLinkPreload());
+}
+
+TEST_F(ResourceFetcherTest, RepetitiveLinkPreloadShouldBeMerged) {
+  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_preload = fetch_params_for_request;
+  fetch_params_for_preload.SetLinkPreload(true);
+
+  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();
-  fetcher2->PreloadStarted(second_resource);
 
-  // Link rel preload scanner
-  FetchParameters fetch_params_link_preload_scanner =
+  // 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());
-  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_TRUE(resource->IsLinkPreload());
-  fetcher->PreloadStarted(resource);
+  FetchParameters fetch_params_for_preload = fetch_params_for_request;
+  fetch_params_for_preload.SetSpeculativePreload(true);
 
-  // Resource created by preload scanner
-  FetchParameters fetch_params_preload_scanner =
+  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, 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());
-  Resource* preload_scanner_resource =
-      MockResource::Fetch(fetch_params_preload_scanner, fetcher);
-  EXPECT_EQ(resource, preload_scanner_resource);
-  EXPECT_FALSE(resource->IsLinkPreload());
-  fetcher->PreloadStarted(resource);
+  FetchParameters fetch_params_for_speculative_preload =
+      fetch_params_for_request;
+  fetch_params_for_speculative_preload.SetSpeculativePreload(true);
+  FetchParameters fetch_params_for_link_preload = fetch_params_for_request;
+  fetch_params_for_link_preload.SetLinkPreload(true);
 
-  // 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);
+  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();
 
-  // Resource created by parser
-  FetchParameters fetch_params =
-      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());
+  // 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);
 
-  // Resource created by parser on the second fetcher
-  FetchParameters fetch_params2 =
-      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());
-
-  // DCL reached on first fetcher
-  EXPECT_TRUE(resource->IsPreloaded());
-  fetcher->ClearPreloads(ResourceFetcher::kClearSpeculativeMarkupPreloads);
-  EXPECT_TRUE(GetMemoryCache()->Contains(resource));
-  EXPECT_TRUE(resource->IsPreloaded());
-
-  // DCL reached on second fetcher
-  fetcher2->ClearPreloads(ResourceFetcher::kClearSpeculativeMarkupPreloads);
-  EXPECT_TRUE(GetMemoryCache()->Contains(resource));
-  EXPECT_FALSE(resource->IsPreloaded());
+  // 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) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.html");
   Resource* resource =
       RawResource::Create(ResourceRequest(url), Resource::kRaw);
   GetMemoryCache()->Add(resource);
   ResourceResponse response;
   response.SetURL(url);
   response.SetHTTPStatusCode(304);
@@ skipping 21 matching lines @@
   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());
   EXPECT_FALSE(fetcher->IsFetching());
-  fetcher->PreloadStarted(resource);
 
   // Resource created by parser on the second fetcher
   FetchParameters fetch_params2 =
       FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   Resource* new_resource2 = MockResource::Fetch(fetch_params2, fetcher2);
   Persistent<MockResourceClient> client2 =
       new MockResourceClient(new_resource2);
   EXPECT_NE(resource, new_resource2);
   EXPECT_FALSE(fetcher2->IsFetching());
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
 }
 
 TEST_F(ResourceFetcherTest, ContentTypeDataURL) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
   FetchParameters fetch_params = FetchParameters(
       ResourceRequest("data:text/testmimetype,foo"), FetchInitiatorInfo());
   Resource* resource = MockResource::Fetch(fetch_params, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_EQ(ResourceStatus::kCached, resource->GetStatus());
   EXPECT_EQ("text/testmimetype", resource->GetResponse().MimeType());
   EXPECT_EQ("text/testmimetype", resource->GetResponse().HttpContentType());
 }
 
 }  // namespace blink