Only generate suggested filenames when actually dragging an image.

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 229 matching lines @@
   fetcher->startLoad(imageResource);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
   EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
 
   // Send the multipart response. No image or data buffer is created. Note that
   // the response must be routed through ResourceLoader to ensure the load is
   // flagged as multipart.
   ResourceResponse multipartResponse(KURL(), "multipart/x-mixed-replace", 0,
-                                     nullAtom, String());
+                                     nullAtom);
   multipartResponse.setMultipartBoundary("boundary", strlen("boundary"));
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(multipartResponse), nullptr);
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
   EXPECT_EQ(0, observer->imageChangedCount());
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ("multipart/x-mixed-replace", imageResource->response().mimeType());
 
   const char firstPart[] =
@@ skipping 80 matching lines @@
 
 TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients) {
   ImageResource* imageResource = ImageResource::create(ResourceRequest());
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   imageResource->responseReceived(
-      ResourceResponse(KURL(), "multipart/x-mixed-replace", 0, nullAtom,
-                       String()),
+      ResourceResponse(KURL(), "multipart/x-mixed-replace", 0, nullAtom),
       nullptr);
 
   imageResource->responseReceived(
-      ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), nullAtom,
-                       String()),
+      ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), nullAtom),
       nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage),
                             sizeof(kJpegImage));
   EXPECT_NE(0u, imageResource->encodedSizeMemoryUsageForTesting());
   imageResource->finish();
   EXPECT_EQ(0u, imageResource->encodedSizeMemoryUsageForTesting());
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
@@ skipping 17 matching lines @@
 
 TEST(ImageResourceTest, UpdateBitmapImages) {
   ImageResource* imageResource = ImageResource::create(ResourceRequest());
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   imageResource->responseReceived(
-      ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), nullAtom,
-                       String()),
+      ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), nullAtom),
       nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage),
                             sizeof(kJpegImage));
   imageResource->finish();
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
   ResourceRequest request = ResourceRequest(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   ImageResource* imageResource = ImageResource::create(request);
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage),
-                                    nullAtom, String());
+                                    nullAtom);
   resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform",
                                       "empty-image");
 
   imageResource->responseReceived(resourceResponse, nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage),
                             sizeof(kJpegImage));
   imageResource->finish();
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
@@ skipping 43 matching lines @@
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   FetchRequest fetchRequest(request, FetchInitiatorInfo());
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
-  ResourceResponse initialResourceResponse(
-      testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String());
+  ResourceResponse initialResourceResponse(testURL, "image/jpeg",
+                                           sizeof(kJpegImage), nullAtom);
   initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(initialResourceResponse));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
@@ skipping 11 matching lines @@
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_EQ(0, observer->imageWidthOnLastImageChanged());
   // The observer should not have been notified of completion yet, since the
   // image
   // is still loading.
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
   imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(ResourceResponse(
-          testURL, "image/jpeg", sizeof(kJpegImage2), nullAtom, String())),
+      WrappedResourceResponse(ResourceResponse(testURL, "image/jpeg",
+                                               sizeof(kJpegImage2), nullAtom)),
       nullptr);
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
                                             sizeof(kJpegImage2));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(kJpegImage2Width, observer->imageWidthOnLastImageChanged());
@@ skipping 16 matching lines @@
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
-                            kJpegImageSubrangeWithDimensionsLength, nullAtom,
-                            String());
+                            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(
@@ skipping 282 matching lines @@
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(
-          ResourceResponse(testURL, "image/jpeg", 18, nullAtom, String())),
+          ResourceResponse(testURL, "image/jpeg", 18, nullAtom)),
       nullptr);
 
   EXPECT_EQ(0, observer->imageChangedCount());
 
   imageResource->loader()->didReceiveData("notactuallyanimage", 18);
 
   EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(ResourceStatus::DecodeError,
             observer->statusOnImageNotifyFinished());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_FALSE(imageResource->isLoading());
 }
 
 TEST(ImageResourceTest, DecodeErrorWithEmptyBody) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(
-          ResourceResponse(testURL, "image/jpeg", 0, nullAtom, String())),
+          ResourceResponse(testURL, "image/jpeg", 0, nullAtom)),
       nullptr);
 
   EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(0, observer->imageChangedCount());
 
   imageResource->loader()->didFinishLoading(0.0, 0, 0);
 
   EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
@@ skipping 12 matching lines @@
       request,
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_FALSE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
-  imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(ResourceResponse(
-          testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
+  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_LT(0, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
@@ skipping 72 matching lines @@
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
-                            kJpegImageSubrangeWithDimensionsLength, nullAtom,
-                            String());
+                            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(
@@ skipping 28 matching lines @@
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   const char kBadData[] = "notanimageresponse";
 
-  imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(ResourceResponse(
-          testURL, "image/jpeg", sizeof(kBadData), nullAtom, String())));
+  imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
+      ResourceResponse(testURL, "image/jpeg", sizeof(kBadData), nullAtom)));
 
   EXPECT_EQ(0, observer->imageChangedCount());
 
   imageResource->loader()->didReceiveData(kBadData, sizeof(kBadData));
 
   // The dimensions could not be extracted, so the full original image should be
   // loading.
   EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
   EXPECT_FALSE(imageResource->isPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(
       static_cast<int>(WebCachePolicy::BypassingCache),
       static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(3, observer->imageChangedCount());
 
-  imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(ResourceResponse(
-          testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
+  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_LT(3, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
@@ skipping 43 matching lines @@
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
-                            kJpegImageSubrangeWithDimensionsLength, nullAtom,
-                            String());
+                            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(
@@ skipping 29 matching lines @@
   ScopedRegisteredURL scopedRegisteredURL(testURL);
   ResourceRequest request = ResourceRequest(testURL);
   ImageResource* imageResource = ImageResource::create(request);
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage2),
-                                    nullAtom, String());
+                                    nullAtom);
   resourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   imageResource->responseReceived(resourceResponse, nullptr);
 
   // This is number is sufficiently large amount of bytes necessary for the
   // image to be created (since the size is known). This was determined by
   // appending one byte at a time (with flushes) until the image was decoded.
   size_t meaningfulImageSize = 280;
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage2),
                             meaningfulImageSize);
@@ skipping 53 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