Phase III Step 1: Make ImageResourceContent manage its own ResourceStatus

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 21 matching lines @@
   NullImageResourceInfo() {}
 
   DEFINE_INLINE_VIRTUAL_TRACE() { ImageResourceInfo::Trace(visitor); }
 
  private:
   const KURL& Url() const override { return url_; }
   bool IsSchedulingReload() const override { return false; }
   bool HasDevicePixelRatioHeaderValue() const override { return false; }
   float DevicePixelRatioHeaderValue() const override { return 1.0; }
   const ResourceResponse& GetResponse() const override { return response_; }
-  ResourceStatus GetStatus() const override { return ResourceStatus::kCached; }
   bool ShouldShowPlaceholder() const override { return false; }
   bool IsCacheValidator() const override { return false; }
   bool SchedulingReloadOrShouldReloadBrokenPlaceholder() const override {
     return false;
   }
   bool IsAccessAllowed(
       SecurityOrigin*,
       DoesCurrentFrameHaveSingleSecurityOrigin) const override {
     return true;
   }
@@ skipping 265 matching lines @@
   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.
   image_->ClearImageObserver();
   image_.Clear();
   size_available_ = Image::kSizeUnavailable;
 }
 
+// |new_status| is the status of corresponding ImageResource.
+void ImageResourceContent::UpdateToLoadedContentStatus(
+    ResourceStatus new_status) {
+  // When |ShouldNotifyFinish|, we set content_status_
+  // to a loaded ResourceStatus.
+
+  // Checks |new_status| (i.e. Resource's current status).
+  switch (new_status) {
+    case ResourceStatus::kCached:
+    case ResourceStatus::kPending:
+      // In case of successful load, Resource's status can be
+      // kCached (e.g. for second part of multipart image) or
+      // still Pending (e.g. for a non-multipart image).
+      // Therefore we use kCached as the new state here.
+      new_status = ResourceStatus::kCached;
+      break;
+
+    case ResourceStatus::kLoadError:
+    case ResourceStatus::kDecodeError:
+      // In case of error, Resource's status is set to an error status
+      // before UpdateImage() and thus we use the error status as-is.
+      break;
+
+    case ResourceStatus::kNotStarted:
+      CHECK(false);
+      break;
+  }
+
+  // Checks ImageResourceContent's previous status.
+  switch (GetContentStatus()) {
+    case ResourceStatus::kPending:
+      // A non-multipart image or the first part of a multipart image.
+      break;
+
+    case ResourceStatus::kCached:
+      // Second (or later) part of a multipart image.
+      break;
+
+    case ResourceStatus::kNotStarted:
+      // Should have updated to kPending via NotifyStartLoad().
+      CHECK(false);
+      break;
+
+    case ResourceStatus::kLoadError:
+    case ResourceStatus::kDecodeError:
+      CHECK(false);
+      break;
+  }
+
+  // Updates the status.
+  content_status_ = new_status;
+}
+
+void ImageResourceContent::NotifyStartLoad() {
+  // Checks ImageResourceContent's previous status.
+  switch (GetContentStatus()) {
+    case ResourceStatus::kPending:
+      CHECK(false);
+      break;
+
+    case ResourceStatus::kNotStarted:
+      // Normal load start.
+      break;
+
+    case ResourceStatus::kCached:
+    case ResourceStatus::kLoadError:
+    case ResourceStatus::kDecodeError:
+      // Load start due to revalidation/reload.
+      break;
+  }
+
+  content_status_ = ResourceStatus::kPending;
+}
+
 ImageResourceContent::UpdateImageResult ImageResourceContent::UpdateImage(
     PassRefPtr<SharedBuffer> data,
+    ResourceStatus status,
     UpdateImageOption update_image_option,
     bool all_data_received) {
   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|.
   switch (update_image_option) {
     case kClearAndUpdateImage:
     case kClearImageAndNotifyObservers:
       ClearImage();
       break;
     case kUpdateImage:
       break;
   }
 
@@ skipping 32 matching lines @@
       if (!image_ || image_->IsNull()) {
         ClearImage();
         return UpdateImageResult::kShouldDecodeError;
       }
       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(all_data_received ? kShouldNotifyFinish : kDoNotNotifyFinish);
+
+  if (all_data_received) {
+    UpdateToLoadedContentStatus(status);
+    NotifyObservers(kShouldNotifyFinish);
+  } else {
+    NotifyObservers(kDoNotNotifyFinish);
+  }
+
   return UpdateImageResult::kNoDecodeError;
 }
 
 void ImageResourceContent::DecodedSizeChangedTo(const blink::Image* image,
                                                 size_t new_size) {
   if (!image || image != image_)
     return;
 
   info_->SetDecodedSize(new_size);
 }
@@ skipping 61 matching lines @@
                            : ImageResourceInfo::kHasMultipleSecurityOrigin);
 }
 
 void ImageResourceContent::EmulateLoadStartedForInspector(
     ResourceFetcher* fetcher,
     const KURL& url,
     const AtomicString& initiator_name) {
   info_->EmulateLoadStartedForInspector(fetcher, url, initiator_name);
 }
 
+bool ImageResourceContent::IsLoaded() const {
+  return GetContentStatus() > ResourceStatus::kPending;
+}
+
+bool ImageResourceContent::IsLoading() const {
+  return GetContentStatus() == ResourceStatus::kPending;
+}
+
+bool ImageResourceContent::ErrorOccurred() const {
+  return GetContentStatus() == ResourceStatus::kLoadError ||
+         GetContentStatus() == ResourceStatus::kDecodeError;
+}
+
+bool ImageResourceContent::LoadFailedOrCanceled() const {
+  return GetContentStatus() == ResourceStatus::kLoadError;
+}
+
+ResourceStatus ImageResourceContent::GetContentStatus() const {
+  return content_status_;
+}
+
 // TODO(hiroshige): Consider removing the following methods, or stoping
 // redirecting to ImageResource.
-bool ImageResourceContent::IsLoaded() const {
-  return GetStatus() > ResourceStatus::kPending;
-}
-
-bool ImageResourceContent::IsLoading() const {
-  return GetStatus() == ResourceStatus::kPending;
-}
-
-bool ImageResourceContent::ErrorOccurred() const {
-  return GetStatus() == ResourceStatus::kLoadError ||
-         GetStatus() == ResourceStatus::kDecodeError;
-}
-
-bool ImageResourceContent::LoadFailedOrCanceled() const {
-  return GetStatus() == ResourceStatus::kLoadError;
-}
-
-ResourceStatus ImageResourceContent::GetStatus() const {
-  return info_->GetStatus();
-}
-
 const KURL& ImageResourceContent::Url() const {
   return info_->Url();
 }
 
 bool ImageResourceContent::HasCacheControlNoStoreHeader() const {
   return info_->HasCacheControlNoStoreHeader();
 }
 
 float ImageResourceContent::DevicePixelRatioHeaderValue() const {
   return info_->DevicePixelRatioHeaderValue();
 }
 
 bool ImageResourceContent::HasDevicePixelRatioHeaderValue() const {
   return info_->HasDevicePixelRatioHeaderValue();
 }
 
 const ResourceResponse& ImageResourceContent::GetResponse() const {
   return info_->GetResponse();
 }
 
 const ResourceError& ImageResourceContent::GetResourceError() const {
   return info_->GetResourceError();
 }
 
 }  // namespace blink