Phase II Step 2: Remove setIsPlaceholder() in updateImage()

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 170 matching lines @@
                                             WebCachePolicy policyForReload) {
   const char* data = reinterpret_cast<const char*>(kJpegImage2);
   constexpr size_t dataLength = sizeof(kJpegImage2);
   constexpr int imageWidth = 50;
   constexpr int imageHeight = 50;
 
   // Checks that |imageResource| and |content| are ready for non-placeholder
   // reloading.
   EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
   EXPECT_FALSE(imageResource->resourceBuffer());
-  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(policyForReload, imageResource->resourceRequest().getCachePolicy());
   EXPECT_EQ(content, imageResource->getContent());
   EXPECT_FALSE(content->hasImage());
 
   // Checks |observer| before reloading.
   const int originalImageChangedCount = observer->imageChangedCount();
   const bool alreadyNotifiedFinish = observer->imageNotifyFinishedCalled();
   const int imageWidthOnImageNotifyFinished =
@@ skipping 373 matching lines @@
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(response));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage),
       kJpegImageSubrangeWithDimensionsLength);
   imageResource->loader()->didFinishLoading(
       0.0, kJpegImageSubrangeWithDimensionsLength,
       kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
-  EXPECT_TRUE(imageResource->isPlaceholder());
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
 
   imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
                                                 Resource::kReloadAlways);
 
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
@@ skipping 360 matching lines @@
 TEST(ImageResourceTest, FetchDisallowPlaceholder) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
       ResourceResponse(testURL, "image/jpeg", sizeof(kJpegImage), nullAtom)));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
                                             sizeof(kJpegImage));
 
   EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
   EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
-  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   EXPECT_LT(0, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   KURL testURL(ParsedURLString,
                "data:image/jpeg;base64," +
                    base64Encode(reinterpret_cast<const char*>(kJpegImage),
                                 sizeof(kJpegImage)));
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPostRequest) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest resourceRequest(testURL);
   resourceRequest.setHTTPMethod("POST");
   FetchRequest request(resourceRequest, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
 
   imageResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest resourceRequest(testURL);
   resourceRequest.setHTTPHeaderField("range", "bytes=128-255");
   FetchRequest request(resourceRequest, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=128-255",
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
 
   imageResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_TRUE(imageResource->isPlaceholder());
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom);
   response.setHTTPStatusCode(206);
   response.setHTTPHeaderField(
       "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
                                          sizeof(kJpegImage)));
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(response));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage),
       kJpegImageSubrangeWithDimensionsLength);
   imageResource->loader()->didFinishLoading(
       0.0, kJpegImageSubrangeWithDimensionsLength,
       kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
   EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
             imageResource->encodedSize());
-  EXPECT_TRUE(imageResource->isPlaceholder());
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   EXPECT_LT(0, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isSVGImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_TRUE(imageResource->isPlaceholder());
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   const char kBadData[] = "notanimageresponse";
 
   ResourceResponse badResponse(testURL, "image/jpeg", sizeof(kBadData),
                                nullAtom);
   badResponse.setHTTPStatusCode(206);
   badResponse.setHTTPHeaderField(
       "content-range", buildContentRange(sizeof(kBadData), sizeof(kJpegImage)));
@@ skipping 19 matching lines @@
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_TRUE(imageResource->isPlaceholder());
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // TODO(hiroshige): Make the range request header and partial content length
   // consistent. https://crbug.com/689760.
   ResourceResponse partialResponse(testURL, "image/jpeg",
                                    kJpegImageSubrangeWithoutDimensionsLength,
                                    nullAtom);
   partialResponse.setHTTPStatusCode(206);
   partialResponse.setHTTPHeaderField(
@@ skipping 69 matching lines @@
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage),
       kJpegImageSubrangeWithDimensionsLength);
   imageResource->loader()->didFinishLoading(
       0.0, kJpegImageSubrangeWithDimensionsLength,
       kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
   EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
             imageResource->encodedSize());
-  EXPECT_TRUE(imageResource->isPlaceholder());
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   EXPECT_LT(0, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImageResource =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   EXPECT_EQ(imageResource, secondImageResource);
 
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
@@ skipping 14 matching lines @@
     ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
     FetchRequest request(testURL, FetchInitiatorInfo());
     request.setAllowImagePlaceholder();
     ImageResource* imageResource =
         ImageResource::fetch(request, createFetcher());
     EXPECT_EQ(FetchRequest::AllowPlaceholder,
               request.placeholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               imageResource->resourceRequest().httpHeaderField("range"));
-    EXPECT_TRUE(imageResource->isPlaceholder());
+    EXPECT_TRUE(imageResource->shouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::create(imageResource->getContent());
 
     ResourceResponse response(testURL, "image/jpeg", sizeof(kJpegImage),
                               nullAtom);
     response.setHTTPStatusCode(test.statusCode);
     if (test.contentRange != nullAtom)
       response.setHTTPHeaderField("content-range", test.contentRange);
     imageResource->loader()->didReceiveResponse(
         WrappedResourceResponse(response));
     imageResource->loader()->didReceiveData(
         reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
     imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
                                               sizeof(kJpegImage));
 
     EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
     EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
-    EXPECT_FALSE(imageResource->isPlaceholder());
+    EXPECT_FALSE(imageResource->shouldShowPlaceholder());
     EXPECT_LT(0, observer->imageChangedCount());
     EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
     EXPECT_TRUE(observer->imageNotifyFinishedCalled());
     EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
     ASSERT_TRUE(imageResource->getContent()->hasImage());
     EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
     EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
     EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   }
@@ skipping 18 matching lines @@
     ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
     FetchRequest request(testURL, FetchInitiatorInfo());
     request.setAllowImagePlaceholder();
     ImageResource* imageResource =
         ImageResource::fetch(request, createFetcher());
     EXPECT_EQ(FetchRequest::AllowPlaceholder,
               request.placeholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               imageResource->resourceRequest().httpHeaderField("range"));
-    EXPECT_TRUE(imageResource->isPlaceholder());
+    EXPECT_TRUE(imageResource->shouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::create(imageResource->getContent());
 
     ResourceResponse response(testURL, "image/jpeg", test.dataSize, nullAtom);
     response.setHTTPStatusCode(test.statusCode);
     if (test.contentRange != nullAtom)
       response.setHTTPHeaderField("content-range", test.contentRange);
     imageResource->loader()->didReceiveResponse(
         WrappedResourceResponse(response));
     imageResource->loader()->didReceiveData(kBadImageData, test.dataSize);
 
     EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
-    EXPECT_FALSE(imageResource->isPlaceholder());
+    EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   }
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
   const int kStatusCodes[] = {404, 500};
   for (int statusCode : kStatusCodes) {
     KURL testURL(ParsedURLString, kTestURL);
     ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
     FetchRequest request(testURL, FetchInitiatorInfo());
     request.setAllowImagePlaceholder();
     ImageResource* imageResource =
         ImageResource::fetch(request, createFetcher());
     EXPECT_EQ(FetchRequest::AllowPlaceholder,
               request.placeholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               imageResource->resourceRequest().httpHeaderField("range"));
-    EXPECT_TRUE(imageResource->isPlaceholder());
+    EXPECT_TRUE(imageResource->shouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::create(imageResource->getContent());
 
     static const char kBadImageData[] = "bad image data";
 
     ResourceResponse response(testURL, "image/jpeg", sizeof(kBadImageData),
                               nullAtom);
     response.setHTTPStatusCode(statusCode);
     imageResource->loader()->didReceiveResponse(
         WrappedResourceResponse(response));
@@ skipping 91 matching lines @@
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
 
   WTF::setTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink