Revert of Remove ResourceFetcher's access to a real FetchContext at frame detach time

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 59 matching lines @@
 }
 
 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);
-    return frame;
+        return m_documentLoader->frame();
+    if (m_document && m_document->importsController())
+        return m_document->importsController()->master()->frame();
+    return 0;
 }
 
 void FrameFetchContext::addAdditionalRequestHeaders(ResourceRequest& request, FetchResourceType type)
 {
+    if (!frame())
+        return;
+
     bool isMainResource = type == FetchMainResource;
     if (!isMainResource) {
         String outgoingOrigin;
         if (!request.didSetHTTPReferrer()) {
             outgoingOrigin = m_document->outgoingOrigin();
             request.setHTTPReferrer(SecurityPolicy::generateReferrer(m_document->referrerPolicy(), request.url(), m_document->outgoingReferrer()));
         } else {
             RELEASE_ASSERT(SecurityPolicy::generateReferrer(request.referrerPolicy(), request.url(), request.httpReferrer()).referrer == request.httpReferrer());
             outgoingOrigin = SecurityOrigin::createFromString(request.httpReferrer())->toString();
         }
 
         request.addHTTPOriginIfNeeded(AtomicString(outgoingOrigin));
     }
 
     if (m_document)
         request.setOriginatesFromReservedIPRange(m_document->isHostedInReservedIPRange());
 
     // The remaining modifications are only necessary for HTTP and HTTPS.
     if (!request.url().isEmpty() && !request.url().protocolIsInHTTPFamily())
         return;
 
     frame()->loader().applyUserAgent(request);
 }
 
 void FrameFetchContext::setFirstPartyForCookies(ResourceRequest& request)
 {
+    if (!frame())
+        return;
+
     if (frame()->tree().top()->isLocalFrame())
         request.setFirstPartyForCookies(toLocalFrame(frame()->tree().top())->document()->firstPartyForCookies());
 }
 
 CachePolicy FrameFetchContext::cachePolicy() const
 {
+    if (!frame())
+        return CachePolicyVerify;
+
     if (m_document && m_document->loadEventFinished())
         return CachePolicyVerify;
 
     FrameLoadType loadType = frame()->loader().loadType();
     if (loadType == FrameLoadTypeReloadFromOrigin)
         return CachePolicyReload;
 
     Frame* parentFrame = frame()->tree().parent();
     if (parentFrame && parentFrame->isLocalFrame()) {
         CachePolicy parentCachePolicy = toLocalFrame(parentFrame)->document()->fetcher()->context().cachePolicy();
@@ skipping 18 matching lines @@
         return ReloadIgnoringCacheData;
     if (policy == CachePolicyReload)
         return ReloadBypassingCache;
     if (policy == CachePolicyHistoryBuffer)
         return ReturnCacheDataElseLoad;
     return UseProtocolCachePolicy;
 }
 
 ResourceRequestCachePolicy FrameFetchContext::resourceRequestCachePolicy(const ResourceRequest& request, Resource::Type type) const
 {
+    if (!frame())
+        return UseProtocolCachePolicy;
+
     if (type == Resource::MainResource) {
         FrameLoadType frameLoadType = frame()->loader().loadType();
         if (request.httpMethod() == "POST" && frameLoadType == FrameLoadTypeBackForward)
             return ReturnCacheDataDontLoad;
         if (!frame()->host()->overrideEncoding().isEmpty() || frameLoadType == FrameLoadTypeBackForward)
             return ReturnCacheDataElseLoad;
         if (frameLoadType == FrameLoadTypeReloadFromOrigin)
             return ReloadBypassingCache;
         if (frameLoadType == FrameLoadTypeReload || frameLoadType == FrameLoadTypeSame || request.isConditional() || request.httpMethod() == "POST")
             return ReloadIgnoringCacheData;
@@ skipping 24 matching lines @@
 // |loader| can be null if the resource is loaded from imported document.
 // This means inspector, which uses DocumentLoader as an grouping entity,
 // cannot see imported documents.
 inline DocumentLoader* FrameFetchContext::ensureLoaderForNotifications()
 {
     return m_documentLoader ? m_documentLoader : frame()->loader().documentLoader();
 }
 
 void FrameFetchContext::dispatchDidChangeResourcePriority(unsigned long identifier, ResourceLoadPriority loadPriority, int intraPriorityValue)
 {
+    if (!frame())
+        return;
+
     frame()->loader().client()->dispatchDidChangeResourcePriority(identifier, loadPriority, intraPriorityValue);
 }
 
 void FrameFetchContext::dispatchWillSendRequest(unsigned long identifier, ResourceRequest& request, const ResourceResponse& redirectResponse, const FetchInitiatorInfo& initiatorInfo)
 {
+    if (!frame())
+        return;
+
     frame()->loader().applyUserAgent(request);
     frame()->loader().client()->dispatchWillSendRequest(m_documentLoader, identifier, request, redirectResponse);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceSendRequest", "data", InspectorSendRequestEvent::data(identifier, frame(), request));
     InspectorInstrumentation::willSendRequest(frame(), identifier, ensureLoaderForNotifications(), request, redirectResponse, initiatorInfo);
 }
 
 void FrameFetchContext::dispatchDidLoadResourceFromMemoryCache(const ResourceRequest& request, const ResourceResponse& response)
 {
+    if (!frame())
+        return;
+
     frame()->loader().client()->dispatchDidLoadResourceFromMemoryCache(request, response);
 }
 
 void FrameFetchContext::dispatchDidReceiveResponse(unsigned long identifier, const ResourceResponse& response, ResourceLoader* resourceLoader)
 {
+    if (!frame())
+        return;
+
     MixedContentChecker::checkMixedPrivatePublic(frame(), response.remoteIPAddress());
     LinkLoader::loadLinkFromHeader(response.httpHeaderField("Link"), frame()->document());
     if (m_documentLoader == frame()->loader().provisionalDocumentLoader())
         handleAcceptClientHintsHeader(response.httpHeaderField("accept-ch"), frame());
 
     frame()->loader().progress().incrementProgress(identifier, response);
     frame()->loader().client()->dispatchDidReceiveResponse(m_documentLoader, identifier, response);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceReceiveResponse", "data", InspectorReceiveResponseEvent::data(identifier, frame(), response));
     DocumentLoader* documentLoader = ensureLoaderForNotifications();
     InspectorInstrumentation::didReceiveResourceResponse(frame(), identifier, documentLoader, response, resourceLoader);
     // It is essential that inspector gets resource response BEFORE console.
     frame()->console().reportResourceResponseReceived(documentLoader, identifier, response);
 }
 
 void FrameFetchContext::dispatchDidReceiveData(unsigned long identifier, const char* data, int dataLength, int encodedDataLength)
 {
+    if (!frame())
+        return;
+
     frame()->loader().progress().incrementProgress(identifier, dataLength);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceReceivedData", "data", InspectorReceiveDataEvent::data(identifier, frame(), encodedDataLength));
     InspectorInstrumentation::didReceiveData(frame(), identifier, data, dataLength, encodedDataLength);
 }
 
 void FrameFetchContext::dispatchDidDownloadData(unsigned long identifier, int dataLength, int encodedDataLength)
 {
+    if (!frame())
+        return;
+
     frame()->loader().progress().incrementProgress(identifier, dataLength);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceReceivedData", "data", InspectorReceiveDataEvent::data(identifier, frame(), encodedDataLength));
     InspectorInstrumentation::didReceiveData(frame(), identifier, 0, dataLength, encodedDataLength);
 }
 
 void FrameFetchContext::dispatchDidFinishLoading(unsigned long identifier, double finishTime, int64_t encodedDataLength)
 {
+    if (!frame())
+        return;
+
     frame()->loader().progress().completeProgress(identifier);
     frame()->loader().client()->dispatchDidFinishLoading(m_documentLoader, identifier);
 
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceFinish", "data", InspectorResourceFinishEvent::data(identifier, finishTime, false));
     InspectorInstrumentation::didFinishLoading(frame(), identifier, finishTime, encodedDataLength);
 }
 
 void FrameFetchContext::dispatchDidFail(unsigned long identifier, const ResourceError& error, bool isInternalRequest)
 {
+    if (!frame())
+        return;
+
     frame()->loader().progress().completeProgress(identifier);
     frame()->loader().client()->dispatchDidFinishLoading(m_documentLoader, identifier);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceFinish", "data", InspectorResourceFinishEvent::data(identifier, 0, true));
     InspectorInstrumentation::didFailLoading(frame(), identifier, error);
     // Notification to FrameConsole should come AFTER InspectorInstrumentation call, DevTools front-end relies on this.
     if (!isInternalRequest)
         frame()->console().didFailLoading(identifier, error);
 }
 
 void FrameFetchContext::sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse& response, int dataLength)
 {
+    if (!frame())
+        return;
+
     InspectorInstrumentation::markResourceAsCached(frame(), identifier);
     if (!response.isNull())
         dispatchDidReceiveResponse(identifier, response);
 
     if (dataLength > 0)
         dispatchDidReceiveData(identifier, 0, dataLength, 0);
 
     dispatchDidFinishLoading(identifier, 0, 0);
 }
 
 bool FrameFetchContext::shouldLoadNewResource(Resource::Type type) const
 {
+    if (!frame())
+        return false;
     if (!m_documentLoader)
         return true;
     if (type == Resource::MainResource)
         return m_documentLoader == frame()->loader().provisionalDocumentLoader();
     return m_documentLoader == frame()->loader().documentLoader();
 }
 
 void FrameFetchContext::dispatchWillRequestResource(FetchRequest* request)
 {
-    frame()->loader().client()->dispatchWillRequestResource(request);
+    if (frame())
+        frame()->loader().client()->dispatchWillRequestResource(request);
 }
 
 void FrameFetchContext::willStartLoadingResource(ResourceRequest& request)
 {
     if (m_documentLoader)
         m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
 }
 
 void FrameFetchContext::didLoadResource()
 {
-    frame()->loader().checkCompleted();
+    if (frame())
+        frame()->loader().checkCompleted();
 }
 
 void FrameFetchContext::addResourceTiming(ResourceTimingInfo* info, bool isMainResource)
 {
     Document* initiatorDocument = m_document && isMainResource ? m_document->parentDocument() : m_document.get();
-    if (!initiatorDocument || !initiatorDocument->domWindow())
+    if (!frame() || !initiatorDocument || !initiatorDocument->domWindow())
         return;
     DOMWindowPerformance::performance(*initiatorDocument->domWindow())->addResourceTiming(*info, initiatorDocument);
 }
 
 bool FrameFetchContext::allowImage(bool imagesEnabled, const KURL& url) const
 {
-    return frame()->loader().client()->allowImage(imagesEnabled, url);
+    return !frame() || frame()->loader().client()->allowImage(imagesEnabled, url);
 }
 
 void FrameFetchContext::printAccessDeniedMessage(const KURL& url) const
 {
     if (url.isNull())
         return;
 
     String message;
     if (!m_document || m_document->url().isNull())
         message = "Unsafe attempt to load URL " + url.elidedString() + '.';
     else
         message = "Unsafe attempt to load URL " + url.elidedString() + " from frame with URL " + m_document->url().elidedString() + ". Domains, protocols and ports must match.\n";
 
     frame()->document()->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, message));
 }
 
 bool FrameFetchContext::canRequest(Resource::Type type, const ResourceRequest& resourceRequest, const KURL& url, const ResourceLoaderOptions& options, bool forPreload, FetchRequest::OriginRestriction originRestriction) const
 {
+    // FIXME: CachingCorrectnessTest needs us to permit loads when there isn't a frame.
+    // Once CachingCorrectnessTest can create a FetchContext mock to meet its needs (without
+    // also needing to mock Document, DocumentLoader, and Frame), this should either be reverted to
+    // return false or removed entirely.
+    if (!frame())
+        return true;
+
     SecurityOrigin* securityOrigin = options.securityOrigin.get();
     if (!securityOrigin && m_document)
         securityOrigin = m_document->securityOrigin();
 
     if (originRestriction != FetchRequest::NoOriginRestriction && securityOrigin && !securityOrigin->canDisplay(url)) {
         if (!forPreload)
             FrameLoader::reportLocalLoadFailed(frame(), url.elidedString());
         WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource URL was not allowed by SecurityOrigin::canDisplay");
         return false;
     }
@@ skipping 139 matching lines @@
             effectiveFrame = toLocalFrame(parentFrame);
     }
 
     MixedContentChecker::ReportingStatus mixedContentReporting = forPreload ?
         MixedContentChecker::SuppressReport : MixedContentChecker::SendReport;
     return !MixedContentChecker::shouldBlockFetch(effectiveFrame, resourceRequest, url, mixedContentReporting);
 }
 
 bool FrameFetchContext::isControlledByServiceWorker() const
 {
+    if (!frame())
+        return false;
     ASSERT(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
 {
+    if (!frame())
+        return -1;
     ASSERT(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
 {
-    return frame()->isMainFrame();
+    return frame() && frame()->isMainFrame();
 }
 
 bool FrameFetchContext::hasSubstituteData() const
 {
     return m_documentLoader && m_documentLoader->substituteData().isValid();
 }
 
 bool FrameFetchContext::defersLoading() const
 {
-    return frame()->page()->defersLoading();
+    return frame() && frame()->page()->defersLoading();
 }
 
 bool FrameFetchContext::isLoadComplete() const
 {
     return m_document && m_document->loadEventFinished();
 }
 
 bool FrameFetchContext::pageDismissalEventBeingDispatched() const
 {
     return m_document && m_document->pageDismissalEventBeingDispatched() != Document::NoDismissal;
 }
 
 bool FrameFetchContext::updateTimingInfoForIFrameNavigation(ResourceTimingInfo* info)
 {
     // <iframe>s should report the initial navigation requested by the parent document, but not subsequent navigations.
     // FIXME: Resource timing is broken when the parent is a remote frame.
-    if (!frame()->deprecatedLocalOwner() || frame()->deprecatedLocalOwner()->loadedNonEmptyDocument())
+    if (!frame() || !frame()->deprecatedLocalOwner() || frame()->deprecatedLocalOwner()->loadedNonEmptyDocument())
         return false;
     info->setInitiatorType(frame()->deprecatedLocalOwner()->localName());
     frame()->deprecatedLocalOwner()->didLoadNonEmptyDocument();
     return true;
 }
 
 void FrameFetchContext::sendImagePing(const KURL& url)
 {
-    PingLoader::loadImage(frame(), url);
+    if (frame())
+        PingLoader::loadImage(frame(), url);
 }
 
 void FrameFetchContext::addConsoleMessage(const String& message) const
 {
-    if (frame()->document())
+    if (frame() && frame()->document())
         frame()->document()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 }
 
 SecurityOrigin* FrameFetchContext::securityOrigin() const
 {
     return m_document ? m_document->securityOrigin() : nullptr;
 }
 
 String FrameFetchContext::charset() const
 {
@@ skipping 30 matching lines @@
             url.setProtocol("https");
             if (url.port() == 80)
                 url.setPort(443);
             fetchRequest.mutableResourceRequest().setURL(url);
         }
     }
 }
 
 void FrameFetchContext::addClientHintsIfNecessary(FetchRequest& fetchRequest)
 {
-    if (!RuntimeEnabledFeatures::clientHintsEnabled() || !m_document)
+    if (!frame() || !RuntimeEnabledFeatures::clientHintsEnabled() || !m_document)
         return;
 
     if (frame()->shouldSendDPRHint())
         fetchRequest.mutableResourceRequest().addHTTPHeaderField("DPR", AtomicString(String::number(m_document->devicePixelRatio())));
 
     // FIXME: Send the RW hint based on the actual resource width, when we have it.
     if (frame()->shouldSendRWHint() && frame()->view())
         fetchRequest.mutableResourceRequest().addHTTPHeaderField("RW", AtomicString(String::number(frame()->view()->viewportWidth())));
 }
 
 void FrameFetchContext::addCSPHeaderIfNecessary(Resource::Type type, FetchRequest& fetchRequest)
 {
-    if (!m_document)
+    if (!document() || !frame())
         return;
 
-    const ContentSecurityPolicy* csp = m_document->contentSecurityPolicy();
+    const ContentSecurityPolicy* csp = document()->contentSecurityPolicy();
     if (csp->shouldSendCSPHeader(type))
         fetchRequest.mutableResourceRequest().addHTTPHeaderField("CSP", "active");
 }
 
 DEFINE_TRACE(FrameFetchContext)
 {
     visitor->trace(m_document);
     FetchContext::trace(visitor);
 }
 
 } // namespace blink