Reload: propagate FrameLoadType to child frames

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 102 matching lines @@
     // are likely to be third party content.
     if (request.url().host() == document.getSecurityOrigin()->domain())
         return false;
 
     emitWarningForDocWriteScripts(request.url().getString(), document);
 
     // 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 bool isReload = loadType == FrameLoadTypeReload || loadType == FrameLoadTypeReloadBypassingCache || loadType == FrameLoadTypeReloadMainResource;
-    if (isReload) {
+    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
     // the flag will be conveyed to the browser process only once.
     document.loader()->didObserveLoadingBehavior(WebLoadingBehaviorFlag::WebLoadingBehaviorDocumentWriteBlock);
@@ skipping 77 matching lines @@
         CachePolicy parentCachePolicy = toLocalFrame(parentFrame)->document()->fetcher()->context().getCachePolicy();
         if (parentCachePolicy != CachePolicyVerify)
             return parentCachePolicy;
     }
 
     if (loadType == FrameLoadTypeReload)
         return CachePolicyRevalidate;
 
     if (m_documentLoader && m_documentLoader->request().getCachePolicy() == WebCachePolicy::ReturnCacheDataElseLoad)
         return CachePolicyHistoryBuffer;
+
+    // Returning CachePolicyVerify for FrameLoadTypeReloadMainResource is
+    // intentional.

[hiroshige, 2016/07/26 07:37:17]

Not blocking this CL, but do we have any documents/crbug/code locations that
explains the intention?

[Takashi Toyoshima, 2016/07/26 08:14:20]

How about public/web/WebFrameLoadType.h?
core/loader/FrameLoaderTypes.h points this header in the comment, and it
explains ReloadMainResource is equivalent to Standard for sub-resources.

I can add comment to point these headers, and probably it would be better to
split these fixes to separate CL? Changes in this file is not directly related
to the bug, but just cleanup sort of things.

     return CachePolicyVerify;
 }
 
 static WebCachePolicy memoryCachePolicyToResourceRequestCachePolicy(const CachePolicy policy)
 {
     if (policy == CachePolicyVerify)
         return WebCachePolicy::UseProtocolCachePolicy;
     if (policy == CachePolicyRevalidate)
         return WebCachePolicy::ValidatingCacheData;
     if (policy == CachePolicyReload)
@@ skipping 19 matching lines @@
             if (!f->isLocalFrame())
                 continue;
             frameLoadType = toLocalFrame(f)->loader().loadType();
             if (frameLoadType == FrameLoadTypeBackForward)
                 return WebCachePolicy::ReturnCacheDataElseLoad;
             if (frameLoadType == FrameLoadTypeReloadBypassingCache)
                 return WebCachePolicy::BypassingCache;
             if (frameLoadType == FrameLoadTypeReload)
                 return WebCachePolicy::ValidatingCacheData;
         }
+        // Returning UseProtocolCachePolicy for FrameLoadTypeReloadMainResource
+        // is intentional.

[hiroshige, 2016/07/26 07:37:17]

ditto.

         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
     // add significant delays before page content is displayed on the screen.
     if (type == Resource::Script && isMainFrame() && m_document && shouldDisallowFetchForMainFrameScript(request, defer, *m_document))
         return WebCachePolicy::ReturnCacheDataDontLoad;
 
     if (request.isConditional())
@@ skipping 538 matching lines @@
 }
 
 DEFINE_TRACE(FrameFetchContext)
 {
     visitor->trace(m_document);
     visitor->trace(m_documentLoader);
     FetchContext::trace(visitor);
 }
 
 } // namespace blink