Make blink::ResourceRequest ctors explicit

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 102 matching lines @@
   FetchParameters fetch_params =
       FetchParameters(resource_request, FetchInitiatorInfo());
   Resource* resource = RawResource::Fetch(fetch_params, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->ErrorOccurred());
   EXPECT_TRUE(resource->GetResourceError().IsAccessCheck());
   EXPECT_FALSE(GetMemoryCache()->ResourceForURL(secure_url));
 
   // Start by calling startLoad() directly, rather than via requestResource().
   // This shouldn't crash.
-  fetcher->StartLoad(RawResource::Create(secure_url, Resource::kRaw));
+  fetcher->StartLoad(
+      RawResource::Create(ResourceRequest(secure_url), Resource::kRaw));
 }
 
 TEST_F(ResourceFetcherTest, UseExistingResource) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
 
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.html");
   ResourceResponse response;
   response.SetURL(url);
   response.SetHTTPStatusCode(200);
   response.SetHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   RegisterMockedURLLoadWithCustomResponse(url, response);
 
-  FetchParameters fetch_params = FetchParameters(url, FetchInitiatorInfo());
+  FetchParameters fetch_params =
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   Resource* resource = MockResource::Fetch(fetch_params, fetcher);
   ASSERT_TRUE(resource);
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
   EXPECT_TRUE(resource->IsLoaded());
   EXPECT_TRUE(GetMemoryCache()->Contains(resource));
 
   Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
   EXPECT_EQ(resource, new_resource);
 }
 
 TEST_F(ResourceFetcherTest, Vary) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.html");
-  Resource* resource = RawResource::Create(url, Resource::kRaw);
+  Resource* resource =
+      RawResource::Create(ResourceRequest(url), Resource::kRaw);
   GetMemoryCache()->Add(resource);
   ResourceResponse response;
   response.SetURL(url);
   response.SetHTTPStatusCode(200);
   response.SetHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.SetHTTPHeaderField(HTTPNames::Vary, "*");
   resource->ResponseReceived(response, nullptr);
   resource->Finish();
-  ASSERT_TRUE(resource->MustReloadDueToVaryHeader(url));
+  ASSERT_TRUE(resource->MustReloadDueToVaryHeader(ResourceRequest(url)));
 
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
   ResourceRequest resource_request(url);
   resource_request.SetRequestContext(WebURLRequest::kRequestContextInternal);
   FetchParameters fetch_params =
       FetchParameters(resource_request, FetchInitiatorInfo());
   Platform::Current()->GetURLLoaderMockFactory()->RegisterURL(
       url, WebURLResponse(), "");
   Resource* new_resource = RawResource::Fetch(fetch_params, fetcher);
   EXPECT_NE(resource, new_resource);
@@ skipping 36 matching lines @@
   ResourceRequest redirect_resource_request(url);
   fetcher->RecordResourceTimingOnRedirect(resource, redirect_response, false);
   EXPECT_EQ(navigation_timing_info->TransferSize(),
             encoded_data_length + redirect_encoded_data_length);
 }
 
 TEST_F(ResourceFetcherTest, VaryOnBack) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
 
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.html");
-  Resource* resource = RawResource::Create(url, Resource::kRaw);
+  Resource* resource =
+      RawResource::Create(ResourceRequest(url), Resource::kRaw);
   GetMemoryCache()->Add(resource);
   ResourceResponse response;
   response.SetURL(url);
   response.SetHTTPStatusCode(200);
   response.SetHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.SetHTTPHeaderField(HTTPNames::Vary, "*");
   resource->ResponseReceived(response, nullptr);
   resource->Finish();
-  ASSERT_TRUE(resource->MustReloadDueToVaryHeader(url));
+  ASSERT_TRUE(resource->MustReloadDueToVaryHeader(ResourceRequest(url)));
 
   ResourceRequest resource_request(url);
   resource_request.SetCachePolicy(WebCachePolicy::kReturnCacheDataElseLoad);
   resource_request.SetRequestContext(WebURLRequest::kRequestContextInternal);
   FetchParameters fetch_params =
       FetchParameters(resource_request, FetchInitiatorInfo());
   Resource* new_resource = RawResource::Fetch(fetch_params, fetcher);
   EXPECT_EQ(resource, new_resource);
 }
 
 TEST_F(ResourceFetcherTest, VaryResource) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
 
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.html");
   ResourceResponse response;
   response.SetURL(url);
   response.SetHTTPStatusCode(200);
   response.SetHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.SetHTTPHeaderField(HTTPNames::Vary, "*");
   RegisterMockedURLLoadWithCustomResponse(url, response);
 
   FetchParameters fetch_params_original =
