Do not reload in ImageResource::fetch()

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 1192 matching lines @@
   ResourceFetcher* fetcher = createFetcher();
 
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
-  ImageResource* secondImageResource =
+  ImageResource* imageResource2 =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
+  std::unique_ptr<MockImageResourceObserver> observer2 =
+      MockImageResourceObserver::create(imageResource2->getContent());
 
-  EXPECT_EQ(imageResource, secondImageResource);
+  ImageResource* imageResource3 =
+      ImageResource::fetch(nonPlaceholderRequest, fetcher);
+  std::unique_ptr<MockImageResourceObserver> observer3 =
+      MockImageResourceObserver::create(imageResource3->getContent());
+
+  // |imageResource| remains a placeholder, while following non-placeholder
+  // requests start non-placeholder loading with a separate ImageResource.
+  ASSERT_NE(imageResource, imageResource2);
+  ASSERT_NE(imageResource->loader(), imageResource2->loader());
+  ASSERT_NE(imageResource->getContent(), imageResource2->getContent());
+  ASSERT_EQ(imageResource2, imageResource3);
+
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
+  EXPECT_FALSE(observer2->imageNotifyFinishedCalled());
+  EXPECT_FALSE(observer3->imageNotifyFinishedCalled());
 
-  testThatReloadIsStartedThenServeReload(
-      testURL, imageResource, imageResource->getContent(), observer.get(),
-      WebCachePolicy::UseProtocolCachePolicy);
+  // Checks that |imageResource2| (and |imageResource3|) loads a
+  // non-placeholder image.
+  testThatIsNotPlaceholderRequestAndServeResponse(testURL, imageResource2,
+                                                  observer2.get());
+  EXPECT_TRUE(observer3->imageNotifyFinishedCalled());
+
+  // Checks that |imageResource| will loads a placeholder image.
+  testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
+                                               observer.get());
+
+  // |imageResource2| is still a non-placeholder image.
+  EXPECT_FALSE(imageResource2->shouldShowPlaceholder());
+  EXPECT_TRUE(imageResource2->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceFetcher* fetcher = createFetcher();
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
                                                observer.get());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
-  ImageResource* secondImageResource =
+  ImageResource* imageResource2 =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
-  EXPECT_EQ(imageResource, secondImageResource);
+  std::unique_ptr<MockImageResourceObserver> observer2 =
+      MockImageResourceObserver::create(imageResource2->getContent());
 
-  testThatReloadIsStartedThenServeReload(
-      testURL, imageResource, imageResource->getContent(), observer.get(),
-      WebCachePolicy::UseProtocolCachePolicy);
+  ImageResource* imageResource3 =
+      ImageResource::fetch(nonPlaceholderRequest, fetcher);
+  std::unique_ptr<MockImageResourceObserver> observer3 =
+      MockImageResourceObserver::create(imageResource3->getContent());
+
+  EXPECT_FALSE(observer2->imageNotifyFinishedCalled());
+  EXPECT_FALSE(observer3->imageNotifyFinishedCalled());
+
+  // |imageResource| remains a placeholder, while following non-placeholder
+  // requests start non-placeholder loading with a separate ImageResource.
+  ASSERT_NE(imageResource, imageResource2);
+  ASSERT_EQ(imageResource2, imageResource3);
+
+  testThatIsNotPlaceholderRequestAndServeResponse(testURL, imageResource2,
+                                                  observer2.get());
+  EXPECT_TRUE(observer3->imageNotifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
   const struct {
     int statusCode;
     AtomicString contentRange;
   } tests[] = {
       {200, nullAtom},
       {404, nullAtom},
       {206, buildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))},
@@ skipping 206 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