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

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

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 135 matching lines @@
     , m_isUsingDataConsumerHandle(false)
     , m_async(blockingBehavior == LoadAsynchronously)
     , m_requestContext(WebURLRequest::RequestContextUnspecified)
     , m_timeoutTimer(this, &DocumentThreadableLoader::didTimeout)
     , m_requestStartedSeconds(0.0)
     , m_corsRedirectLimit(m_options.crossOriginRequestPolicy == UseAccessControl ? kMaxCORSRedirects : 0)
     , m_redirectMode(WebURLRequest::FetchRedirectModeFollow)
     , m_didRedirect(false)
     , m_weakFactory(this)
 {
-    ASSERT(client);
+    DCHECK(client);
 }
 
 void DocumentThreadableLoader::start(const ResourceRequest& request)
 {
     // Setting an outgoing referer is only supported in the async code path.
-    ASSERT(m_async || request.httpReferrer().isEmpty());
+    DCHECK(m_async || request.httpReferrer().isEmpty());
 
     m_sameOriginRequest = getSecurityOrigin()->canRequestNoSuborigin(request.url());
     m_requestContext = request.requestContext();
     m_redirectMode = request.fetchRedirectMode();
 
     if (!m_sameOriginRequest && m_options.crossOriginRequestPolicy == DenyCrossOriginRequests) {
         InspectorInstrumentation::documentThreadableLoaderFailedToStartLoadingForClient(m_document, m_client);
         ThreadableLoaderClient* client = m_client;
         clear();
         client->didFail(ResourceError(errorDomainBlinkInternal, 0, request.url().getString(), "Cross origin requests are not supported."));
@@ skipping 83 matching lines @@
     dispatchInitialRequest(newRequest);
 }
 
 void DocumentThreadableLoader::dispatchInitialRequest(const ResourceRequest& request)
 {
     if (!request.isExternalRequest() && (m_sameOriginRequest || m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)) {
         loadRequest(request, m_resourceLoaderOptions);
         return;
     }
 
-    ASSERT(m_options.crossOriginRequestPolicy == UseAccessControl || request.isExternalRequest());
+    DCHECK(m_options.crossOriginRequestPolicy == UseAccessControl || request.isExternalRequest());
 
     makeCrossOriginAccessRequest(request);
 }
 
 void DocumentThreadableLoader::makeCrossOriginAccessRequest(const ResourceRequest& request)
 {
-    ASSERT(m_options.crossOriginRequestPolicy == UseAccessControl || request.isExternalRequest());
-    ASSERT(m_client);
-    ASSERT(!resource());
+    DCHECK(m_options.crossOriginRequestPolicy == UseAccessControl || request.isExternalRequest());
+    DCHECK(m_client);
+    DCHECK(!resource());
 
     // Cross-origin requests are only allowed certain registered schemes.
     // We would catch this when checking response headers later, but there
     // is no reason to send a request, preflighted or not, that's guaranteed
     // to be denied.
     if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(request.url().protocol())) {
         InspectorInstrumentation::documentThreadableLoaderFailedToStartLoadingForClient(m_document, m_client);
         ThreadableLoaderClient* client = m_client;
         clear();
         client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, request.url().getString(), "Cross origin requests are only supported for protocol schemes: " + SchemeRegistry::listOfCORSEnabledURLSchemes() + "."));
