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

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

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 140 matching lines @@
 
     return disallowFetch;
 }
 
 } // namespace
 
 FrameFetchContext::FrameFetchContext(DocumentLoader* loader, Document* document)
     : m_document(document)
     , m_documentLoader(loader)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 }
 
 FrameFetchContext::~FrameFetchContext()
 {
     m_document = nullptr;
     m_documentLoader = nullptr;
 }
 
 LocalFrame* FrameFetchContext::frame() const
 {
     LocalFrame* frame = nullptr;
     if (m_documentLoader)
         frame = m_documentLoader->frame();
     else if (m_document && m_document->importsController())
         frame = m_document->importsController()->master()->frame();
-    ASSERT(frame);
+    DCHECK(frame);
     return frame;
 }
 
 void FrameFetchContext::addAdditionalRequestHeaders(ResourceRequest& request, FetchResourceType type)
 {
     bool isMainResource = type == FetchMainResource;
     if (!isMainResource) {
         RefPtr<SecurityOrigin> outgoingOrigin;
         if (!request.didSetHTTPReferrer()) {
-            ASSERT(m_document);
+            DCHECK(m_document);
             outgoingOrigin = m_document->getSecurityOrigin();
             request.setHTTPReferrer(SecurityPolicy::generateReferrer(m_document->getReferrerPolicy(), request.url(), m_document->outgoingReferrer()));
         } else {
-            RELEASE_ASSERT(SecurityPolicy::generateReferrer(request.getReferrerPolicy(), request.url(), request.httpReferrer()).referrer == request.httpReferrer());
+            CHECK(SecurityPolicy::generateReferrer(request.getReferrerPolicy(), request.url(), request.httpReferrer()).referrer == request.httpReferrer());
             outgoingOrigin = SecurityOrigin::createFromString(request.httpReferrer());
         }
 
         request.addHTTPOriginIfNeeded(outgoingOrigin.get());
     }
 
     if (m_document)
         request.setExternalRequestStateFromRequestorAddressSpace(m_document->addressSpace());
 
     // The remaining modifications are only necessary for HTTP and HTTPS.
@@ skipping 45 matching lines @@
         return WebCachePolicy::ValidatingCacheData;
     if (policy == CachePolicyReload)
         return WebCachePolicy::BypassingCache;
     if (policy == CachePolicyHistoryBuffer)
         return WebCachePolicy::ReturnCacheDataElseLoad;
     return WebCachePolicy::UseProtocolCachePolicy;
 }
 
 WebCachePolicy FrameFetchContext::resourceRequestCachePolicy(const ResourceRequest& request, Resource::Type type, FetchRequest::DeferOption defer) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     if (type == Resource::MainResource) {
         FrameLoadType frameLoadType = frame()->loader().loadType();
         if (request.httpMethod() == "POST" && frameLoadType == FrameLoadTypeBackForward)
             return WebCachePolicy::ReturnCacheDataDontLoad;
         if (frameLoadType == FrameLoadTypeReloadMainResource || request.isConditional() || request.httpMethod() == "POST")
             return WebCachePolicy::ValidatingCacheData;
 
         for (Frame* f = frame(); f; f = f->tree().parent()) {
             if (!f->isLocalFrame())
                 continue;
@@ skipping 248 matching lines @@
     case Resource::Media:
     case Resource::Manifest:
         // By default these types of resources can be loaded from any origin.
         // FIXME: Are we sure about Resource::Font?
         if (originRestriction == FetchRequest::RestrictToSameOrigin && !securityOrigin->canRequest(url)) {
             printAccessDeniedMessage(url);
             return ResourceRequestBlockedReasonOrigin;
         }
         break;
     case Resource::XSLStyleSheet:
-        ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+        DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::SVGDocument:
         if (!securityOrigin->canRequest(url)) {
             printAccessDeniedMessage(url);
             return ResourceRequestBlockedReasonOrigin;
         }
         break;
     }
 
     // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
     bool shouldBypassMainWorldCSP = frame()->script().shouldBypassMainWorldCSP() || options.contentSecurityPolicyOption == DoNotCheckContentSecurityPolicy;
 
     // Don't send CSP messages for preloads, we might never actually display those items.
     ContentSecurityPolicy::ReportingStatus cspReporting = forPreload ?
         ContentSecurityPolicy::SuppressReport : ContentSecurityPolicy::SendReport;
 
     if (m_document) {
         DCHECK(m_document->contentSecurityPolicy());
         if (!shouldBypassMainWorldCSP && !m_document->contentSecurityPolicy()->allowRequest(resourceRequest.requestContext(), url, options.contentSecurityPolicyNonce, options.integrityMetadata, redirectStatus, cspReporting))
             return ResourceRequestBlockedReasonCSP;
     }
 
     if (type == Resource::Script || type == Resource::ImportResource) {
-        ASSERT(frame());
+        DCHECK(frame());
         if (!frame()->loader().client()->allowScriptFromSource(!frame()->settings() || frame()->settings()->scriptEnabled(), url)) {
             frame()->loader().client()->didNotAllowScript();
             // TODO(estark): Use a different ResourceRequestBlockedReason
             // here, since this check has nothing to do with
             // CSP. https://crbug.com/600795
             return ResourceRequestBlockedReasonCSP;
         }
     } else if (type == Resource::Media || type == Resource::TextTrack) {
-        ASSERT(frame());
+        DCHECK(frame());
         if (!frame()->loader().client()->allowMedia(url))
             return ResourceRequestBlockedReasonOther;
     }
 
     // SVG Images have unique security rules that prevent all subresource requests
     // except for data urls.
     if (type != Resource::MainResource && frame()->chromeClient().isSVGImageChromeClient() && !url.protocolIsData())
         return ResourceRequestBlockedReasonOrigin;
 
     // Measure the number of legacy URL schemes ('ftp://') and the number of embedded-credential
     // ('http://user:password@...') resources embedded as subresources. in the hopes that we can
     // block them at some point in the future.
     if (resourceRequest.frameType() != WebURLRequest::FrameTypeTopLevel) {
-        ASSERT(frame()->document());
+        DCHECK(frame()->document());
         if (SchemeRegistry::shouldTreatURLSchemeAsLegacy(url.protocol()) && !SchemeRegistry::shouldTreatURLSchemeAsLegacy(frame()->document()->getSecurityOrigin()->protocol()))
             UseCounter::count(frame()->document(), UseCounter::LegacyProtocolEmbeddedAsSubresource);
         if (!url.user().isEmpty() || !url.pass().isEmpty())
             UseCounter::count(frame()->document(), UseCounter::RequestedSubresourceWithEmbeddedCredentials);
     }
 
     // Check for mixed content. We do this second-to-last so that when folks block
     // mixed content with a CSP policy, they don't get a warning. They'll still
     // get a warning in the console about CSP blocking the load.
     MixedContentChecker::ReportingStatus mixedContentReporting = forPreload ?
         MixedContentChecker::SuppressReport : MixedContentChecker::SendReport;
     if (MixedContentChecker::shouldBlockFetch(frame(), resourceRequest, url, mixedContentReporting))
         return ResourceRequestBlockedReasonMixedContent;
 
     // Let the client have the final say into whether or not the load should proceed.
     DocumentLoader* documentLoader = masterDocumentLoader();
     if (documentLoader && documentLoader->subresourceFilter() && type != Resource::MainResource && type != Resource::ImportResource && !documentLoader->subresourceFilter()->allowLoad(url, resourceRequest.requestContext()))
         return ResourceRequestBlockedReasonSubresourceFilter;
 
     return ResourceRequestBlockedReasonNone;
 }
 
 bool FrameFetchContext::isControlledByServiceWorker() const
 {
-    ASSERT(m_documentLoader || frame()->loader().documentLoader());
+    DCHECK(m_documentLoader || frame()->loader().documentLoader());
     if (m_documentLoader)
         return frame()->loader().client()->isControlledByServiceWorker(*m_documentLoader);
     // m_documentLoader is null while loading resources from an HTML import.
     // In such cases whether the request is controlled by ServiceWorker or not
     // is determined by the document loader of the frame.
     return frame()->loader().client()->isControlledByServiceWorker(*frame()->loader().documentLoader());
 }
 
 int64_t FrameFetchContext::serviceWorkerID() const
 {
-    ASSERT(m_documentLoader || frame()->loader().documentLoader());
+    DCHECK(m_documentLoader || frame()->loader().documentLoader());
     if (m_documentLoader)
         return frame()->loader().client()->serviceWorkerID(*m_documentLoader);
     // m_documentLoader is null while loading resources from an HTML import.
     // In such cases a service worker ID could be retrieved from the document
     // loader of the frame.
     return frame()->loader().client()->serviceWorkerID(*frame()->loader().documentLoader());
 }
 
 bool FrameFetchContext::isMainFrame() const
 {
@@ skipping 134 matching lines @@
     // Auxiliary frame types in 'createWindow()' and 'FrameLoader::load'.
     if (request.frameType() == WebURLRequest::FrameTypeNone && !request.requestorOrigin()) {
         request.setRequestorOrigin(m_document->isSandboxed(SandboxOrigin)
             ? SecurityOrigin::create(m_document->url())
             : m_document->getSecurityOrigin());
     }
 }
 
 MHTMLArchive* FrameFetchContext::archive() const
 {
-    ASSERT(!isMainFrame());
+    DCHECK(!isMainFrame());
     // TODO(nasko): How should this work with OOPIF?
     // The MHTMLArchive is parsed as a whole, but can be constructed from
     // frames in mutliple processes. In that case, which process should parse
     // it and how should the output be spread back across multiple processes?
     if (!frame()->tree().parent()->isLocalFrame())
         return nullptr;
     return toLocalFrame(frame()->tree().parent())->loader().documentLoader()->fetcher()->archive();
 }
 
 void FrameFetchContext::countClientHintsDPR()
@@ skipping 55 matching lines @@
 }
 
 DEFINE_TRACE(FrameFetchContext)
 {
     visitor->trace(m_document);
     visitor->trace(m_documentLoader);
     FetchContext::trace(visitor);
 }
 
 } // namespace blink