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

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

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 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.
@@ skipping 107 matching lines @@
 
 FrameLoader* DocumentLoader::frameLoader() const
 {
     if (!m_frame)
         return nullptr;
     return &m_frame->loader();
 }
 
 DocumentLoader::~DocumentLoader()
 {
-    ASSERT(!m_frame);
-    ASSERT(!m_mainResource);
-    ASSERT(!m_applicationCacheHost);
+    DCHECK(!m_frame);
+    DCHECK(!m_mainResource);
+    DCHECK(!m_applicationCacheHost);
 }
 
 DEFINE_TRACE(DocumentLoader)
 {
     visitor->trace(m_frame);
     visitor->trace(m_fetcher);
     visitor->trace(m_mainResource);
     visitor->trace(m_writer);
     visitor->trace(m_documentLoadTiming);
     visitor->trace(m_applicationCacheHost);
@@ skipping 48 matching lines @@
     case Resource::TextTrack:
         resource = RawResource::fetchTextTrack(request, fetcher());
         break;
     case Resource::ImportResource:
         resource = RawResource::fetchImport(request, fetcher());
         break;
     case Resource::Raw:
         resource = RawResource::fetch(request, fetcher());
         break;
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 
     if (resource)
         fetcher()->preloadStarted(resource);
     return resource;
 }
 
 void DocumentLoader::didRedirect(const KURL& oldURL, const KURL& newURL)
 {
     timing().addRedirect(oldURL, newURL);
@@ skipping 14 matching lines @@
 void DocumentLoader::didChangePerformanceTiming()
 {
     if (frame() && frame()->isMainFrame() && m_state >= Committed) {
         frameLoader()->client()->didChangePerformanceTiming();
     }
 }
 
 void DocumentLoader::didObserveLoadingBehavior(WebLoadingBehaviorFlag behavior)
 {
     if (frame() && frame()->isMainFrame()) {
-        ASSERT(m_state >= Committed);
+        DCHECK_GE(m_state, Committed);
         frameLoader()->client()->didObserveLoadingBehavior(behavior);
     }
 }
 
 void DocumentLoader::updateForSameDocumentNavigation(const KURL& newURL, SameDocumentNavigationSource sameDocumentNavigationSource)
 {
     KURL oldURL = m_request.url();
     m_originalRequest.setURL(newURL);
     m_request.setURL(newURL);
     if (sameDocumentNavigationSource == SameDocumentNavigationHistoryApi) {
@@ skipping 14 matching lines @@
 void DocumentLoader::commitIfReady()
 {
     if (m_state < Committed) {
         m_state = Committed;
         frameLoader()->commitProvisionalLoad();
     }
 }
 
 void DocumentLoader::notifyFinished(Resource* resource)
 {
-    ASSERT_UNUSED(resource, m_mainResource == resource);
-    ASSERT(m_mainResource);
+    DCHECK_EQ(m_mainResource, resource);
+    DCHECK(m_mainResource);
 
     if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
         finishedLoading(m_mainResource->loadFinishTime());
         return;
     }
 
     if (m_applicationCacheHost)
         m_applicationCacheHost->failedLoadingMainResource();
     m_state = MainResourceDone;
     frameLoader()->loadFailed(this, m_mainResource->resourceError());
@@ skipping 29 matching lines @@
 
     m_applicationCacheHost->finishedLoadingMainResource();
     endWriting(m_writer.get());
     if (m_state < MainResourceDone)
         m_state = MainResourceDone;
     clearMainResourceHandle();
 }
 
 void DocumentLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
 {
-    ASSERT_UNUSED(resource, resource == m_mainResource);
-    ASSERT(!redirectResponse.isNull());
+    DCHECK_EQ(resource, m_mainResource);
+    DCHECK(!redirectResponse.isNull());
     m_request = request;
 
     // If the redirecting url is not allowed to display content from the target origin,
     // then block the redirect.
     const KURL& requestURL = m_request.url();
     RefPtr<SecurityOrigin> redirectingOrigin = SecurityOrigin::create(redirectResponse.url());
     if (!redirectingOrigin->canDisplay(requestURL)) {
         FrameLoader::reportLocalLoadFailed(m_frame, requestURL.getString());
         m_fetcher->stopFetching();
         return;
     }
     if (!frameLoader()->shouldContinueForNavigationPolicy(m_request, SubstituteData(), this, CheckContentSecurityPolicy, m_navigationType, NavigationPolicyCurrentTab, replacesCurrentHistoryItem(), isClientRedirect())) {
         m_fetcher->stopFetching();
         return;
     }
 
-    ASSERT(timing().fetchStart());
+    DCHECK(timing().fetchStart());
     appendRedirect(requestURL);
     didRedirect(redirectResponse.url(), requestURL);
     frameLoader()->client()->dispatchDidReceiveServerRedirectForProvisionalLoad();
 }
 
 static bool canShowMIMEType(const String& mimeType, LocalFrame* frame)
 {
     if (Platform::current()->mimeRegistry()->supportsMIMEType(mimeType) == WebMimeRegistry::IsSupported)
         return true;
     PluginData* pluginData = frame->pluginData();
@@ skipping 41 matching lines @@
     m_redirectChain.removeLast();
     appendRedirect(blockedURL);
     m_response = ResourceResponse(blockedURL, "text/html", 0, nullAtom, String());
     finishedLoading(monotonicallyIncreasingTime());
 
     return;
 }
 
 void DocumentLoader::responseReceived(Resource* resource, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    ASSERT_UNUSED(resource, m_mainResource == resource);
-    ASSERT_UNUSED(handle, !handle);
-    ASSERT(frame());
+    DCHECK_EQ(m_mainResource, resource);
+    DCHECK(!handle);
+    DCHECK(frame());
 
     m_applicationCacheHost->didReceiveResponseForMainResource(response);
 
     // The memory cache doesn't understand the application cache or its caching rules. So if a main resource is served
     // from the application cache, ensure we don't save the result for future use. All responses loaded
     // from appcache will have a non-zero appCacheID().
     if (response.appCacheID())
         memoryCache()->remove(m_mainResource.get());
 
     m_contentSecurityPolicy = ContentSecurityPolicy::create();
@@ skipping 13 matching lines @@
                 String message = "Refused to display '" + response.url().elidedString() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
                 ConsoleMessage* consoleMessage = ConsoleMessage::createForRequest(SecurityMessageSource, ErrorMessageLevel, message, response.url(), mainResourceIdentifier());
                 frame()->document()->addConsoleMessage(consoleMessage);
 
                 cancelLoadAfterXFrameOptionsOrCSPDenied(response);
                 return;
             }
         }
     }
 
