cc/blink: Veto checker-imaging for multipart image resources.

third_party/WebKit/Source/core/loader/resource/ImageResourceContent.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/resource/ImageResourceContent.h"
 
 #include <memory>
 
 #include "core/loader/resource/ImageResource.h"
 #include "core/loader/resource/ImageResourceInfo.h"
@@ skipping 295 matching lines @@
             observers_.Contains(observer) &&
             !info_->SchedulingReloadOrShouldReloadBrokenPlaceholder()) {
           MarkObserverFinished(observer);
           observer->ImageNotifyFinished(this);
         }
       }
     }
   }
 }
 
-PassRefPtr<Image> ImageResourceContent::CreateImage() {
+PassRefPtr<Image> ImageResourceContent::CreateImage(bool is_multipart) {
   if (info_->GetResponse().MimeType() == "image/svg+xml")
-    return SVGImage::Create(this);
-  return BitmapImage::Create(this);
+    return SVGImage::Create(this, is_multipart);
+  return BitmapImage::Create(this, is_multipart);
 }
 
 void ImageResourceContent::ClearImage() {
   if (!image_)
     return;
   int64_t length = image_->Data() ? image_->Data()->size() : 0;
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-length);
 
   // If our Image has an observer, it's always us so we need to clear the back
   // pointer before dropping our reference.
@@ skipping 82 matching lines @@
   CHECK_EQ(size_available_, Image::kSizeAvailableAndLoadingAsynchronously);
   size_available_ = Image::kSizeAvailable;
   UpdateToLoadedContentStatus(ResourceStatus::kCached);
   NotifyObservers(kShouldNotifyFinish);
 }
 
 ImageResourceContent::UpdateImageResult ImageResourceContent::UpdateImage(
     PassRefPtr<SharedBuffer> data,
     ResourceStatus status,
     UpdateImageOption update_image_option,
-    bool all_data_received) {
+    bool all_data_received,
+    bool is_multipart) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
 #if DCHECK_IS_ON()
   DCHECK(!is_update_image_being_called_);
   AutoReset<bool> scope(&is_update_image_being_called_, true);
 #endif
 
   CHECK_NE(GetContentStatus(), ResourceStatus::kNotStarted);
 
   // Clears the existing image, if instructed by |updateImageOption|.
@@ skipping 12 matching lines @@
       DCHECK(!data);
       break;
 
     case kUpdateImage:
     case kClearAndUpdateImage:
       // Have the image update its data from its internal buffer. It will not do
       // anything now, but will delay decoding until queried for info (like size
       // or specific image frames).
       if (data) {
         if (!image_)
-          image_ = CreateImage();
+          image_ = CreateImage(is_multipart);
         DCHECK(image_);
         size_available_ = image_->SetData(std::move(data), all_data_received);
         DCHECK(all_data_received ||
                size_available_ !=
                    Image::kSizeAvailableAndLoadingAsynchronously);
       }
 
       // Go ahead and tell our observers to try to draw if we have either
       // received all the data or the size is known. Each chunk from the network
       // causes observers to repaint, which will force that chunk to decode.
@@ skipping 155 matching lines @@
 
 const ResourceResponse& ImageResourceContent::GetResponse() const {
   return info_->GetResponse();
 }
 
 const ResourceError& ImageResourceContent::GetResourceError() const {
   return info_->GetResourceError();
 }
 
 }  // namespace blink