Phase II Step 1: Remove updateImage() reentrancy around decodeError()

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 34 matching lines @@
     return false;
   }
   bool isAccessAllowed(
       SecurityOrigin*,
       DoesCurrentFrameHaveSingleSecurityOrigin) const override {
     return true;
   }
   bool hasCacheControlNoStoreHeader() const override { return false; }
   const ResourceError& resourceError() const override { return m_error; }
 
-  void decodeError(bool allDataReceived) override {}
   void setDecodedSize(size_t) override {}
   void setIsPlaceholder(bool) override {}
   void willAddClientOrObserver() override {}
   void didRemoveClientOrObserver() override {}
   void emulateLoadStartedForInspector(
       ResourceFetcher*,
       const KURL&,
       const AtomicString& initiatorName) override {}
 
   const KURL m_url;
@@ skipping 256 matching lines @@
     return true;
 
   // Don't treat a complete and broken image as a placeholder if the response
   // code is something other than a 4xx or 5xx error. This is done to prevent
   // reissuing the request in cases like "204 No Content" responses to tracking
   // requests triggered by <img> tags, and <img> tags used to preload non-image
   // resources.
   return response.httpStatusCode() < 400 || response.httpStatusCode() >= 600;
 }
 
-void ImageResourceContent::updateImage(PassRefPtr<SharedBuffer> data,
-                                       UpdateImageOption updateImageOption,
-                                       bool allDataReceived) {
+ImageResourceContent::UpdateImageResult ImageResourceContent::updateImage(
+    PassRefPtr<SharedBuffer> data,
+    UpdateImageOption updateImageOption,
+    bool allDataReceived) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
+#if DCHECK_IS_ON()
+  DCHECK(!m_isUpdateImageBeingCalled);
+  AutoReset<bool> scope(&m_isUpdateImageBeingCalled, true);
+#endif
+
   // Clears the existing image, if instructed by |updateImageOption|.
   switch (updateImageOption) {
     case ClearAndUpdateImage:
     case ClearImageAndNotifyObservers:
       clearImage();
       break;
     case UpdateImage:
       break;
   }
 
@@ skipping 12 matching lines @@
         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;
+        return UpdateImageResult::NoDecodeError;
 
       if (m_info->isPlaceholder() && allDataReceived) {
         if (shouldShowFullImageInsteadOfPlaceholder(response(),
                                                     m_image.get())) {
           m_info->setIsPlaceholder(false);
         } else if (m_image && !m_image->isNull()) {
           IntSize dimensions = m_image->size();
           clearImage();
           m_image = PlaceholderImage::create(this, dimensions);
         }
       }
 
       if (!m_image || m_image->isNull()) {
         clearImage();
-        m_info->decodeError(allDataReceived);
+        return UpdateImageResult::ShouldDecodeError;
       }
       break;
   }
 
   // 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);
+  return UpdateImageResult::NoDecodeError;
 }
 
 void ImageResourceContent::decodedSizeChangedTo(const blink::Image* image,
                                                 size_t newSize) {
   if (!image || image != m_image)
     return;
 
   m_info->setDecodedSize(newSize);
 }
 
@@ skipping 102 matching lines @@
 
 const ResourceResponse& ImageResourceContent::response() const {
   return m_info->response();
 }
 
 const ResourceError& ImageResourceContent::resourceError() const {
   return m_info->resourceError();
 }
 
 }  // namespace blink