-    ASSERT(!m_frame->page()->defersLoading());
+    DCHECK(!m_frame->page()->defersLoading());
 
     m_response = response;
 
     if (isArchiveMIMEType(m_response.mimeType()) && m_mainResource->getDataBufferingPolicy() != BufferData)
         m_mainResource->setDataBufferingPolicy(BufferData);
 
     if (!shouldContinueForResponse()) {
         InspectorInstrumentation::continueWithPolicyIgnore(m_frame, this, m_mainResource->identifier(), m_response, m_mainResource.get());
         m_fetcher->stopFetching();
         return;
@@ skipping 21 matching lines @@
     if (shouldInheritSecurityOriginFromOwner(url())) {
         Frame* ownerFrame = m_frame->tree().parent();
         if (!ownerFrame)
             ownerFrame = m_frame->loader().opener();
         if (ownerFrame && ownerFrame->isLocalFrame())
             owner = toLocalFrame(ownerFrame)->document();
     }
     DocumentInit init(owner, url(), m_frame);
     init.withNewRegistrationContext();
     m_frame->loader().clear();
-    ASSERT(m_frame->page());
+    DCHECK(m_frame->page());
 
     ParserSynchronizationPolicy parsingPolicy = AllowAsynchronousParsing;
     if ((m_substituteData.isValid() && m_substituteData.forceSynchronousLoad()) || !Document::threadedParsingEnabledForTesting())
         parsingPolicy = ForceSynchronousParsing;
 
     m_writer = createWriterFor(init, mimeType, encoding, false, parsingPolicy, overridingURL);
     m_writer->setDocumentWasLoadedAsPartOfNavigation();
     m_frame->document()->maybeHandleHttpRefresh(m_response.httpHeaderField(HTTPNames::Refresh), Document::HttpRefreshFromHeader);
 }
 
 void DocumentLoader::commitData(const char* bytes, size_t length)
 {
-    ASSERT(m_state < MainResourceDone);
+    DCHECK_LT(m_state, MainResourceDone);
     ensureWriter(m_response.mimeType());
 
     // This can happen if document.close() is called by an event handler while
     // there's still pending incoming data.
     if (m_frame && !m_frame->document()->parsing())
         return;
 
     if (length)
         m_dataReceived = true;
 
     m_writer->addData(bytes, length);
 }
 
 void DocumentLoader::dataReceived(Resource* resource, const char* data, size_t length)
 {
-    ASSERT(data);
-    ASSERT(length);
-    ASSERT_UNUSED(resource, resource == m_mainResource);
-    ASSERT(!m_response.isNull());
-    ASSERT(!m_frame->page()->defersLoading());
+    DCHECK(data);
+    DCHECK(length);
+    DCHECK_EQ(resource, m_mainResource);
+    DCHECK(!m_response.isNull());
+    DCHECK(!m_frame->page()->defersLoading());
 
     if (m_inDataReceived) {
         // If this function is reentered, defer processing of the additional
         // data to the top-level invocation. Reentrant calls can occur because
         // of web platform (mis-)features that require running a nested message
         // loop:
         // - alert(), confirm(), prompt()
         // - Detach of plugin elements.
         // - Synchronous XMLHTTPRequest
         m_dataBuffer->append(data, length);
@@ skipping 39 matching lines @@
     m_redirectChain.clear();
 }
 
 void DocumentLoader::appendRedirect(const KURL& url)
 {
     m_redirectChain.append(url);
 }
 
 void DocumentLoader::detachFromFrame()
 {
-    ASSERT(m_frame);
+    DCHECK(m_frame);
 
     // It never makes sense to have a document loader that is detached from its
     // frame have any loads active, so go ahead and kill all the loads.
     m_fetcher->stopFetching();
 
     // If that load cancellation triggered another detach, leave.
     // (fast/frames/detach-frame-nested-no-crash.html is an example of this.)
     if (!m_frame)
         return;
 
@@ skipping 12 matching lines @@
     m_mainResource->removeClient(this);
     m_mainResource = nullptr;
 }
 
 bool DocumentLoader::maybeCreateArchive()
 {
     // Give the archive machinery a crack at this document. If the MIME type is not an archive type, it will return 0.
     if (!isArchiveMIMEType(m_response.mimeType()))
         return false;
 
-    ASSERT(m_mainResource);
+    DCHECK(m_mainResource);
     ArchiveResource* mainResource = m_fetcher->createArchive(m_mainResource.get());
     if (!mainResource)
         return false;
     // The origin is the MHTML file, we need to set the base URL to the document encoded in the MHTML so
     // relative URLs are resolved properly.
     ensureWriter(mainResource->mimeType(), mainResource->url());
 
     // The Document has now been created.
     m_frame->document()->enforceSandboxFlags(SandboxAll);
 
@@ skipping 20 matching lines @@
     if (m_request.url().isEmpty() && !frameLoader()->stateMachine()->creatingInitialEmptyDocument())
         m_request.setURL(blankURL());
     m_response = ResourceResponse(m_request.url(), "text/html", 0, nullAtom, String());
     finishedLoading(monotonicallyIncreasingTime());
     return true;
 }
 
 void DocumentLoader::startLoadingMainResource()
 {
     timing().markNavigationStart();
-    ASSERT(!m_mainResource);
-    ASSERT(m_state == NotStarted);
+    DCHECK(!m_mainResource);
+    DCHECK_EQ(m_state, NotStarted);
     m_state = Provisional;
 
     if (maybeLoadEmpty())
         return;
 
-    ASSERT(timing().navigationStart());
+    DCHECK(timing().navigationStart());
 
     // PlzNavigate:
     // The fetch has already started in the browser. Don't mark it again.
     if (!m_frame->settings()->browserSideNavigationEnabled()) {
         DCHECK(!timing().fetchStart());
         timing().markFetchStart();
     }
 
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, mainResourceLoadOptions,
         (DoNotBufferData, AllowStoredCredentials, ClientRequestedCredentials, CheckContentSecurityPolicy, DocumentContext));
     FetchRequest fetchRequest(m_request, FetchInitiatorTypeNames::document, mainResourceLoadOptions);
     m_mainResource = RawResource::fetchMainResource(fetchRequest, fetcher(), m_substituteData);
     if (!m_mainResource) {
         m_request = ResourceRequest(blankURL());
         maybeLoadEmpty();
         return;
     }
     // A bunch of headers are set when the underlying resource load begins, and m_request needs to include those.
     // Even when using a cached resource, we may make some modification to the request, e.g. adding the referer header.
     m_request = m_mainResource->isLoading() ? m_mainResource->resourceRequest() : fetchRequest.resourceRequest();
     m_mainResource->addClient(this);
 }
 
 void DocumentLoader::endWriting(DocumentWriter* writer)
 {
-    ASSERT_UNUSED(writer, m_writer == writer);
+    DCHECK_EQ(m_writer, writer);
     m_writer->end();
     m_writer.clear();
 }
 
 DocumentWriter* DocumentLoader::createWriterFor(const DocumentInit& init, const AtomicString& mimeType, const AtomicString& encoding, bool dispatchWindowObjectAvailable, ParserSynchronizationPolicy parsingPolicy, const KURL& overridingURL)
 {
     LocalFrame* frame = init.frame();
 
-    ASSERT(!frame->document() || !frame->document()->isActive());
-    ASSERT(frame->tree().childCount() == 0);
+    DCHECK(!frame->document() || !frame->document()->isActive());
+    DCHECK_EQ(frame->tree().childCount(), 0u);
 
     if (!init.shouldReuseDefaultView())
         frame->setDOMWindow(LocalDOMWindow::create(*frame));
 
     Document* document = frame->localDOMWindow()->installNewDocument(mimeType, init);
 
     // This should be set before receivedFirstData().
     if (!overridingURL.isEmpty())
         frame->document()->setBaseURLOverride(overridingURL);
 
@@ skipping 21 matching lines @@
 {
     m_writer = createWriterFor(init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true, ForceSynchronousParsing);
     if (!source.isNull())
         m_writer->appendReplacingData(source);
     endWriting(m_writer.get());
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 } // namespace blink