@@ skipping 53 matching lines @@
 }
 
 DocumentThreadableLoader::~DocumentThreadableLoader()
 {
     CHECK(!m_client);
     DCHECK(!m_resource);
 }
 
 void DocumentThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
 {
-    ASSERT(m_async);
+    DCHECK(m_async);
 
     // |m_requestStartedSeconds| == 0.0 indicates loading is already finished
     // and |m_timeoutTimer| is already stopped, and thus we do nothing for such
     // cases. See https://crbug.com/551663 for details.
     if (m_requestStartedSeconds <= 0.0)
         return;
 
     m_timeoutTimer.stop();
     // At the time of this method's implementation, it is only ever called by
     // XMLHttpRequest, when the timeout attribute is set after sending the
@@ skipping 50 matching lines @@
 }
 
 // In this method, we can clear |request| to tell content::WebURLLoaderImpl of
 // Chromium not to follow the redirect. This works only when this method is
 // called by RawResource::willSendRequest(). If called by
 // RawResource::didAddClient(), clearing |request| won't be propagated
 // to content::WebURLLoaderImpl. So, this loader must also get detached from
 // the resource by calling clearResource().
 void DocumentThreadableLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
 {
-    ASSERT(m_client);
-    ASSERT_UNUSED(resource, resource == this->resource());
-    ASSERT(m_async);
+    DCHECK(m_client);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_async);
 
     m_checker.redirectReceived();
 
     if (!m_actualRequest.isNull()) {
         reportResponseReceived(resource->identifier(), redirectResponse);
 
         handlePreflightFailure(redirectResponse.url().getString(), "Response for preflight is invalid (redirect)");
 
         request = ResourceRequest();
 
         return;
     }
 
     if (m_redirectMode == WebURLRequest::FetchRedirectModeManual) {
         // Keep |this| alive even if the client release a reference in
         // responseReceived().
         WeakPtr<DocumentThreadableLoader> self(m_weakFactory.createWeakPtr());
 
         // We use |m_redirectMode| to check the original redirect mode.
         // |request| is a new request for redirect. So we don't set the redirect
         // mode of it in WebURLLoaderImpl::Context::OnReceivedRedirect().
-        ASSERT(request.useStreamOnResponse());
+        DCHECK(request.useStreamOnResponse());
         // There is no need to read the body of redirect response because there
         // is no way to read the body of opaque-redirect filtered response's
         // internal response.
         // TODO(horo): If we support any API which expose the internal body, we
         // will have to read the body. And also HTTPCache changes will be needed
         // because it doesn't store the body of redirect responses.
         responseReceived(resource, redirectResponse, wrapUnique(new EmptyDataHandle()));
 
         if (!self) {
             request = ResourceRequest();
             return;
         }
 
         if (m_client) {
-            ASSERT(m_actualRequest.isNull());
+            DCHECK(m_actualRequest.isNull());
             notifyFinished(resource);
         }
 
         request = ResourceRequest();
 
         return;
     }
 
     if (m_redirectMode == WebURLRequest::FetchRedirectModeError) {
         ThreadableLoaderClient* client = m_client;
@@ skipping 90 matching lines @@
     m_checker.redirectBlocked();
 
     // Tells the client that a redirect was received but not followed (for an unknown reason).
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFailRedirectCheck();
 }
 
 void DocumentThreadableLoader::dataSent(Resource* resource, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
-    ASSERT(m_client);
-    ASSERT_UNUSED(resource, resource == this->resource());
-    ASSERT(m_async);
+    DCHECK(m_client);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_async);
 
     m_checker.dataSent();
     m_client->didSendData(bytesSent, totalBytesToBeSent);
 }
 
 void DocumentThreadableLoader::dataDownloaded(Resource* resource, int dataLength)
 {
-    ASSERT(m_client);
-    ASSERT_UNUSED(resource, resource == this->resource());
-    ASSERT(m_actualRequest.isNull());
-    ASSERT(m_async);
+    DCHECK(m_client);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_actualRequest.isNull());
+    DCHECK(m_async);
 
     m_checker.dataDownloaded();
     m_client->didDownloadData(dataLength);
 }
 
 void DocumentThreadableLoader::didReceiveResourceTiming(Resource* resource, const ResourceTimingInfo& info)
 {
-    ASSERT(m_client);
-    ASSERT_UNUSED(resource, resource == this->resource());
-    ASSERT(m_async);
+    DCHECK(m_client);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_async);
 
     m_client->didReceiveResourceTiming(info);
 }
 
 void DocumentThreadableLoader::responseReceived(Resource* resource, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    ASSERT_UNUSED(resource, resource == this->resource());
-    ASSERT(m_async);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_async);
 
     m_checker.responseReceived();
 
     if (handle)
         m_isUsingDataConsumerHandle = true;
 
     handleResponse(resource->identifier(), response, std::move(handle));
 }
 
 void DocumentThreadableLoader::handlePreflightResponse(const ResourceResponse& response)
@@ skipping 24 matching lines @@
     }
 
     CrossOriginPreflightResultCache::shared().appendEntry(getSecurityOrigin()->toString(), m_actualRequest.url(), std::move(preflightResult));
 }
 
 void DocumentThreadableLoader::reportResponseReceived(unsigned long identifier, const ResourceResponse& response)
 {
     LocalFrame* frame = document().frame();
     // We are seeing crashes caused by nullptr (crbug.com/578849). But the frame
     // must be set here. TODO(horo): Find the root cause of the unset frame.
-    ASSERT(frame);
+    DCHECK(frame);
     if (!frame)
         return;
     DocumentLoader* loader = frame->loader().documentLoader();
     TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceReceiveResponse", TRACE_EVENT_SCOPE_THREAD, "data", InspectorReceiveResponseEvent::data(identifier, frame, response));
     InspectorInstrumentation::didReceiveResourceResponse(frame, identifier, loader, response, resource());
     frame->console().reportResourceResponseReceived(loader, identifier, response);
 }
 
 void DocumentThreadableLoader::handleResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    ASSERT(m_client);
