Replace ASSERT*() with DCHECK*() in core/fetch/ and core/loader/

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 56 matching lines @@
     return sender;
 }
 
 static inline bool pageIsBeingDismissed(Document* document)
 {
     return document->pageDismissalEventBeingDispatched() != Document::NoDismissal;
 }
 
 static ImageLoader::BypassMainWorldBehavior shouldBypassMainWorldCSP(ImageLoader* loader)
 {
-    ASSERT(loader);
-    ASSERT(loader->element());
+    DCHECK(loader);
+    DCHECK(loader->element());
     if (loader->element()->document().frame() && loader->element()->document().frame()->script().shouldBypassMainWorldCSP())
         return ImageLoader::BypassMainWorldCSP;
     return ImageLoader::DoNotBypassMainWorldCSP;
 }
 
 class ImageLoader::Task {
 public:
     static std::unique_ptr<Task> create(ImageLoader* loader, UpdateFromElementBehavior updateBehavior, ReferrerPolicy referrerPolicy)
     {
         return wrapUnique(new Task(loader, updateBehavior, referrerPolicy));
     }
 
     Task(ImageLoader* loader, UpdateFromElementBehavior updateBehavior, ReferrerPolicy referrerPolicy)
         : m_loader(loader)
         , m_shouldBypassMainWorldCSP(shouldBypassMainWorldCSP(loader))
         , m_updateBehavior(updateBehavior)
         , m_weakFactory(this)
         , m_referrerPolicy(referrerPolicy)
     {
         ExecutionContext& context = m_loader->element()->document();
         InspectorInstrumentation::asyncTaskScheduled(&context, "Image", this);
         v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
         v8::HandleScope scope(isolate);
         // If we're invoked from C++ without a V8 context on the stack, we should
         // run the microtask in the context of the element's document's main world.
         if (ScriptState::hasCurrentScriptState(isolate)) {
             m_scriptState = ScriptState::current(isolate);
         } else {
             m_scriptState = ScriptState::forMainWorld(loader->element()->document().frame());
-            ASSERT(m_scriptState);
+            DCHECK(m_scriptState);
         }
         m_requestURL = loader->imageSourceToKURL(loader->element()->imageSourceURL());
     }
 
     void run()
     {
         if (!m_loader)
             return;
         ExecutionContext& context = m_loader->element()->document();
         InspectorInstrumentation::AsyncTask asyncTask(&context, this);
@@ skipping 66 matching lines @@
 {
     setImageWithoutConsideringPendingLoadEvent(newImage);
 
     // 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(ImageResource* newImage)
 {
-    ASSERT(m_failedLoadURL.isEmpty());
+    DCHECK(m_failedLoadURL.isEmpty());
     ImageResource* oldImage = m_image.get();
     if (newImage != oldImage) {
         m_image = newImage;
         if (m_hasPendingLoadEvent) {
             loadEventSender().cancelEvent(this);
             m_hasPendingLoadEvent = false;
         }
         if (m_hasPendingErrorEvent) {
             errorEventSender().cancelEvent(this);
             m_hasPendingErrorEvent = false;
@@ skipping 224 matching lines @@
             return true;
     }
     return (isHTMLObjectElement(m_element) || isHTMLEmbedElement(m_element) || url.protocolIsData());
 }
 
 void ImageLoader::imageNotifyFinished(ImageResource* resource)
 {
     RESOURCE_LOADING_DVLOG(1) << "ImageLoader::imageNotifyFinished " << this
         << "; m_hasPendingLoadEvent=" << m_hasPendingLoadEvent;
 
-    ASSERT(m_failedLoadURL.isEmpty());
-    ASSERT(resource == m_image.get());
+    DCHECK(m_failedLoadURL.isEmpty());
+    DCHECK(resource == m_image.get());

[yhirano, 2016/09/12 04:33:13]

DCHECK_EQ

[hiroshige, 2016/09/13 08:43:21]

Done.

 
     m_imageComplete = true;
 
     // Update ImageAnimationPolicy for m_image.
     if (m_image)
         m_image->updateImageAnimationPolicy();
 
     updateLayoutObject();
 
     if (m_image && m_image->getImage() && m_image->getImage()->isSVGImage())
@@ skipping 75 matching lines @@
     m_elementIsProtected = m_hasPendingLoadEvent || m_hasPendingErrorEvent;
     if (wasProtected == m_elementIsProtected)
         return;
 
     if (m_elementIsProtected) {
         if (m_derefElementTimer.isActive())
             m_derefElementTimer.stop();
         else
             m_keepAlive = m_element;
     } else {
-        ASSERT(!m_derefElementTimer.isActive());
+        DCHECK(!m_derefElementTimer.isActive());
         m_derefElementTimer.startOneShot(0, BLINK_FROM_HERE);
     }
 }
 
 void ImageLoader::timerFired(TimerBase*)
 {
     m_keepAlive.clear();
 }
 
 void ImageLoader::dispatchPendingEvent(ImageEventSender* eventSender)
 {
     RESOURCE_LOADING_DVLOG(1) << "ImageLoader::dispatchPendingEvent " << this;
-    ASSERT(eventSender == &loadEventSender() || eventSender == &errorEventSender());
+    DCHECK(eventSender == &loadEventSender() || eventSender == &errorEventSender());
     const AtomicString& eventType = eventSender->eventType();
     if (eventType == EventTypeNames::load)
         dispatchPendingLoadEvent();
     if (eventType == EventTypeNames::error)
         dispatchPendingErrorEvent();
 }
 
 void ImageLoader::dispatchPendingLoadEvent()
 {
     if (!m_hasPendingLoadEvent)
@@ skipping 44 matching lines @@
 
 void ImageLoader::elementDidMoveToNewDocument()
 {
     if (m_loadDelayCounter)
         m_loadDelayCounter->documentChanged(m_element->document());
     clearFailedLoadURL();
     setImage(0);
 }
 
 } // namespace blink