Clean up around FrameFetchContext

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 185 matching lines @@
 FrameFetchContext::FrameFetchContext(DocumentLoader* loader, Document* document)
     : m_document(document), m_documentLoader(loader) {
   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();
+LocalFrame* FrameFetchContext::frameOfImportsController() const {
+  DCHECK(m_document);
+  HTMLImportsController* importsController = m_document->importsController();
+  DCHECK(importsController);
+  LocalFrame* frame = importsController->master()->frame();
   DCHECK(frame);
   return frame;
 }
+
+LocalFrame* FrameFetchContext::frame() const {
+  if (!m_documentLoader)
+    return frameOfImportsController();
+
+  LocalFrame* frame = m_documentLoader->frame();
+  DCHECK(frame);
+  return frame;
+}
 
 void FrameFetchContext::addAdditionalRequestHeaders(ResourceRequest& request,
                                                     FetchResourceType type) {
   bool isMainResource = type == FetchMainResource;
   if (!isMainResource) {
     if (!request.didSetHTTPReferrer()) {
       DCHECK(m_document);
       request.setHTTPReferrer(SecurityPolicy::generateReferrer(
           m_document->getReferrerPolicy(), request.url(),
           m_document->outgoingReferrer()));
@@ skipping 125 matching lines @@
     return memoryCachePolicyToResourceRequestCachePolicy(getCachePolicy());
   }
   return WebCachePolicy::UseProtocolCachePolicy;
 }
 
 // The |m_documentLoader| is null in the FrameFetchContext of an imported
 // document.
 // FIXME(http://crbug.com/274173): This means Inspector, which uses
 // DocumentLoader as a grouping entity, cannot see imported documents.
 inline DocumentLoader* FrameFetchContext::masterDocumentLoader() const {
-  return m_documentLoader ? m_documentLoader.get()
-                          : frame()->loader().documentLoader();
+  if (m_documentLoader)
+    return m_documentLoader.get();
+
+  return frameOfImportsController()->loader().documentLoader();
 }
 
 void FrameFetchContext::dispatchDidChangeResourcePriority(
     unsigned long identifier,
     ResourceLoadPriority loadPriority,
     int intraPriorityValue) {
   TRACE_EVENT1(
       "devtools.timeline", "ResourceChangePriority", "data",
       InspectorChangeResourcePriorityEvent::data(identifier, loadPriority));
   InspectorInstrumentation::didChangeResourcePriority(frame(), identifier,
@@ skipping 112 matching lines @@
 
   if (resource->encodedSize() > 0)
     dispatchDidReceiveData(identifier, 0, resource->encodedSize(), 0);
 
   dispatchDidFinishLoading(identifier, 0, 0);
 }
 
 bool FrameFetchContext::shouldLoadNewResource(Resource::Type type) const {
   if (!m_documentLoader)
     return true;
+
+  FrameLoader& loader = m_documentLoader->frame()->loader();
   if (type == Resource::MainResource)
-    return m_documentLoader == frame()->loader().provisionalDocumentLoader();
-  return m_documentLoader == frame()->loader().documentLoader();
+    return m_documentLoader == loader.provisionalDocumentLoader();
+  return m_documentLoader == loader.documentLoader();
 }
 
 static std::unique_ptr<TracedValue>
 loadResourceTraceData(unsigned long identifier, const KURL& url, int priority) {
   String requestId = IdentifiersFactory::requestId(identifier);
 
   std::unique_ptr<TracedValue> value = TracedValue::create();
   value->setString("requestId", requestId);
   value->setString("url", url.getString());
   value->setInteger("priority", priority);
@@ skipping 253 matching lines @@
   // explicitly return |false| here so that it is clear that the SW will be
   // bypassed. In particular, this is important for
   // ResourceFetcher::getCacheIdentifier(), which will return the SW's cache if
   // the context's isControlledByServiceWorker() returns |true|, and thus will
   // returned cached resources from the service worker. That would have the
   // effect of not bypassing the SW.
   if (getSecurityOrigin() && getSecurityOrigin()->hasSuborigin())
     return false;
 
   if (m_documentLoader) {
-    return frame()->loader().client()->isControlledByServiceWorker(
-        *m_documentLoader);
+    return m_documentLoader->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 {
   DCHECK(m_documentLoader || frame()->loader().documentLoader());
-  if (m_documentLoader)
-    return frame()->loader().client()->serviceWorkerID(*m_documentLoader);
+  if (m_documentLoader) {
+    return m_documentLoader->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();
 }
@@ skipping 174 matching lines @@
     WebURLRequest::FrameType frameType,
     WebURLRequest::RequestContext requestContext,
     Resource* resource,
     LinkLoader::CanLoadResources resourceLoadingPolicy) {
   TRACE_EVENT1(
       "devtools.timeline", "ResourceReceiveResponse", "data",
       InspectorReceiveResponseEvent::data(identifier, frame(), response));
   MixedContentChecker::checkMixedPrivatePublic(frame(),
                                                response.remoteIPAddress());
   if (m_documentLoader &&
-      m_documentLoader == frame()->loader().provisionalDocumentLoader()) {
+      m_documentLoader ==
+          m_documentLoader->frame()->loader().provisionalDocumentLoader()) {
     ResourceFetcher* fetcher = nullptr;
     if (frame()->document())
       fetcher = frame()->document()->fetcher();
     m_documentLoader->clientHintsPreferences()
         .updateFromAcceptClientHintsHeader(
             response.httpHeaderField(HTTPNames::Accept_CH), fetcher);
     // When response is received with a provisional docloader, the resource
     // haven't committed yet, and we cannot load resources, only preconnect.
     resourceLoadingPolicy = LinkLoader::DoNotLoadResources;
   }
@@ skipping 17 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink