Replace ASSERT with DCHECK in modules/fetch.

third_party/WebKit/Source/modules/fetch/FetchManager.cpp

 // Copyright 2014 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 "modules/fetch/FetchManager.h"
 
 #include <memory>
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 174 matching lines @@
           m_updater(updater),
           m_response(response),
           m_loader(loader),
           m_integrityMetadata(integrityMetadata),
           m_url(url),
           m_finished(false) {
       m_reader = m_handle->obtainReader(this);
     }
 
     void didGetReadable() override {
-      ASSERT(m_reader);
-      ASSERT(m_loader);
-      ASSERT(m_response);
+      DCHECK(m_reader);
+      DCHECK(m_loader);
+      DCHECK(m_response);
 
       WebDataConsumerHandle::Result r = WebDataConsumerHandle::Ok;
       while (r == WebDataConsumerHandle::Ok) {
         const void* buffer;
         size_t size;
         r = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone,
                                 &size);
         if (r == WebDataConsumerHandle::Ok) {
           m_buffer.append(static_cast<const char*>(buffer), size);
           m_reader->endRead(size);
@@ skipping 93 matching lines @@
       m_finished(false),
       m_responseHttpStatusCode(0),
       m_integrityVerifier(nullptr),
       m_didFinishLoading(false),
       m_isIsolatedWorld(isIsolatedWorld),
       m_executionContext(executionContext) {
   m_urlList.push_back(request->url());
 }
 
 FetchManager::Loader::~Loader() {
-  ASSERT(!m_loader);
+  DCHECK(!m_loader);
 }
 
 DEFINE_TRACE(FetchManager::Loader) {
   visitor->trace(m_fetchManager);
   visitor->trace(m_resolver);
   visitor->trace(m_request);
   visitor->trace(m_loader);
   visitor->trace(m_integrityVerifier);
   visitor->trace(m_executionContext);
 }
 
 void FetchManager::Loader::didReceiveRedirectTo(const KURL& url) {
   m_urlList.push_back(url);
 }
 
 void FetchManager::Loader::didReceiveResponse(
     unsigned long,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
-  ASSERT(handle);
+  DCHECK(handle);
   // TODO(horo): This check could be false when we will use the response url
   // in service worker responses. (crbug.com/553535)
   DCHECK(response.url() == m_urlList.back());
   ScriptState* scriptState = m_resolver->getScriptState();
   ScriptState::Scope scope(scriptState);
 
   if (response.url().protocolIs("blob") && response.httpStatusCode() == 404) {
     // "If |blob| is null, return a network error."
     // https://fetch.spec.whatwg.org/#concept-basic-fetch
     performNetworkError("Blob not found.");
@@ skipping 112 matching lines @@
     if (locations.size() > 1) {
       performNetworkError("Multiple Location header.");
       return;
     }
     if (locations.size() == 1) {
       KURL locationURL(m_request->url(), locations[0]);
       if (!locationURL.isValid()) {
         performNetworkError("Invalid Location header.");
         return;
       }
-      ASSERT(m_request->redirect() == WebURLRequest::FetchRedirectModeManual);
+      DCHECK(m_request->redirect() == WebURLRequest::FetchRedirectModeManual);

[tkent, 2017/04/08 02:29:54]

Use DCHECK_EQ if it doesn't cause a build failure.

       taintedResponse = responseData->createOpaqueRedirectFilteredResponse();
     }
     // When the location header doesn't exist, we don't treat the response
     // as a redirect response, and execute tainting.
   }
   if (!taintedResponse) {
     switch (tainting) {
       case FetchRequestData::BasicTainting:
         taintedResponse = responseData->createBasicFilteredResponse();
         break;
@@ skipping 20 matching lines @@
     //  whose name is `Content-Type` and value is the MIME type and
     //  parameters returned from obtaining a resource"
     r->headers()->headerList()->remove(HTTPNames::Access_Control_Allow_Origin);
   }
   r->headers()->setGuard(Headers::ImmutableGuard);
 
   if (m_request->integrity().isEmpty()) {
     m_resolver->resolve(r);
     m_resolver.clear();
   } else {
-    ASSERT(!m_integrityVerifier);
+    DCHECK(!m_integrityVerifier);
     m_integrityVerifier =
         new SRIVerifier(std::move(handle), sriConsumer, r, this,
                         m_request->integrity(), response.url());
   }
 }
 
 void FetchManager::Loader::didFinishLoading(unsigned long, double) {
   m_didFinishLoading = true;
   // If there is an integrity verifier, and it has not already finished, it
   // will take care of finishing the load or performing a network error when
@@ skipping 29 matching lines @@
 }
 
 Document* FetchManager::Loader::document() const {
   if (m_executionContext->isDocument()) {
     return toDocument(m_executionContext);
   }
   return nullptr;
 }
 
 void FetchManager::Loader::loadSucceeded() {
-  ASSERT(!m_failed);
+  DCHECK(!m_failed);
 
   m_finished = true;
 
   if (document() && document()->frame() && document()->frame()->page() &&
       FetchUtils::isOkStatus(m_responseHttpStatusCode)) {
     document()->frame()->page()->chromeClient().ajaxSucceeded(
         document()->frame());
   }
   probe::didFinishFetch(m_executionContext, this, m_request->method(),
                         m_request->url().getString());
@@ skipping 137 matching lines @@
                         m_request->url().protocol() + "\" is not supported.");
   }
 }
 
 void FetchManager::Loader::performNetworkError(const String& message) {
   failed(message);
 }
 
 void FetchManager::Loader::performHTTPFetch(bool corsFlag,
                                             bool corsPreflightFlag) {
-  ASSERT(
+  DCHECK(
       SchemeRegistry::shouldTreatURLSchemeAsSupportingFetchAPI(
           m_request->url().protocol()) ||
       (m_request->url().protocolIs("blob") && !corsFlag && !corsPreflightFlag));
   // CORS preflight fetch procedure is implemented inside
   // DocumentThreadableLoader.
 
   // "1. Let |HTTPRequest| be a copy of |request|, except that |HTTPRequest|'s
   //  body is a tee of |request|'s body."
   // We use ResourceRequest class for HTTPRequest.
   // FIXME: Support body.
@@ skipping 118 matching lines @@
       ThreadableLoader::create(*m_executionContext, this,
                                threadableLoaderOptions, resourceLoaderOptions);
   m_loader->start(request);
 }
 
 // performDataFetch() is almost the same as performHTTPFetch(), except for:
 // - We set AllowCrossOriginRequests to allow requests to data: URLs in
 //   'same-origin' mode.
 // - We reject non-GET method.
 void FetchManager::Loader::performDataFetch() {
-  ASSERT(m_request->url().protocolIsData());
+  DCHECK(m_request->url().protocolIsData());
 
   ResourceRequest request(m_request->url());
   request.setRequestContext(m_request->context());
   request.setUseStreamOnResponse(true);
   request.setHTTPMethod(m_request->method());
   request.setFetchRedirectMode(WebURLRequest::FetchRedirectModeError);
   // We intentionally skip 'setExternalRequestStateFromRequestorAddressSpace',
   // as 'data:' can never be external.
 
   ResourceLoaderOptions resourceLoaderOptions;
@@ skipping 69 matching lines @@
   m_loaders.erase(loader);
   loader->dispose();
 }
 
 DEFINE_TRACE(FetchManager) {
   visitor->trace(m_loaders);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink