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

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
  * Copyright (C) 2011 Kris Jordan <krisjordan@gmail.com>
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ skipping 171 matching lines @@
     , m_dispatchingDidClearWindowObjectInMainWorld(false)
     , m_protectProvisionalLoader(false)
 {
     TRACE_EVENT_OBJECT_CREATED_WITH_ID("loading", "FrameLoader", this);
     takeObjectSnapshot();
 }
 
 FrameLoader::~FrameLoader()
 {
     // Verify that this FrameLoader has been detached.
-    ASSERT(!m_progressTracker);
+    DCHECK(!m_progressTracker);
 }
 
 DEFINE_TRACE(FrameLoader)
 {
     visitor->trace(m_frame);
     visitor->trace(m_progressTracker);
     visitor->trace(m_documentLoader);
     visitor->trace(m_provisionalDocumentLoader);
     visitor->trace(m_currentItem);
     visitor->trace(m_provisionalItem);
@@ skipping 257 matching lines @@
     TRACE_EVENT1("devtools.timeline", "CommitLoad", "data", InspectorCommitLoadEvent::data(m_frame));
     InspectorInstrumentation::didCommitLoad(m_frame, m_documentLoader.get());
     m_frame->page()->didCommitLoad(m_frame);
     dispatchDidClearDocumentOfWindowObject();
 
     takeObjectSnapshot();
 }
 
 void FrameLoader::didInstallNewDocument(bool dispatchWindowObjectAvailable)
 {
-    ASSERT(m_frame);
-    ASSERT(m_frame->document());
+    DCHECK(m_frame);
+    DCHECK(m_frame->document());
 
     m_frame->document()->setReadyState(Document::Loading);
 
     if (dispatchWindowObjectAvailable)
         dispatchDidClearDocumentOfWindowObject();
 
     m_frame->document()->initContentSecurityPolicy(m_documentLoader ? m_documentLoader->releaseContentSecurityPolicy() : ContentSecurityPolicy::create());
 
     if (m_provisionalItem && isBackForwardLoadType(m_loadType))
         m_frame->document()->setStateForNewFormElements(m_provisionalItem->documentState());
 }
 
 void FrameLoader::didBeginDocument()
 {
-    ASSERT(m_frame);
-    ASSERT(m_frame->document());
-    ASSERT(m_frame->document()->fetcher());
+    DCHECK(m_frame);
+    DCHECK(m_frame->document());
+    DCHECK(m_frame->document()->fetcher());
 
     if (m_documentLoader) {
         String suboriginHeader = m_documentLoader->response().httpHeaderField(HTTPNames::Suborigin);
         if (!suboriginHeader.isNull()) {
             Vector<String> messages;
             Suborigin suborigin;
             if (parseSuboriginHeader(suboriginHeader, &suborigin, messages))
                 m_frame->document()->enforceSuborigin(suborigin);
 
             for (auto& message : messages)
@@ skipping 244 matching lines @@
         return;
 
     FrameNavigationDisabler navigationDisabler(*m_frame);
     loader->detachFromFrame();
     loader = nullptr;
 }
 
 void FrameLoader::loadInSameDocument(const KURL& url, PassRefPtr<SerializedScriptValue> stateObject, FrameLoadType frameLoadType, HistoryLoadType historyLoadType, ClientRedirectPolicy clientRedirect, Document* initiatingDocument)
 {
     // If we have a state object, we cannot also be a new navigation.
-    ASSERT(!stateObject || frameLoadType == FrameLoadTypeBackForward);
+    DCHECK(!stateObject || frameLoadType == FrameLoadTypeBackForward);
 
     // If we have a provisional request for a different document, a fragment scroll should cancel it.
     detachDocumentLoader(m_provisionalDocumentLoader);
     if (!m_frame->host())
         return;
     AutoReset<FrameLoadType> loadTypeChange(&m_loadType, frameLoadType);
     saveScrollState();
 
     KURL oldURL = m_frame->document()->url();
     bool hashChange = equalIgnoringFragmentIdentifier(url, oldURL) && url.fragmentIdentifier() != oldURL.fragmentIdentifier();
@@ skipping 163 matching lines @@
         // The click is simulated when triggering the gesture-tap event
         GestureEvent* gestureEvent = toGestureEvent(event);
         navigationPolicyFromMouseEvent(0, gestureEvent->ctrlKey(), gestureEvent->shiftKey(), gestureEvent->altKey(), gestureEvent->metaKey(), &policy);
     }
     return policy;
 }
 
 void FrameLoader::load(const FrameLoadRequest& passedRequest, FrameLoadType frameLoadType,
     HistoryItem* historyItem, HistoryLoadType historyLoadType)
 {
-    ASSERT(m_frame->document());
+    DCHECK(m_frame->document());
 
     if (!m_frame->isNavigationAllowed())
         return;
 
     if (m_inStopAllLoaders)
         return;
 
     if (m_frame->page()->defersLoading() && isBackForwardLoadType(frameLoadType)) {
         m_deferredHistoryLoad = DeferredHistoryLoad::create(passedRequest.resourceRequest(), historyItem, frameLoadType, historyLoadType);
         return;
     }
 
     FrameLoadRequest request(passedRequest);
     request.resourceRequest().setHasUserGesture(UserGestureIndicator::processingUserGesture());
 
     if (!prepareRequestForThisFrame(request))
         return;
 
     Frame* targetFrame = request.form() ? nullptr : m_frame->findFrameForNavigation(AtomicString(request.frameName()), *m_frame);
 
     if (isBackForwardLoadType(frameLoadType)) {
-        ASSERT(historyItem);
+        DCHECK(historyItem);
         m_provisionalItem = historyItem;
     }
 
     if (targetFrame && targetFrame != m_frame) {
         bool wasInSamePage = targetFrame->page() == m_frame->page();
 
         request.setFrameName("_self");
         targetFrame->navigate(request);
         Page* page = targetFrame->page();
         if (!wasInSamePage && page)
@@ skipping 18 matching lines @@
 
     const KURL& url = request.resourceRequest().url();
     bool sameDocumentHistoryNavigation =
         isBackForwardLoadType(newLoadType) && historyLoadType == HistorySameDocumentLoad;
     bool sameDocumentNavigation = policy == NavigationPolicyCurrentTab
         && shouldPerformFragmentNavigation(
             request.form(), request.resourceRequest().httpMethod(), newLoadType, url);
 
     // Perform same document navigation.
     if (sameDocumentHistoryNavigation || sameDocumentNavigation) {
-        ASSERT(historyItem || !sameDocumentHistoryNavigation);
+        DCHECK(historyItem || !sameDocumentHistoryNavigation);
         RefPtr<SerializedScriptValue> stateObject = sameDocumentHistoryNavigation ?
             historyItem->stateObject() : nullptr;
 
         if (!sameDocumentHistoryNavigation) {
             m_documentLoader->setNavigationType(determineNavigationType(
                 newLoadType, false, request.triggeringEvent()));
             if (shouldTreatURLAsSameAsCurrent(url))
                 newLoadType = FrameLoadTypeReplaceCurrentItem;
         }
 
         loadInSameDocument(url, stateObject, newLoadType, historyLoadType, request.clientRedirect(), request.originDocument());
         return;
     }
 
     startLoad(request, newLoadType, policy);
 }
 
 SubstituteData FrameLoader::defaultSubstituteDataForURL(const KURL& url)
 {
     if (!shouldTreatURLAsSrcdocDocument(url))
         return SubstituteData();
     String srcdoc = m_frame->deprecatedLocalOwner()->fastGetAttribute(srcdocAttr);
-    ASSERT(!srcdoc.isNull());
+    DCHECK(!srcdoc.isNull());
     CString encodedSrcdoc = srcdoc.utf8();
     return SubstituteData(SharedBuffer::create(encodedSrcdoc.data(), encodedSrcdoc.length()), "text/html", "UTF-8", KURL());
 }
 
 void FrameLoader::reportLocalLoadFailed(LocalFrame* frame, const String& url)
 {
-    ASSERT(!url.isEmpty());
+    DCHECK(!url.isEmpty());
     if (!frame)
         return;
 
     frame->document()->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Not allowed to load local resource: " + url));
 }
 
 void FrameLoader::stopAllLoaders()
 {
     if (m_frame->document()->pageDismissalEventBeingDispatched() != Document::NoDismissal)
         return;
@@ skipping 79 matching lines @@
     // window.stop(), which will in turn detach the provisional document loader.
     // At this point, the provisional document loader should not detach, because
     // then the FrameLoader would not have any attached DocumentLoaders.
     if (m_documentLoader) {
         AutoReset<bool> inDetachDocumentLoader(&m_protectProvisionalLoader, true);
         detachDocumentLoader(m_documentLoader);
     }
     // 'abort' listeners can also detach the frame.
     if (!m_frame->client())
         return false;
-    ASSERT(m_provisionalDocumentLoader == pdl);
+    DCHECK_EQ(m_provisionalDocumentLoader, pdl);
     // No more events will be dispatched so detach the Document.
     // TODO(yoav): Should we also be nullifying domWindow's document (or domWindow) since the doc is now detached?
     if (m_frame->document())
         m_frame->document()->shutdown();
     m_documentLoader = m_provisionalDocumentLoader.release();
     takeObjectSnapshot();
 
     return true;
 }
 
 void FrameLoader::commitProvisionalLoad()
 {
-    ASSERT(client()->hasWebView());
+    DCHECK(client()->hasWebView());
 
     // Check if the destination page is allowed to access the previous page's timing information.
     if (m_frame->document()) {
         RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::create(m_provisionalDocumentLoader->request().url());
         m_provisionalDocumentLoader->timing().setHasSameOriginAsPreviousDocument(securityOrigin->canRequest(m_frame->document()->url()));
     }
 
     if (!prepareForCommit())
         return;
 
@@ skipping 119 matching lines @@
     }
 
     HistoryCommitType historyCommitType = loadTypeToCommitType(m_loadType);
     if (loader == m_provisionalDocumentLoader) {
         client()->dispatchDidFailProvisionalLoad(error, historyCommitType);
         if (loader != m_provisionalDocumentLoader)
             return;
         detachDocumentLoader(m_provisionalDocumentLoader);
         m_progressTracker->progressCompleted();
     } else {
-        ASSERT(loader == m_documentLoader);
+        DCHECK_EQ(loader, m_documentLoader);
         if (m_frame->document()->parser())
             m_frame->document()->parser()->stopParsing();
         m_documentLoader->setSentDidFinishLoad();
         if (!m_provisionalDocumentLoader && m_frame->isLoading()) {
             client()->dispatchDidFailLoad(error, historyCommitType);
             m_progressTracker->progressCompleted();
         }
     }
     checkCompleted();
 }
@@ skipping 112 matching lines @@
         return false;
     }
     if (!LocalDOMWindow::allowPopUp(*m_frame) && !UserGestureIndicator::utilizeUserGesture())
         return false;
     client()->loadURLExternally(request, policy, String(), replacesCurrentHistoryItem);
     return false;
 }
 
 void FrameLoader::startLoad(FrameLoadRequest& frameLoadRequest, FrameLoadType type, NavigationPolicy navigationPolicy)
 {
-    ASSERT(client()->hasWebView());
+    DCHECK(client()->hasWebView());
     if (m_frame->document()->pageDismissalEventBeingDispatched() != Document::NoDismissal)
         return;
 
     NavigationType navigationType = determineNavigationType(type, frameLoadRequest.resourceRequest().httpBody() || frameLoadRequest.form(), frameLoadRequest.triggeringEvent());
     frameLoadRequest.resourceRequest().setRequestContext(determineRequestContextFromNavigationType(navigationType));
     frameLoadRequest.resourceRequest().setFrameType(m_frame->isMainFrame() ? WebURLRequest::FrameTypeTopLevel : WebURLRequest::FrameTypeNested);
     ResourceRequest& request = frameLoadRequest.resourceRequest();
     upgradeInsecureRequest(request, nullptr);
     if (!shouldContinueForNavigationPolicy(request, frameLoadRequest.substituteData(), nullptr, frameLoadRequest.shouldCheckMainWorldContentSecurityPolicy(), navigationType, navigationPolicy, type == FrameLoadTypeReplaceCurrentItem, frameLoadRequest.clientRedirect() == ClientRedirectPolicy::ClientRedirect))
         return;
@@ skipping 18 matching lines @@
 
     if (frameLoadRequest.form())
         client()->dispatchWillSubmitForm(frameLoadRequest.form());
 
     m_progressTracker->progressStarted();
     if (m_provisionalDocumentLoader->isClientRedirect())
         m_provisionalDocumentLoader->appendRedirect(m_frame->document()->url());
     m_provisionalDocumentLoader->appendRedirect(m_provisionalDocumentLoader->request().url());
     double triggeringEventTime = frameLoadRequest.triggeringEvent() ? frameLoadRequest.triggeringEvent()->platformTimeStamp() : 0;
     client()->dispatchDidStartProvisionalLoad(triggeringEventTime);
-    ASSERT(m_provisionalDocumentLoader);
+    DCHECK(m_provisionalDocumentLoader);
     m_provisionalDocumentLoader->startLoadingMainResource();
 
     takeObjectSnapshot();
 }
 
 void FrameLoader::applyUserAgent(ResourceRequest& request)
 {
     String userAgent = this->userAgent();
-    ASSERT(!userAgent.isNull());
+    DCHECK(!userAgent.isNull());
     request.setHTTPUserAgent(AtomicString(userAgent));
 }
 
 bool FrameLoader::shouldInterruptLoadForXFrameOptions(const String& content, const KURL& url, unsigned long requestIdentifier)
 {
     UseCounter::count(m_frame->domWindow()->document(), UseCounter::XFrameOptions);
 
     Frame* topFrame = m_frame->tree().top();
     if (m_frame == topFrame)
         return false;
@@ skipping 108 matching lines @@
 {
     Frame* parentFrame = m_frame->tree().parent();
     if (!parentFrame)
         return kLeaveInsecureRequestsAlone;
 
     return parentFrame->securityContext()->getInsecureRequestPolicy();
 }
 
 SecurityContext::InsecureNavigationsSet* FrameLoader::insecureNavigationsToUpgrade() const
 {
-    ASSERT(m_frame);
+    DCHECK(m_frame);
     Frame* parentFrame = m_frame->tree().parent();
     if (!parentFrame)
         return nullptr;
 
     // FIXME: We need a way to propagate insecure requests policy flags to
     // out-of-process frames. For now, we'll always use default behavior.
     if (!parentFrame->isLocalFrame())
         return nullptr;
 
-    ASSERT(toLocalFrame(parentFrame)->document());
+    DCHECK(toLocalFrame(parentFrame)->document());
     return toLocalFrame(parentFrame)->document()->insecureNavigationsToUpgrade();
 }
 
 void FrameLoader::upgradeInsecureRequest(ResourceRequest& resourceRequest, Document* document) const
 {
     // Tack an 'Upgrade-Insecure-Requests' header to outgoing navigational requests, as described in
     // https://w3c.github.io/webappsec/specs/upgrade/#feature-detect
     if (resourceRequest.frameType() != WebURLRequest::FrameTypeNone) {
 
         // Early return if the request has already been upgraded.
@@ skipping 41 matching lines @@
     tracedValue->setString("documentLoaderURL", m_documentLoader ? m_documentLoader->url() : String());
     return tracedValue;
 }
 
 inline void FrameLoader::takeObjectSnapshot() const
 {
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("loading", "FrameLoader", this, toTracedValue());
 }
 
 } // namespace blink