+    DCHECK(m_client);
 
     if (!m_actualRequest.isNull()) {
         reportResponseReceived(identifier, response);
         handlePreflightResponse(response);
         return;
     }
 
     if (response.wasFetchedViaServiceWorker()) {
         if (response.wasFetchedViaForeignFetch())
             UseCounter::count(m_document, UseCounter::ForeignFetchInterception);
         if (response.wasFallbackRequiredByServiceWorker()) {
             // At this point we must have m_fallbackRequestForServiceWorker.
             // (For SharedWorker the request won't be CORS or CORS-with-preflight,
             // therefore fallback-to-network is handled in the browser process
             // when the ServiceWorker does not call respondWith().)
-            ASSERT(!m_fallbackRequestForServiceWorker.isNull());
+            DCHECK(!m_fallbackRequestForServiceWorker.isNull());
             reportResponseReceived(identifier, response);
             loadFallbackRequestForServiceWorker();
             return;
         }
         m_fallbackRequestForServiceWorker = ResourceRequest();
         m_client->didReceiveResponse(identifier, response, std::move(handle));
         return;
     }
 
     // Even if the request met the conditions to get handled by a Service Worker
     // in the constructor of this class (and therefore
     // |m_fallbackRequestForServiceWorker| is set), the Service Worker may skip
     // processing the request. Only if the request is same origin, the skipped
     // response may come here (wasFetchedViaServiceWorker() returns false) since
     // such a request doesn't have to go through the CORS algorithm by calling
     // loadFallbackRequestForServiceWorker().
     // FIXME: We should use |m_sameOriginRequest| when we will support
     // Suborigins (crbug.com/336894) for Service Worker.
-    ASSERT(m_fallbackRequestForServiceWorker.isNull() || getSecurityOrigin()->canRequest(m_fallbackRequestForServiceWorker.url()));
+    DCHECK(m_fallbackRequestForServiceWorker.isNull() || getSecurityOrigin()->canRequest(m_fallbackRequestForServiceWorker.url()));
     m_fallbackRequestForServiceWorker = ResourceRequest();
 
     if (!m_sameOriginRequest && m_options.crossOriginRequestPolicy == UseAccessControl) {
         String accessControlErrorDescription;
         if (!passesAccessControlCheck(response, effectiveAllowCredentials(), getSecurityOrigin(), accessControlErrorDescription, m_requestContext)) {
             reportResponseReceived(identifier, response);
 
             ThreadableLoaderClient* client = m_client;
             clear();
             client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, response.url().getString(), accessControlErrorDescription));
             return;
         }
     }
 
     m_client->didReceiveResponse(identifier, response, std::move(handle));
 }
 
 void DocumentThreadableLoader::setSerializedCachedMetadata(Resource*, const char* data, size_t size)
 {
     m_checker.setSerializedCachedMetadata();
 
     if (!m_actualRequest.isNull())
         return;
     m_client->didReceiveCachedMetadata(data, size);
 }
 
 void DocumentThreadableLoader::dataReceived(Resource* resource, const char* data, size_t dataLength)
 {
-    ASSERT_UNUSED(resource, resource == this->resource());
-    ASSERT(m_async);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_async);
 
     m_checker.dataReceived();
 
     if (m_isUsingDataConsumerHandle)
         return;
 
     // TODO(junov): Fix the ThreadableLoader ecosystem to use size_t.
     // Until then, we use safeCast to trap potential overflows.
     handleReceivedData(data, safeCast<unsigned>(dataLength));
 }
 
 void DocumentThreadableLoader::handleReceivedData(const char* data, size_t dataLength)
 {
-    ASSERT(m_client);
+    DCHECK(m_client);
 
     // Preflight data should be invisible to clients.
     if (!m_actualRequest.isNull())
         return;
 
-    ASSERT(m_fallbackRequestForServiceWorker.isNull());
+    DCHECK(m_fallbackRequestForServiceWorker.isNull());
 
     m_client->didReceiveData(data, dataLength);
 }
 
 void DocumentThreadableLoader::notifyFinished(Resource* resource)
 {
-    ASSERT(m_client);
-    ASSERT(resource == this->resource());
-    ASSERT(m_async);
+    DCHECK(m_client);
+    DCHECK_EQ(resource, this->resource());
+    DCHECK(m_async);
 
     m_checker.notifyFinished(resource);
 
     if (resource->errorOccurred()) {
         handleError(resource->resourceError());
     } else {
         handleSuccessfulFinish(resource->identifier(), resource->loadFinishTime());
     }
 }
 
 void DocumentThreadableLoader::handleSuccessfulFinish(unsigned long identifier, double finishTime)
 {
-    ASSERT(m_fallbackRequestForServiceWorker.isNull());
+    DCHECK(m_fallbackRequestForServiceWorker.isNull());
 
     if (!m_actualRequest.isNull()) {
         // FIXME: Timeout should be applied to whole fetch, not for each of
         // preflight and actual request.
         m_timeoutTimer.stop();
-        ASSERT(!m_sameOriginRequest);
-        ASSERT(m_options.crossOriginRequestPolicy == UseAccessControl);
+        DCHECK(!m_sameOriginRequest);
+        DCHECK_EQ(m_options.crossOriginRequestPolicy, UseAccessControl);
         loadActualRequest();
         return;
     }
 
     ThreadableLoaderClient* client = m_client;
     // Protect the resource in |didFinishLoading| in order not to release the
     // downloaded file.
     Persistent<Resource> protect = resource();
     clear();
     client->didFinishLoading(identifier, finishTime);
 }
 
 void DocumentThreadableLoader::didTimeout(TimerBase* timer)
 {
-    ASSERT_UNUSED(timer, timer == &m_timeoutTimer);
+    DCHECK_EQ(timer, &m_timeoutTimer);
 
     // Using values from net/base/net_error_list.h ERR_TIMED_OUT,
     // Same as existing FIXME above - this error should be coming from FrameLoaderClient to be identifiable.
     static const int timeoutError = -7;
     ResourceError error("net", timeoutError, resource()->url(), String());
     error.setIsTimeout(true);
     cancelWithError(error);
 }
 
 void DocumentThreadableLoader::loadFallbackRequestForServiceWorker()
