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

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 "core/loader/resource/ImageResource.h"
 #include "core/loader/resource/ImageResourceInfo.h"
 #include "core/loader/resource/ImageResourceObserver.h"
 #include "core/svg/graphics/SVGImage.h"
@@ skipping 279 matching lines @@
   int64_t length = m_image->data() ? m_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.
   m_image->clearImageObserver();
   m_image.clear();
   m_sizeAvailable = Image::SizeUnavailable;
 }
 
-void ImageResourceContent::clearImageAndNotifyObservers(
-    NotifyFinishOption notifyingFinishOption) {
-  clearImage();
-  notifyObservers(notifyingFinishOption);
-}
-
 void ImageResourceContent::updateImage(PassRefPtr<SharedBuffer> data,
-                                       ClearImageOption clearImageOption,
+                                       UpdateImageOption updateImageOption,
                                        bool allDataReceived) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
-  if (clearImageOption == ImageResourceContent::ClearExistingImage) {
-    clearImage();
+  // Clears the existing image, if instructed by |updateImageOption|.
+  switch (updateImageOption) {
+    case ClearAndUpdateImage:
+    case ClearImageAndNotifyObservers:
+      clearImage();
+      break;
+    case UpdateImage:
+      break;
   }
 
-  // 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 (!m_image)
-      m_image = createImage();
-    DCHECK(m_image);
-    m_sizeAvailable = m_image->setData(std::move(data), allDataReceived);
+  // Updates the image, if instructed by |updateImageOption|.
+  switch (updateImageOption) {
+    case ClearImageAndNotifyObservers:
+      DCHECK(!data);
+      break;
+
+    case UpdateImage:
+    case ClearAndUpdateImage:
+      // 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 (!m_image)
+          m_image = createImage();
+        DCHECK(m_image);
+        m_sizeAvailable = m_image->setData(std::move(data), allDataReceived);
+      }
+
+      // 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.
+      if (m_sizeAvailable == Image::SizeUnavailable && !allDataReceived)
+        return;
+
+      if (m_info->isPlaceholder() && allDataReceived && m_image &&
+          !m_image->isNull()) {
+        if (m_sizeAvailable == Image::SizeAvailable) {
+          // TODO(sclittle): Show the original image if the response consists of
+          // the entire image, such as if the entire image response body is
+          // smaller than the requested range.
+          IntSize dimensions = m_image->size();
+
+          clearImage();
+          m_image = PlaceholderImage::create(this, dimensions);
+        } else {
+          // Clear the image so that it gets treated like a decoding error,
+          // since the attempt to build a placeholder image failed.
+          clearImage();
+        }
+      }
+      if (!m_image || m_image->isNull()) {
+        clearImage();
+        m_info->decodeError(allDataReceived);
+      }
+      break;
   }
 
-  // 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.
-  if (m_sizeAvailable == Image::SizeUnavailable && !allDataReceived)
-    return;
-
-  if (m_info->isPlaceholder() && allDataReceived && m_image &&
-      !m_image->isNull()) {
-    if (m_sizeAvailable == Image::SizeAvailable) {
-      // TODO(sclittle): Show the original image if the response consists of the
-      // entire image, such as if the entire image response body is smaller than
-      // the requested range.
-      IntSize dimensions = m_image->size();
-
-      clearImage();
-      m_image = PlaceholderImage::create(this, dimensions);
-    } else {
-      // Clear the image so that it gets treated like a decoding error, since
-      // the attempt to build a placeholder image failed.
-      clearImage();
-    }
-  }
-
-  if (!m_image || m_image->isNull()) {
-    clearImage();
-    m_info->decodeError(allDataReceived);
-  }
-
+  // Notifies the observers.
   // It would be nice to only redraw the decoded band of the image, but with the
   // current design (decoding delayed until painting) that seems hard.
   notifyObservers(allDataReceived ? ShouldNotifyFinish : DoNotNotifyFinish);
 }
 
 void ImageResourceContent::decodedSizeChangedTo(const blink::Image* image,
                                                 size_t newSize) {
   if (!image || image != m_image)
     return;
 
@@ skipping 105 matching lines @@
 
 const ResourceResponse& ImageResourceContent::response() const {
   return m_info->response();
 }
 
 const ResourceError& ImageResourceContent::resourceError() const {
   return m_info->resourceError();
 }
 
 }  // namespace blink