Move loadType() to DocumentLoader

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 148 matching lines @@
     return false;
 
   emitWarningForDocWriteScripts(request.url().getString(), document);
   request.setHTTPHeaderField("Intervention",
                              "<https://www.chromestatus.com/feature/"
                              "5718547946799104>; level=\"warning\"");
 
   // Do not block scripts if it is a page reload. This is to enable pages to
   // recover if blocking of a script is leading to a page break and the user
   // reloads the page.
-  const FrameLoadType loadType = document.frame()->loader().loadType();
+  const FrameLoadType loadType = document.loader()->loadType();
   if (isReloadLoadType(loadType)) {
     // Recording this metric since an increase in number of reloads for pages
     // where a script was blocked could be indicative of a page break.
     document.loader()->didObserveLoadingBehavior(
         WebLoadingBehaviorFlag::WebLoadingBehaviorDocumentWriteBlockReload);
     return false;
   }
 
   // Add the metadata that this page has scripts inserted via document.write
   // that are eligible for blocking. Note that if there are multiple scripts
@@ skipping 72 matching lines @@
 
   if (m_document) {
     request.setExternalRequestStateFromRequestorAddressSpace(
         m_document->addressSpace());
   }
 
   // The remaining modifications are only necessary for HTTP and HTTPS.
   if (!request.url().isEmpty() && !request.url().protocolIsInHTTPFamily())
     return;
 
-  if (frame()->loader().loadType() == FrameLoadTypeReload)
+  if (masterDocumentLoader()->loadType() == FrameLoadTypeReload)
     request.clearHTTPHeaderField("Save-Data");
 
   if (frame()->settings() && frame()->settings()->getDataSaverEnabled())
     request.setHTTPHeaderField("Save-Data", "on");
 }
 
 CachePolicy FrameFetchContext::getCachePolicy() const {
   if (m_document && m_document->loadEventFinished())
     return CachePolicyVerify;
 
-  FrameLoadType loadType = frame()->loader().loadType();
+  FrameLoadType loadType = masterDocumentLoader()->loadType();
   if (loadType == FrameLoadTypeReloadBypassingCache)
     return CachePolicyReload;
 
   Frame* parentFrame = frame()->tree().parent();
   if (parentFrame && parentFrame->isLocalFrame()) {
     CachePolicy parentCachePolicy = toLocalFrame(parentFrame)
                                         ->document()
                                         ->fetcher()
                                         ->context()
                                         .getCachePolicy();
@@ skipping 21 matching lines @@
     return WebCachePolicy::UseProtocolCachePolicy;
   if (policy == CachePolicyRevalidate)
     return WebCachePolicy::ValidatingCacheData;
   if (policy == CachePolicyReload)
     return WebCachePolicy::BypassingCache;
   if (policy == CachePolicyHistoryBuffer)
     return WebCachePolicy::ReturnCacheDataElseLoad;
   return WebCachePolicy::UseProtocolCachePolicy;
 }
 
+static WebCachePolicy frameLoadTypeToWebCachePolicy(FrameLoadType type) {
+  if (type == FrameLoadTypeBackForward)
+    return WebCachePolicy::ReturnCacheDataElseLoad;
+  if (type == FrameLoadTypeReloadBypassingCache)
+    return WebCachePolicy::BypassingCache;
+  if (type == FrameLoadTypeReload)
+    return WebCachePolicy::ValidatingCacheData;
+  return WebCachePolicy::UseProtocolCachePolicy;
+}
+
 WebCachePolicy FrameFetchContext::resourceRequestCachePolicy(
     ResourceRequest& request,
     Resource::Type type,
     FetchRequest::DeferOption defer) const {
   DCHECK(frame());
   if (type == Resource::MainResource) {
-    FrameLoadType frameLoadType = frame()->loader().loadType();
+    FrameLoadType frameLoadType = masterDocumentLoader()->loadType();
     if (request.httpMethod() == "POST" &&
         frameLoadType == FrameLoadTypeBackForward)
       return WebCachePolicy::ReturnCacheDataDontLoad;
     if (frameLoadType == FrameLoadTypeReloadMainResource ||
         request.isConditional() || request.httpMethod() == "POST")
       return WebCachePolicy::ValidatingCacheData;
 
-    for (Frame* f = frame(); f; f = f->tree().parent()) {
+    WebCachePolicy policy = frameLoadTypeToWebCachePolicy(frameLoadType);
+    if (policy != WebCachePolicy::UseProtocolCachePolicy)
+      return policy;
+
+    for (Frame* f = frame()->tree().parent(); f; f = f->tree().parent()) {
       if (!f->isLocalFrame())
         continue;
-      FrameLoadType parentFrameLoadType = toLocalFrame(f)->loader().loadType();
-      if (parentFrameLoadType == FrameLoadTypeBackForward)
-        return WebCachePolicy::ReturnCacheDataElseLoad;
-      if (parentFrameLoadType == FrameLoadTypeReloadBypassingCache)
-        return WebCachePolicy::BypassingCache;
-      if (parentFrameLoadType == FrameLoadTypeReload)
-        return WebCachePolicy::ValidatingCacheData;
+      policy = frameLoadTypeToWebCachePolicy(
+          toLocalFrame(f)->loader().documentLoader()->loadType());
+      if (policy != WebCachePolicy::UseProtocolCachePolicy)
+        return policy;
     }
     // Returns UseProtocolCachePolicy for other cases, parent frames not having
     // special kinds of FrameLoadType as they are checked inside the for loop
     // above, or |frameLoadType| being FrameLoadTypeStandard. See
     // public/web/WebFrameLoadType.h to know how these load types work.
     return WebCachePolicy::UseProtocolCachePolicy;
   }
 
   // For users on slow connections, we want to avoid blocking the parser in
   // the main frame on script loads inserted via document.write, since it can
@@ skipping 511 matching lines @@
     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())
     return false;
   frame()->deprecatedLocalOwner()->didLoadNonEmptyDocument();
   // Do not report iframe navigation that restored from history, since its
   // location may have been changed after initial navigation.
-  if (frame()->loader().loadType() == FrameLoadTypeInitialHistoryLoad)
+  if (masterDocumentLoader()->loadType() == FrameLoadTypeInitialHistoryLoad)
     return false;
   info->setInitiatorType(frame()->deprecatedLocalOwner()->localName());
   return true;
 }
 
 void FrameFetchContext::sendImagePing(const KURL& url) {
   PingLoader::loadImage(frame(), url);
 }
 
 void FrameFetchContext::addConsoleMessage(const String& message,
@@ skipping 176 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink