Explicitly clear the image in the first updateImage() call

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 221 matching lines @@
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
   Resource::didAddClient(client);
 }
 
 void ImageResource::destroyDecodedDataForFailedRevalidation() {
   // Clears the image, as we must create a new image for the failed
   // revalidation response.
-  getContent()->updateImage(nullptr, ImageResourceContent::ClearAndUpdateImage,
-                            false);
+  updateImage(nullptr, ImageResourceContent::ClearAndUpdateImage, false);
   setDecodedSize(0);
 }
 
 void ImageResource::destroyDecodedDataIfPossible() {
   getContent()->destroyDecodedData();
   if (getContent()->hasImage() && !isPreloaded() &&
       getContent()->isRefetchableDataFromDiskCache()) {
     UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer.EstimatedDroppableEncodedSize",
                             encodedSize() / 1024);
   }
@@ skipping 24 matching lines @@
 
 void ImageResource::appendData(const char* data, size_t length) {
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(length);
   if (m_multipartParser) {
     m_multipartParser->appendData(data, length);
   } else {
     Resource::appendData(data, length);
 
     // Update the image immediately if needed.
     if (getContent()->shouldUpdateImageImmediately()) {
-      getContent()->updateImage(this->data(), ImageResourceContent::UpdateImage,
-                                false);
+      updateImage(this->data(), ImageResourceContent::UpdateImage, false);
       return;
     }
 
     // For other cases, only update at |kFlushDelaySeconds| intervals. This
     // throttles how frequently we update |m_image| and how frequently we
     // inform the clients which causes an invalidation of this image. In other
     // words, we only invalidate this image every |kFlushDelaySeconds| seconds
     // while loading.
     if (!m_flushTimer.isActive()) {
       double now = WTF::monotonicallyIncreasingTime();
       if (!m_lastFlushTime)
         m_lastFlushTime = now;
 
       DCHECK_LE(m_lastFlushTime, now);
       double flushDelay = m_lastFlushTime - now + kFlushDelaySeconds;
       if (flushDelay < 0.)
         flushDelay = 0.;
       m_flushTimer.startOneShot(flushDelay, BLINK_FROM_HERE);
     }
   }
 }
 
 void ImageResource::flushImageIfNeeded(TimerBase*) {
   // We might have already loaded the image fully, in which case we don't need
   // to call |updateImage()|.
   if (isLoading()) {
     m_lastFlushTime = WTF::monotonicallyIncreasingTime();
-    getContent()->updateImage(this->data(), ImageResourceContent::UpdateImage,
-                              false);
+    updateImage(this->data(), ImageResourceContent::UpdateImage, false);
   }
 }
 
 bool ImageResource::willPaintBrokenImage() const {
   return errorOccurred();
 }
 
 void ImageResource::decodeError(bool allDataReceived) {
   size_t size = encodedSize();
 
   clearData();
   setEncodedSize(0);
   if (!errorOccurred())
     setStatus(DecodeError);
 
   if (!allDataReceived && loader()) {
     // TODO(hiroshige): Do not call didFinishLoading() directly.
     loader()->didFinishLoading(monotonicallyIncreasingTime(), size, size);
   }
 
   memoryCache()->remove(this);
 }
 
 void ImageResource::updateImageAndClearBuffer() {
-  getContent()->updateImage(data(), ImageResourceContent::ClearAndUpdateImage,
-                            true);
+  updateImage(data(), ImageResourceContent::ClearAndUpdateImage, true);
   clearData();
 }
 
 void ImageResource::finish(double loadFinishTime) {
   if (m_multipartParser) {
     m_multipartParser->finish();
     if (data())
       updateImageAndClearBuffer();
   } else {
-    getContent()->updateImage(data(), ImageResourceContent::UpdateImage, true);
+    updateImage(data(), ImageResourceContent::UpdateImage, true);
     // As encoded image data can be created from m_image  (see
     // ImageResource::resourceBuffer(), we don't have to keep m_data. Let's
     // clear this. As for the lifetimes of m_image and m_data, see this
     // document:
     // https://docs.google.com/document/d/1v0yTAZ6wkqX2U_M6BNIGUJpM1s0TIw1VsqpxoL7aciY/edit?usp=sharing
     clearData();
   }
   Resource::finish(loadFinishTime);
 }
 
 void ImageResource::error(const ResourceError& error) {
   if (m_multipartParser)
     m_multipartParser->cancel();
   // TODO(hiroshige): Move setEncodedSize() call to Resource::error() if it
   // is really needed, or remove it otherwise.
   setEncodedSize(0);
   Resource::error(error);
-  getContent()->updateImage(
-      nullptr, ImageResourceContent::ClearImageAndNotifyObservers, true);
+  updateImage(nullptr, ImageResourceContent::ClearImageAndNotifyObservers,
+              true);
 }
 
 void ImageResource::responseReceived(
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(!handle);
   DCHECK(!m_multipartParser);
   // If there's no boundary, just handle the request normally.
   if (response.isMultipart() && !response.multipartBoundary().isEmpty()) {
     m_multipartParser = new MultipartImageResourceParser(
@@ skipping 50 matching lines @@
   }
 
   if (isLoading()) {
     loader()->cancel();
     // Canceling the loader causes error() to be called, which in turn calls
     // clear() and notifyObservers(), so there's no need to call these again
     // here.
   } else {
     clearData();
     setEncodedSize(0);
-    getContent()->updateImage(
-        nullptr, ImageResourceContent::ClearImageAndNotifyObservers, false);
+    updateImage(nullptr, ImageResourceContent::ClearImageAndNotifyObservers,
+                false);
   }
 
   setStatus(NotStarted);
 
   DCHECK(m_isSchedulingReload);
   m_isSchedulingReload = false;
 
   fetcher->startLoad(this);
 }
 
 void ImageResource::onePartInMultipartReceived(
     const ResourceResponse& response) {
   DCHECK(m_multipartParser);
 
   setResponse(response);
   if (m_multipartParsingState == MultipartParsingState::WaitingForFirstPart) {
     // We have nothing to do because we don't have any data.
     m_multipartParsingState = MultipartParsingState::ParsingFirstPart;
     return;
   }
   updateImageAndClearBuffer();
+  // We should create a new image again when the data for the next part arrive.
+  m_shouldEnforceClearImage = true;
 
   if (m_multipartParsingState == MultipartParsingState::ParsingFirstPart) {
     m_multipartParsingState = MultipartParsingState::FinishedParsingFirstPart;
     // Notify finished when the first part ends.
     if (!errorOccurred())
       setStatus(Cached);
     // We notify clients and observers of finish in checkNotify() and
     // updateImageAndClearBuffer(), respectively, and they will not be
     // notified again in Resource::finish()/error().
     checkNotify();
@@ skipping 28 matching lines @@
 }
 
 const ImageResourceContent* ImageResource::getContent() const {
   return m_content;
 }
 
 ResourcePriority ImageResource::priorityFromObservers() {
   return getContent()->priorityFromObservers();
 }
 
+void ImageResource::updateImage(
+    PassRefPtr<SharedBuffer> sharedBuffer,
+    ImageResourceContent::UpdateImageOption updateImageOption,
+    bool allDataReceived) {
+  if (m_shouldEnforceClearImage &&
+      updateImageOption == ImageResourceContent::UpdateImage)
+    updateImageOption = ImageResourceContent::ClearAndUpdateImage;
+  m_shouldEnforceClearImage = false;
+  getContent()->updateImage(std::move(sharedBuffer), updateImageOption,
+                            allDataReceived);
+}
+
 }  // namespace blink