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 175 matching lines @@
           updater_(updater),
           response_(response),
           loader_(loader),
           integrity_metadata_(integrity_metadata),
           url_(url),
           finished_(false) {
       reader_ = handle_->ObtainReader(this);
     }
 
     void DidGetReadable() override {
-      ASSERT(reader_);
-      ASSERT(loader_);
-      ASSERT(response_);
+      DCHECK(reader_);
+      DCHECK(loader_);
+      DCHECK(response_);
 
       WebDataConsumerHandle::Result r = WebDataConsumerHandle::kOk;
       while (r == WebDataConsumerHandle::kOk) {
         const void* buffer;
         size_t size;
         r = reader_->BeginRead(&buffer, WebDataConsumerHandle::kFlagNone,
                                &size);
         if (r == WebDataConsumerHandle::kOk) {
           buffer_.Append(static_cast<const char*>(buffer), size);
           reader_->EndRead(size);
@@ skipping 93 matching lines @@
       finished_(false),
       response_http_status_code_(0),
       integrity_verifier_(nullptr),
       did_finish_loading_(false),
       is_isolated_world_(is_isolated_world),
       execution_context_(execution_context) {
   url_list_.push_back(request->Url());
 }
 
 FetchManager::Loader::~Loader() {
-  ASSERT(!loader_);
+  DCHECK(!loader_);
 }
 
 DEFINE_TRACE(FetchManager::Loader) {
   visitor->Trace(fetch_manager_);
   visitor->Trace(resolver_);
   visitor->Trace(request_);
   visitor->Trace(loader_);
   visitor->Trace(integrity_verifier_);
   visitor->Trace(execution_context_);
 }
 
 void FetchManager::Loader::DidReceiveRedirectTo(const KURL& url) {
   url_list_.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() == url_list_.back());
   ScriptState* script_state = resolver_->GetScriptState();
   ScriptState::Scope scope(script_state);
 
   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 143 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::kImmutableGuard);
 
   if (request_->Integrity().IsEmpty()) {
     resolver_->Resolve(r);
     resolver_.Clear();
   } else {
-    ASSERT(!integrity_verifier_);
+    DCHECK(!integrity_verifier_);
     integrity_verifier_ =
         new SRIVerifier(std::move(handle), sri_consumer, r, this,
                         request_->Integrity(), response.Url());
   }
 }
 
 void FetchManager::Loader::DidFinishLoading(unsigned long, double) {
   did_finish_loading_ = 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::GetDocument() const {
   if (execution_context_->IsDocument()) {
     return ToDocument(execution_context_);
   }
   return nullptr;
 }
 
 void FetchManager::Loader::LoadSucceeded() {
-  ASSERT(!failed_);
+  DCHECK(!failed_);
 
   finished_ = true;
 
   if (GetDocument() && GetDocument()->GetFrame() &&
       GetDocument()->GetFrame()->GetPage() &&
       FetchUtils::IsOkStatus(response_http_status_code_)) {
     GetDocument()->GetFrame()->GetPage()->GetChromeClient().AjaxSucceeded(
         GetDocument()->GetFrame());
   }
   probe::didFinishFetch(execution_context_, this, request_->Method(),
@@ skipping 136 matching lines @@
                         "\" is not supported.");
   }
 }
 
 void FetchManager::Loader::PerformNetworkError(const String& message) {
   Failed(message);
 }
 
 void FetchManager::Loader::PerformHTTPFetch(bool cors_flag,
                                             bool cors_preflight_flag) {
-  ASSERT(SchemeRegistry::ShouldTreatURLSchemeAsSupportingFetchAPI(
+  DCHECK(SchemeRegistry::ShouldTreatURLSchemeAsSupportingFetchAPI(
              request_->Url().Protocol()) ||
          (request_->Url().ProtocolIs("blob") && !cors_flag &&
           !cors_preflight_flag));
   // 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 @@
                                      threadable_loader_options,
                                      resource_loader_options);
   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(request_->Url().ProtocolIsData());
+  DCHECK(request_->Url().ProtocolIsData());
 
   ResourceRequest request(request_->Url());
   request.SetRequestContext(request_->Context());
   request.SetUseStreamOnResponse(true);
   request.SetHTTPMethod(request_->Method());
   request.SetFetchRedirectMode(WebURLRequest::kFetchRedirectModeError);
   // We intentionally skip 'setExternalRequestStateFromRequestorAddressSpace',
   // as 'data:' can never be external.
 
   ResourceLoaderOptions resource_loader_options;
@@ skipping 70 matching lines @@
   loaders_.erase(loader);
   loader->Dispose();
 }
 
 DEFINE_TRACE(FetchManager) {
   visitor->Trace(loaders_);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink