Clarify when DocumentLoader's FrameLoader/FrameLoaderClient accessors can be used

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 99 matching lines @@
       m_replacesCurrentHistoryItem(false),
       m_dataReceived(false),
       m_navigationType(NavigationTypeOther),
       m_documentLoadTiming(*this),
       m_timeOfLastDataReceived(0.0),
       m_applicationCacheHost(ApplicationCacheHost::create(this)),
       m_wasBlockedAfterCSP(false),
       m_state(NotStarted),
       m_inDataReceived(false),
       m_dataBuffer(SharedBuffer::create()) {
+  DCHECK(m_frame);
+
   // The document URL needs to be added to the head of the list as that is
   // where the redirects originated.
   if (m_isClientRedirect)
     appendRedirect(m_frame->document()->url());
 }
 
-FrameLoader* DocumentLoader::frameLoader() const {
-  if (!m_frame)
-    return nullptr;
-  return &m_frame->loader();
+FrameLoader& DocumentLoader::frameLoader() const {
+  DCHECK(m_frame);
+  return m_frame->loader();
+}
+
+FrameLoaderClient& DocumentLoader::frameLoaderClient() const {
+  DCHECK(m_frame);
+  FrameLoaderClient* client = m_frame->client();
+  // LocalFrame clears its |m_client| only after detaching all DocumentLoaders
+  // (i.e. calls detachFromFrame() which clears |m_frame|) owned by the
+  // LocalFrame's FrameLoader. So, if |m_frame| is non nullptr, |client| is
+  // also non nullptr.
+  DCHECK(client);
+  return *client;
 }
 
 DocumentLoader::~DocumentLoader() {
   DCHECK(!m_frame);
   DCHECK(!m_mainResource);
   DCHECK(!m_applicationCacheHost);
   DCHECK_EQ(m_state, SentDidFinishLoad);
 }
 
 DEFINE_TRACE(DocumentLoader) {
@@ skipping 75 matching lines @@
     fetcher()->preloadStarted(resource);
   return resource;
 }
 
 void DocumentLoader::didRedirect(const KURL& oldURL, const KURL& newURL) {
   timing().addRedirect(oldURL, newURL);
 
   // If a redirection happens during a back/forward navigation, don't restore
   // any state from the old HistoryItem. There is a provisional history item for
   // back/forward navigation only. In the other case, clearing it is a no-op.
-  DCHECK(frameLoader());
-  frameLoader()->clearProvisionalHistoryItem();
+  frameLoader().clearProvisionalHistoryItem();
 }
 
 void DocumentLoader::dispatchLinkHeaderPreloads(
     ViewportDescriptionWrapper* viewport,
     LinkLoader::MediaPreloadPolicy mediaPolicy) {
   LinkLoader::loadLinksFromHeader(
       response().httpHeaderField(HTTPNames::Link), response().url(),
       m_frame->document(), NetworkHintsInterfaceImpl(),
       LinkLoader::OnlyLoadResources, mediaPolicy, viewport);
 }
 
 void DocumentLoader::didChangePerformanceTiming() {
-  if (frame() && frame()->isMainFrame() && m_state >= Committed) {
-    frameLoader()->client()->didChangePerformanceTiming();
+  if (m_frame && m_frame->isMainFrame() && m_state >= Committed) {
+    frameLoaderClient().didChangePerformanceTiming();
   }
 }
 
 void DocumentLoader::didObserveLoadingBehavior(
     WebLoadingBehaviorFlag behavior) {
-  if (frame() && frame()->isMainFrame()) {
+  if (m_frame && m_frame->isMainFrame()) {
     DCHECK_GE(m_state, Committed);
-    frameLoader()->client()->didObserveLoadingBehavior(behavior);
+    frameLoaderClient().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) {
     m_request.setHTTPMethod(HTTPNames::GET);
     m_request.setHTTPBody(nullptr);
   }
   clearRedirectChain();
   if (m_isClientRedirect)
     appendRedirect(oldURL);
   appendRedirect(newURL);
 }
 
 const KURL& DocumentLoader::urlForHistory() const {
   return unreachableURL().isEmpty() ? url() : unreachableURL();
 }
 
 void DocumentLoader::commitIfReady() {
   if (m_state < Committed) {
     m_state = Committed;
-    frameLoader()->commitProvisionalLoad();
+    frameLoader().commitProvisionalLoad();
   }
 }
 
 void DocumentLoader::notifyFinished(Resource* resource) {
   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();
 
   if (m_mainResource->resourceError().wasBlockedByResponse()) {
     InspectorInstrumentation::canceledAfterReceivedResourceResponse(
         m_frame, this, mainResourceIdentifier(), resource->response(),
         m_mainResource.get());
   }
 
-  frameLoader()->loadFailed(this, m_mainResource->resourceError());
+  frameLoader().loadFailed(this, m_mainResource->resourceError());
   clearMainResourceHandle();
 }
 
 void DocumentLoader::finishedLoading(double finishTime) {
   DCHECK(m_frame->loader().stateMachine()->creatingInitialEmptyDocument() ||
          !m_frame->page()->suspended() ||
          InspectorInstrumentation::isDebuggerPaused(m_frame));
 
   double responseEndTime = finishTime;
   if (!responseEndTime)
     responseEndTime = m_timeOfLastDataReceived;
   if (!responseEndTime)
     responseEndTime = monotonicallyIncreasingTime();
   timing().setResponseEnd(responseEndTime);
 
   commitIfReady();
-  if (!frameLoader())
+  if (!m_frame)
     return;
 
   if (!maybeCreateArchive()) {
     // If this is an empty document, it will not have actually been created yet.
     // Commit dummy data so that DocumentWriter::begin() gets called and creates
     // the Document.
     if (!m_writer)
       commitData(0, 0);
   }
 
@@ skipping 15 matching lines @@
         m_frame,
         UseCounter::
             ServiceWorkerRespondToNavigationRequestWithRedirectedResponse);
   }
 }
 
 bool DocumentLoader::redirectReceived(
     Resource* resource,
     const ResourceRequest& request,
     const ResourceResponse& redirectResponse) {
+  DCHECK(m_frame);
   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 false;
   }
-  if (!frameLoader()->shouldContinueForNavigationPolicy(
+  if (!frameLoader().shouldContinueForNavigationPolicy(
           m_request, SubstituteData(), this, CheckContentSecurityPolicy,
           m_navigationType, NavigationPolicyCurrentTab,
           replacesCurrentHistoryItem(), isClientRedirect(), nullptr)) {
     m_fetcher->stopFetching();
     return false;
   }
 
   DCHECK(timing().fetchStart());
   appendRedirect(requestURL);
   didRedirect(redirectResponse.url(), requestURL);
-  frameLoader()->client()->dispatchDidReceiveServerRedirectForProvisionalLoad();
+  frameLoaderClient().dispatchDidReceiveServerRedirectForProvisionalLoad();
 
   return true;
 }
 
 static bool canShowMIMEType(const String& mimeType, LocalFrame* frame) {
   if (MIMETypeRegistry::isSupportedMIMEType(mimeType))
     return true;
   PluginData* pluginData = frame->pluginData();
   return !mimeType.isEmpty() && pluginData &&
          pluginData->supportsMimeType(mimeType);
@@ skipping 46 matching lines @@
 
   return;
 }
 
 void DocumentLoader::responseReceived(
     Resource* resource,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK_EQ(m_mainResource, resource);
   DCHECK(!handle);
-  DCHECK(frame());
+  DCHECK(m_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();
   m_contentSecurityPolicy->setOverrideURLForSelf(response.url());
   m_contentSecurityPolicy->didReceiveHeaders(
       ContentSecurityPolicyResponseHeaders(response));
   if (!m_contentSecurityPolicy->allowAncestors(m_frame, response.url())) {
     cancelLoadAfterCSPDenied(response);
     return;
   }
 
   if (RuntimeEnabledFeatures::embedderCSPEnforcementEnabled() &&
-      !frameLoader()->requiredCSP().isEmpty()) {
+      !frameLoader().requiredCSP().isEmpty()) {
     SecurityOrigin* parentSecurityOrigin =
-        frame()->tree().parent()->securityContext()->getSecurityOrigin();
+        m_frame->tree().parent()->securityContext()->getSecurityOrigin();
     if (ContentSecurityPolicy::shouldEnforceEmbeddersPolicy(
             response, parentSecurityOrigin)) {
       m_contentSecurityPolicy->addPolicyFromHeaderValue(
-          frameLoader()->requiredCSP(), ContentSecurityPolicyHeaderTypeEnforce,
+          frameLoader().requiredCSP(), ContentSecurityPolicyHeaderTypeEnforce,
           ContentSecurityPolicyHeaderSourceHTTP);
     } else {
       ContentSecurityPolicy* embeddingCSP = ContentSecurityPolicy::create();
       embeddingCSP->addPolicyFromHeaderValue(
-          frameLoader()->requiredCSP(), ContentSecurityPolicyHeaderTypeEnforce,
+          frameLoader().requiredCSP(), ContentSecurityPolicyHeaderTypeEnforce,
           ContentSecurityPolicyHeaderSourceHTTP);
       if (!embeddingCSP->subsumes(*m_contentSecurityPolicy)) {
         String message = "Refused to display '" +
                          response.url().elidedString() +
                          "' because it has not opted-into the following policy "
                          "required by its embedder: '" +
-                         frameLoader()->requiredCSP() + "'.";
+                         frameLoader().requiredCSP() + "'.";
         ConsoleMessage* consoleMessage = ConsoleMessage::createForRequest(
             SecurityMessageSource, ErrorMessageLevel, message, response.url(),
             mainResourceIdentifier());
-        frame()->document()->addConsoleMessage(consoleMessage);
+        m_frame->document()->addConsoleMessage(consoleMessage);
         cancelLoadAfterCSPDenied(response);
         return;
       }
     }
   }
 
   DCHECK(!m_frame->page()->suspended());
 
   m_response = response;
 
@@ skipping 102 matching lines @@
   m_dataBuffer->clear();
 }
 
 void DocumentLoader::processData(const char* data, size_t length) {
   m_applicationCacheHost->mainResourceDataReceived(data, length);
   m_timeOfLastDataReceived = monotonicallyIncreasingTime();
 
   if (isArchiveMIMEType(response().mimeType()))
     return;
   commitIfReady();
-  if (!frameLoader())
+  if (!m_frame)
     return;
   commitData(data, length);
 
   // If we are sending data to MediaDocument, we should stop here and cancel the
   // request.
   if (m_frame && m_frame->document()->isMediaDocument())
     m_fetcher->stopFetching();
 }
 
 void DocumentLoader::clearRedirectChain() {
   m_redirectChain.clear();
 }
 
 void DocumentLoader::appendRedirect(const KURL& url) {
   m_redirectChain.push_back(url);
 }
 
 void DocumentLoader::detachFromFrame() {
   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 (frameLoader() && !sentDidFinishLoad())
-    frameLoader()->loadFailed(this, ResourceError::cancelledError(url()));
+  if (m_frame && !sentDidFinishLoad())
+    frameLoader().loadFailed(this, ResourceError::cancelledError(url()));
 
   // 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;
 
   m_fetcher->clearContext();
   m_applicationCacheHost->detachFromDocumentLoader();
   m_applicationCacheHost.clear();
   WeakIdentifierMap<DocumentLoader>::notifyObjectDestroyed(this);
@@ skipping 40 matching lines @@
 
 bool DocumentLoader::maybeLoadEmpty() {
   bool shouldLoadEmpty = !m_substituteData.isValid() &&
                          (m_request.url().isEmpty() ||
                           SchemeRegistry::shouldLoadURLSchemeAsEmptyDocument(
                               m_request.url().protocol()));
   if (!shouldLoadEmpty)
     return false;
 
   if (m_request.url().isEmpty() &&
-      !frameLoader()->stateMachine()->creatingInitialEmptyDocument())
+      !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();
   DCHECK(!m_mainResource);
@@ skipping 95 matching lines @@
                              m_writer ? m_writer->encoding() : emptyAtom, true,
                              ForceSynchronousParsing);
   if (!source.isNull())
     m_writer->appendReplacingData(source);
   endWriting();
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 }  // namespace blink