@@ skipping 45 matching lines @@
 
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFail(copiedError);
 }
 
 void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, ResourceLoaderOptions resourceLoaderOptions)
 {
     // Any credential should have been removed from the cross-site requests.
     const KURL& requestURL = request.url();
-    ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
-    ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
+    DCHECK(m_sameOriginRequest || requestURL.user().isEmpty());
+    DCHECK(m_sameOriginRequest || requestURL.pass().isEmpty());
 
     // Update resourceLoaderOptions with enforced values.
     if (m_forceDoNotAllowStoredCredentials)
         resourceLoaderOptions.allowCredentials = DoNotAllowStoredCredentials;
     resourceLoaderOptions.securityOrigin = m_securityOrigin;
     if (m_async) {
         if (!m_actualRequest.isNull())
             resourceLoaderOptions.dataBufferingPolicy = BufferData;
 
         if (m_options.timeoutMilliseconds > 0)
             m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0, BLINK_FROM_HERE);
 
         FetchRequest newRequest(request, m_options.initiator, resourceLoaderOptions);
         if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
             newRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
-        ASSERT(!resource());
+        DCHECK(!resource());
 
         WeakPtr<DocumentThreadableLoader> self(m_weakFactory.createWeakPtr());
 
         if (request.requestContext() == WebURLRequest::RequestContextVideo || request.requestContext() == WebURLRequest::RequestContextAudio)
             setResource(RawResource::fetchMedia(newRequest, document().fetcher()));
         else if (request.requestContext() == WebURLRequest::RequestContextManifest)
             setResource(RawResource::fetchManifest(newRequest, document().fetcher()));
         else
             setResource(RawResource::fetch(newRequest, document().fetcher()));
 
@@ skipping 94 matching lines @@
     return m_resourceLoaderOptions.allowCredentials;
 }
 
 const SecurityOrigin* DocumentThreadableLoader::getSecurityOrigin() const
 {
     return m_securityOrigin ? m_securityOrigin.get() : document().getSecurityOrigin();
 }
 
 Document& DocumentThreadableLoader::document() const
 {
-    ASSERT(m_document);
+    DCHECK(m_document);
     return *m_document;
 }
 
 DEFINE_TRACE(DocumentThreadableLoader)
 {
     visitor->trace(m_resource);
     visitor->trace(m_document);
     ThreadableLoader::trace(visitor);
     RawResourceClient::trace(visitor);
 }
 
 } // namespace blink