Merge clearImage() and clearImageAndNotifyObservers() into updateImage()

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 219 matching lines @@
 
   // Don't notify observers and clients of completion if this ImageResource is
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
   Resource::didAddClient(client);
 }
 
 void ImageResource::destroyDecodedDataForFailedRevalidation() {
-  getContent()->clearImage();
+  // Clears the image, as we must create a new image for the failed
+  // revalidation response.
+  getContent()->updateImage(nullptr, ImageResourceContent::ClearAndUpdateImage,

[yhirano, 2016/12/19 11:50:26]

Isn't this ClearImageOnly?

[hiroshige, 2016/12/19 22:51:50]

No.
Here, we want to clear the image without notifying observers, to keep the
current behavior.
- If we use ClearImageOnly, the image is cleared but the observers are notified.
- If we use ClearAndUpdateImage, the image is cleared and the observers are not
notified because of the following if statement in updateImage():
    if (m_sizeAvailable == Image::SizeUnavailable && !allDataReceived)
      return;

In another perspective, using ClearAndUpdateImage here lets ImageResourceContent
to decide whether to notify observers (and in this case it doesn't), which might
look reasonable.

[yhirano, 2016/12/20 12:09:16]

Then I think the enum naming is confusing - ClearImageOnly sounds more
restrictive than 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::KeepExistingImage, false);
+      getContent()->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::KeepExistingImage, false);
+    getContent()->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::ClearExistingImage,
+  getContent()->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::KeepExistingImage,
-                              true);
+    getContent()->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()->clearImageAndNotifyObservers(
-      ImageResourceContent::ShouldNotifyFinish);
+  getContent()->updateImage(nullptr, ImageResourceContent::ClearImageOnly,
+                            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 48 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()->clearImageAndNotifyObservers(
-        ImageResourceContent::DoNotNotifyFinish);
+    getContent()->updateImage(nullptr, ImageResourceContent::ClearImageOnly,
+                              false);
   }
 
   setStatus(NotStarted);
 
   DCHECK(m_isSchedulingReload);
   m_isSchedulingReload = false;
 
   fetcher->startLoad(this);
 }
 
@@ skipping 50 matching lines @@
 
 const ImageResourceContent* ImageResource::getContent() const {
   return m_content;
 }
 
 ResourcePriority ImageResource::priorityFromObservers() {
   return getContent()->priorityFromObservers();
 }
 
 }  // namespace blink