Split ImageLoader::SetImage() and set flags consistently in tests

third_party/WebKit/Source/core/loader/ImageLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 168 matching lines @@
     image_ = nullptr;
   }
 }
 
 DEFINE_TRACE(ImageLoader) {
   visitor->Trace(image_);
   visitor->Trace(image_resource_for_image_document_);
   visitor->Trace(element_);
 }
 
-void ImageLoader::SetImage(ImageResourceContent* new_image) {
+void ImageLoader::SetImageForTest(ImageResourceContent* new_image) {
+  DCHECK(new_image);
   SetImageWithoutConsideringPendingLoadEvent(new_image);
 
   // Only consider updating the protection ref-count of the Element immediately
   // before returning from this function as doing so might result in the
   // destruction of this ImageLoader.
   UpdatedHasPendingEvent();
 }
 
+void ImageLoader::ClearImage() {
+  SetImageWithoutConsideringPendingLoadEvent(nullptr);
+
+  // Only consider updating the protection ref-count of the Element immediately
+  // before returning from this function as doing so might result in the
+  // destruction of this ImageLoader.
+  UpdatedHasPendingEvent();
+}
+
+void ImageLoader::SetImageForImageDocument(ImageResource* new_image_resource) {
+  DCHECK(loading_image_document_);
+  DCHECK(new_image_resource);
+  DCHECK(new_image_resource->GetContent());
+
+  image_resource_for_image_document_ = new_image_resource;
+  SetImageWithoutConsideringPendingLoadEvent(new_image_resource->GetContent());
+
+  // |has_pending_load_event_| is always false and |image_complete_| is
+  // always true for ImageDocument loading, while the loading is just started.
+  // TODO(hiroshige): clean up the behavior of flags. https://crbug.com/719759
+  has_pending_load_event_ = false;
+  image_complete_ = true;
+
+  // Only consider updating the protection ref-count of the Element immediately
+  // before returning from this function as doing so might result in the
+  // destruction of this ImageLoader.
+  UpdatedHasPendingEvent();
+}
+
 void ImageLoader::SetImageWithoutConsideringPendingLoadEvent(
     ImageResourceContent* new_image) {
   DCHECK(failed_load_url_.IsEmpty());
   ImageResourceContent* old_image = image_.Get();
   if (new_image != old_image) {
-    image_ = new_image;
     if (has_pending_load_event_) {
       LoadEventSender().CancelEvent(this);
       has_pending_load_event_ = false;
     }
     if (has_pending_error_event_) {
       ErrorEventSender().CancelEvent(this);
       has_pending_error_event_ = false;
     }
-    image_complete_ = true;
+    UpdateImageState(new_image);
     if (new_image) {
       new_image->AddObserver(this);
     }
     if (old_image) {
       old_image->RemoveObserver(this);
     }
   }
 
   if (LayoutImageResource* image_resource = GetLayoutImageResource())
     image_resource->ResetAnimation();
@@ skipping 38 matching lines @@
     ReferrerPolicy referrer_policy) {
   std::unique_ptr<Task> task =
       Task::Create(this, update_behavior, referrer_policy);
   pending_task_ = task->CreateWeakPtr();
   Microtask::EnqueueMicrotask(
       WTF::Bind(&Task::Run, WTF::Passed(std::move(task))));
   load_delay_counter_ =
       IncrementLoadEventDelayCount::Create(element_->GetDocument());
 }
 
+void ImageLoader::UpdateImageState(ImageResourceContent* new_image) {
+  image_ = new_image;
+  has_pending_load_event_ = new_image;
+  image_complete_ = !new_image;
+}
+
 void ImageLoader::DoUpdateFromElement(BypassMainWorldBehavior bypass_behavior,
                                       UpdateFromElementBehavior update_behavior,
                                       const KURL& url,
                                       ReferrerPolicy referrer_policy) {
   // FIXME: According to
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/embedded-content.html#the-img-element:the-img-element-55
   // When "update image" is called due to environment changes and the load
   // fails, onerror should not be called. That is currently not the case.
   //
   // We don't need to call clearLoader here: Either we were called from the
@@ skipping 68 matching lines @@
     // cancelled by changing the src attribute. If newImage is null and
     // has_pending_error_event_ is true, we know the error event has been just
     // posted by this load and we should not cancel the event.
     // FIXME: If both previous load and this one got blocked with an error, we
     // can receive one error event instead of two.
     if (has_pending_error_event_ && new_image) {
       ErrorEventSender().CancelEvent(this);
       has_pending_error_event_ = false;
     }
 
-    image_ = new_image;
-    has_pending_load_event_ = new_image;
-    image_complete_ = !new_image;
+    UpdateImageState(new_image);
 
     UpdateLayoutObject();
     // If newImage exists and is cached, addObserver() will result in the load
     // event being queued to fire. Ensure this happens after beforeload is
     // dispatched.
     if (new_image) {
       new_image->AddObserver(this);
     }
     if (old_image) {
       old_image->RemoveObserver(this);
@@ skipping 23 matching lines @@
   // Prevent the creation of a ResourceLoader (and therefore a network request)
   // for ImageDocument loads. In this case, the image contents have already been
   // requested as a main resource and ImageDocumentParser will take care of
   // funneling the main resource bytes into image_, so just create an
   // ImageResource to be populated later.
   if (loading_image_document_ && update_behavior != kUpdateForcedReload) {
     ImageResource* image_resource = ImageResource::Create(
         ResourceRequest(ImageSourceToKURL(element_->ImageSourceURL())));
     image_resource->SetStatus(ResourceStatus::kPending);
     image_resource->NotifyStartLoad();
-    image_resource_for_image_document_ = image_resource;
-    SetImage(image_resource->GetContent());
+    SetImageForImageDocument(image_resource);
     return;
   }
 
   // If we have a pending task, we have to clear it -- either we're now loading
   // immediately, or we need to reset the task's state.
   if (pending_task_) {
     pending_task_->ClearLoader();
     pending_task_.reset();
   }
 
@@ skipping 215 matching lines @@
 }
 
 void ImageLoader::DispatchPendingErrorEvents() {
   ErrorEventSender().DispatchPendingEvents();
 }
 
 void ImageLoader::ElementDidMoveToNewDocument() {
   if (load_delay_counter_)
     load_delay_counter_->DocumentChanged(element_->GetDocument());
   ClearFailedLoadURL();
-  SetImage(0);
+  ClearImage();
 }
 
 }  // namespace blink