-      FetchParameters(url, FetchInitiatorInfo());
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
   ASSERT_TRUE(resource);
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
-  ASSERT_TRUE(resource->MustReloadDueToVaryHeader(url));
+  ASSERT_TRUE(resource->MustReloadDueToVaryHeader(ResourceRequest(url)));
 
-  FetchParameters fetch_params = FetchParameters(url, FetchInitiatorInfo());
+  FetchParameters fetch_params =
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
   EXPECT_EQ(resource, new_resource);
 }
 
 class RequestSameResourceOnComplete
     : public GarbageCollectedFinalized<RequestSameResourceOnComplete>,
       public RawResourceClient {
   USING_GARBAGE_COLLECTED_MIXIN(RequestSameResourceOnComplete);
 
  public:
@@ skipping 216 matching lines @@
             resource->GetResourceRequest().Priority());
 }
 
 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(url, FetchInitiatorInfo());
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
   ASSERT_TRUE(resource);
   Platform::Current()->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
   fetcher->PreloadStarted(resource);
 
-  FetchParameters fetch_params = FetchParameters(url, FetchInitiatorInfo());
+  FetchParameters fetch_params =
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
   EXPECT_EQ(resource, new_resource);
   fetcher->PreloadStarted(resource);
 
   fetcher->ClearPreloads(ResourceFetcher::kClearAllPreloads);
   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(url, FetchInitiatorInfo());
+      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(url, FetchInitiatorInfo());
+      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(url, FetchInitiatorInfo());
+  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) {
   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(url, FetchInitiatorInfo());
+      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(url, FetchInitiatorInfo());
+      FetchParameters(ResourceRequest(url), FetchInitiatorInfo());
   fetch_params_second.SetLinkPreload(true);
   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(url, FetchInitiatorInfo());
+      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);
 
   // Resource created by preload scanner
   FetchParameters fetch_params_preload_scanner =
-      FetchParameters(url, FetchInitiatorInfo());
+      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 preload scanner on the second fetcher
   FetchParameters fetch_params_preload_scanner2 =
-      FetchParameters(url, FetchInitiatorInfo());
+      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 created by parser
-  FetchParameters fetch_params = FetchParameters(url, FetchInitiatorInfo());
+  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());
 
   // Resource created by parser on the second fetcher
-  FetchParameters fetch_params2 = FetchParameters(url, FetchInitiatorInfo());
+  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());
 }
 
 TEST_F(ResourceFetcherTest, Revalidate304) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo.html");
-  Resource* resource = RawResource::Create(url, Resource::kRaw);
+  Resource* resource =
+      RawResource::Create(ResourceRequest(url), Resource::kRaw);
   GetMemoryCache()->Add(resource);
   ResourceResponse response;
   response.SetURL(url);
   response.SetHTTPStatusCode(304);
   response.SetHTTPHeaderField("etag", "1234567890");
   resource->ResponseReceived(response, nullptr);
   resource->Finish();
 
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
   ResourceRequest resource_request(url);
   resource_request.SetRequestContext(WebURLRequest::kRequestContextInternal);
   FetchParameters fetch_params =
       FetchParameters(resource_request, FetchInitiatorInfo());
   Platform::Current()->GetURLLoaderMockFactory()->RegisterURL(
       url, WebURLResponse(), "");
   Resource* new_resource = RawResource::Fetch(fetch_params, fetcher);
   fetcher->StopFetching();
 
   EXPECT_NE(resource, new_resource);
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) {
   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(url, FetchInitiatorInfo());
+      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(url, FetchInitiatorInfo());
+  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(KURL(kParsedURLString, "data:text/testmimetype,foo"),
-                      FetchInitiatorInfo());
+  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