Make blink::ResourceRequest ctors explicit

third_party/WebKit/Source/core/loader/resource/ImageResourceTest.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 710 matching lines @@
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
   ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 
@@ skipping 269 matching lines @@
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
   EXPECT_TRUE(client2->NotifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDecodeError) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   image_resource->Loader()->DidReceiveResponse(
       WrappedResourceResponse(
           ResourceResponse(test_url, "image/jpeg", 18, g_null_atom)),
       nullptr);
 
   EXPECT_EQ(0, observer->ImageChangedCount());
 
   image_resource->Loader()->DidReceiveData("notactuallyanimage", 18);
 
   EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(ResourceStatus::kDecodeError,
             observer->StatusOnImageNotifyFinished());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_FALSE(image_resource->IsLoading());
 }
 
 TEST(ImageResourceTest, DecodeErrorWithEmptyBody) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   image_resource->Loader()->DidReceiveResponse(
       WrappedResourceResponse(
           ResourceResponse(test_url, "image/jpeg", 0, g_null_atom)),
       nullptr);
 
   EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus());
@@ skipping 52 matching lines @@
   EXPECT_EQ(ResourceStatus::kDecodeError,
             observer->StatusOnImageNotifyFinished());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_FALSE(image_resource->IsLoading());
 }
 
 TEST(ImageResourceTest, FetchDisallowPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kDisallowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                   observer.get());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   KURL test_url(kParsedURLString,
                 "data:image/jpeg;base64," +
                     Base64Encode(reinterpret_cast<const char*>(kJpegImage),
                                  sizeof(kJpegImage)));
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
   ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kDisallowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ(g_null_atom,
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPostRequest) {
@@ skipping 27 matching lines @@
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
 
   image_resource->Loader()->Cancel();
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
   ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
   ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
@@ skipping 19 matching lines @@
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-  FetchParameters params(test_url, FetchInitiatorInfo());
+  FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
   ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
@@ skipping 27 matching lines @@
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
 
-  FetchParameters placeholder_params(test_url, FetchInitiatorInfo());
+  FetchParameters placeholder_params{ResourceRequest(test_url),
+                                     FetchInitiatorInfo()};
   placeholder_params.SetAllowImagePlaceholder();
   ImageResource* image_resource =
       ImageResource::Fetch(placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
-  FetchParameters non_placeholder_params(test_url, FetchInitiatorInfo());
+  FetchParameters non_placeholder_params{ResourceRequest(test_url),
+                                         FetchInitiatorInfo()};
   ImageResource* image_resource2 =
       ImageResource::Fetch(non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer2 =
       MockImageResourceObserver::Create(image_resource2->GetContent());
 
   ImageResource* image_resource3 =
       ImageResource::Fetch(non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer3 =
       MockImageResourceObserver::Create(image_resource3->GetContent());
 
@@ skipping 22 matching lines @@
   EXPECT_FALSE(image_resource2->ShouldShowPlaceholder());
   EXPECT_TRUE(image_resource2->GetContent()->GetImage()->IsBitmapImage());
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
-  FetchParameters placeholder_params(test_url, FetchInitiatorInfo());
+  FetchParameters placeholder_params{ResourceRequest(test_url),
+                                     FetchInitiatorInfo()};
   placeholder_params.SetAllowImagePlaceholder();
   ImageResource* image_resource =
       ImageResource::Fetch(placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 
-  FetchParameters non_placeholder_params(test_url, FetchInitiatorInfo());
+  FetchParameters non_placeholder_params{ResourceRequest(test_url),
+                                         FetchInitiatorInfo()};
   ImageResource* image_resource2 =
       ImageResource::Fetch(non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer2 =
       MockImageResourceObserver::Create(image_resource2->GetContent());
 
   ImageResource* image_resource3 =
       ImageResource::Fetch(non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer3 =
       MockImageResourceObserver::Create(image_resource3->GetContent());
 
@@ skipping 16 matching lines @@
     AtomicString content_range;
   } tests[] = {
       {200, g_null_atom},
       {404, g_null_atom},
       {206, BuildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))},
   };
   for (const auto& test : tests) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-    FetchParameters params(test_url, FetchInitiatorInfo());
+    FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
     params.SetAllowImagePlaceholder();
     ImageResource* image_resource =
         ImageResource::Fetch(params, CreateFetcher());
     EXPECT_EQ(FetchParameters::kAllowPlaceholder,
               params.GetPlaceholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               image_resource->GetResourceRequest().HttpHeaderField("range"));
     EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::Create(image_resource->GetContent());
@@ skipping 38 matching lines @@
   } tests[] = {
       {200, g_null_atom, sizeof(kBadImageData)},
       {206, BuildContentRange(sizeof(kBadImageData), sizeof(kBadImageData)),
        sizeof(kBadImageData)},
       {204, g_null_atom, 0},
   };
   for (const auto& test : tests) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-    FetchParameters params(test_url, FetchInitiatorInfo());
+    FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
     params.SetAllowImagePlaceholder();
     ImageResource* image_resource =
         ImageResource::Fetch(params, CreateFetcher());
     EXPECT_EQ(FetchParameters::kAllowPlaceholder,
               params.GetPlaceholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               image_resource->GetResourceRequest().HttpHeaderField("range"));
     EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::Create(image_resource->GetContent());
@@ skipping 12 matching lines @@
   }
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
   const int kStatusCodes[] = {404, 500};
   for (int status_code : kStatusCodes) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
-    FetchParameters params(test_url, FetchInitiatorInfo());
+    FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
     params.SetAllowImagePlaceholder();
     ImageResource* image_resource =
         ImageResource::Fetch(params, CreateFetcher());
     EXPECT_EQ(FetchParameters::kAllowPlaceholder,
               params.GetPlaceholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               image_resource->GetResourceRequest().HttpHeaderField("range"));
     EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::Create(image_resource->GetContent());
@@ skipping 99 matching lines @@
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height());
 
   WTF::SetTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink