ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/PendingScript.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 62 matching lines @@
     m_element = other.m_element;
     m_startingPosition = other.m_startingPosition;
     m_integrityFailure = other.m_integrityFailure;
     m_streamer = other.m_streamer;
     this->ResourceOwner<ScriptResource, ScriptResourceClient>::operator=(other);
     return *this;
 }
 
 void PendingScript::watchForLoad(ScriptResourceClient* client)
 {
-    ASSERT(!m_watchingForLoad);
+    DCHECK(!m_watchingForLoad);
     // addClient() will call streamingFinished() if the load is complete. Callers
     // who do not expect to be re-entered from this call should not call
     // watchForLoad for a PendingScript which isReady. We also need to set
     // m_watchingForLoad early, since addClient() can result in calling
     // notifyFinished and further stopWatchingForLoad().
     m_watchingForLoad = true;
     m_client = client;
     if (!m_streamer)
         resource()->addClient(client);
 }
 
 void PendingScript::stopWatchingForLoad()
 {
     if (!m_watchingForLoad)
         return;
-    ASSERT(resource());
+    DCHECK(resource());
     if (!m_streamer)
         resource()->removeClient(m_client);
     m_client = nullptr;
     m_watchingForLoad = false;
 }
 
 void PendingScript::streamingFinished()
 {
-    ASSERT(resource());
+    DCHECK(resource());
     if (m_client)
         m_client->notifyFinished(resource());
 }
 
 void PendingScript::setElement(Element* element)
 {
     m_element = element;
 }
 
 RawPtr<Element> PendingScript::releaseElementAndClear()
 {
     setScriptResource(0);
     m_watchingForLoad = false;
     m_startingPosition = TextPosition::belowRangePosition();
     m_integrityFailure = false;
     m_parserBlockingLoadStartTime = 0;
     if (m_streamer)
         m_streamer->cancel();
     m_streamer.release();
     return m_element.release();
 }
 
 void PendingScript::setScriptResource(ScriptResource* resource)
 {
     setResource(resource);
 }
 
 void PendingScript::markParserBlockingLoadStartTime()
 {
-    ASSERT(m_parserBlockingLoadStartTime == 0.0);
+    DCHECK_EQ(m_parserBlockingLoadStartTime, 0.0);
     m_parserBlockingLoadStartTime = monotonicallyIncreasingTime();
 }
 
 void PendingScript::notifyFinished(Resource* resource)
 {
     // The following SRI checks need to be here because, unfortunately, fetches
     // are not done purely according to the Fetch spec. In particular,
     // different requests for the same resource do not have different
     // responses; the memory cache can (and will) return the exact same
     // Resource object.
     //
     // For different requests, the same Resource object will be returned and
     // will not be associated with the particular request.  Therefore, when the
     // body of the response comes in, there's no way to validate the integrity
     // of the Resource object against a particular request (since there may be
     // several pending requests all tied to the identical object, and the
     // actual requests are not stored).
     //
     // In order to simulate the correct behavior, Blink explicitly does the SRI
     // checks here, when a PendingScript tied to a particular request is
     // finished (and in the case of a StyleSheet, at the point of execution),
     // while having proper Fetch checks in the fetch module for use in the
     // fetch JavaScript API. In a future world where the ResourceFetcher uses
     // the Fetch algorithm, this should be fixed by having separate Response
     // objects (perhaps attached to identical Resource objects) per request.
     //
     // See https://crbug.com/500701 for more information.
     if (m_element) {
-        ASSERT(resource->getType() == Resource::Script);
+        DCHECK_EQ(resource->getType(), Resource::Script);
         ScriptResource* scriptResource = toScriptResource(resource);
         String integrityAttr = m_element->fastGetAttribute(HTMLNames::integrityAttr);
 
         // It is possible to get back a script resource with integrity metadata
         // for a request with an empty integrity attribute. In that case, the
         // integrity check should be skipped, so this check ensures that the
         // integrity attribute isn't empty in addition to checking if the
         // resource has empty integrity metadata.
         if (!integrityAttr.isEmpty() && !scriptResource->integrityMetadata().isEmpty()) {
             ScriptIntegrityDisposition disposition = scriptResource->integrityDisposition();
@@ skipping 23 matching lines @@
 {
     visitor->trace(m_element);
     visitor->trace(m_streamer);
     ResourceOwner<ScriptResource>::trace(visitor);
 }
 
 ScriptSourceCode PendingScript::getSource(const KURL& documentURL, bool& errorOccurred) const
 {
     if (resource()) {
         errorOccurred = resource()->errorOccurred() || m_integrityFailure;
-        ASSERT(resource()->isLoaded());
+        DCHECK(resource()->isLoaded());
         if (m_streamer && !m_streamer->streamingSuppressed())
             return ScriptSourceCode(m_streamer, resource());
         return ScriptSourceCode(resource());
     }
     errorOccurred = false;
     return ScriptSourceCode(m_element->textContent(), documentURL, startingPosition());
 }
 
 void PendingScript::setStreamer(RawPtr<ScriptStreamer> streamer)
 {
-    ASSERT(!m_streamer);
-    ASSERT(!m_watchingForLoad);
+    DCHECK(!m_streamer);
+    DCHECK(!m_watchingForLoad);
     m_streamer = streamer;
 }
 
 bool PendingScript::isReady() const
 {
     if (resource() && !resource()->isLoaded())
         return false;
     if (m_streamer && !m_streamer->isFinished())
         return false;
     return true;
 }
 
 bool PendingScript::errorOccurred() const
 {
     if (resource())
         return resource()->errorOccurred();
     if (m_streamer && m_streamer->resource())
         return m_streamer->resource()->errorOccurred();
     return false;
 }
 
 } // namespace blink