Cache-aware Resource loading

third_party/WebKit/Source/core/fetch/ResourceLoader.cpp

Index: third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
diff --git a/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp b/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
index c9e4d3c4ad80eeea93dee39b13d3bad95bea8aac..2f7e6585361f24ebbbb43481175222b887dd7148 100644
--- a/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
+++ b/third_party/WebKit/Source/core/fetch/ResourceLoader.cpp
@@ -37,6 +37,7 @@
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/network/ResourceError.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebURLRequest.h"
@@ -54,7 +55,9 @@ ResourceLoader* ResourceLoader::create(ResourceFetcher* fetcher,
 }
 
 ResourceLoader::ResourceLoader(ResourceFetcher* fetcher, Resource* resource)
-    : m_fetcher(fetcher), m_resource(resource) {
+    : m_fetcher(fetcher),
+      m_resource(resource),
+      m_isCacheAwareLoadingActivated(false) {
   DCHECK(m_resource);
   DCHECK(m_fetcher);
   m_resource->setLoader(this);
@@ -84,10 +87,18 @@ void ResourceLoader::start(const ResourceRequest& request,
   m_loader->setDefersLoading(defersLoading);
   m_loader->setLoadingTaskRunner(loadingTaskRunner);
 
-  if (m_resource->options().synchronousPolicy == RequestSynchronously)
+  if (m_resource->options().synchronousPolicy == RequestSynchronously) {

[kinuko, 2016/11/09 04:34:24]

nit: maybe should we assert m_isCacheAwareLoadingActivated is false here?

[Shao-Chuan Lee, 2016/11/09 06:54:32]

Now the CAL check is moved before this and returns early, then we don't have to
assert here. CAL is only activated with RequestAsynchronously. The diff is also
cleaner now.

     requestSynchronously(request);
-  else
+  } else if (m_isCacheAwareLoadingActivated) {
+    // Override cache policy for cache-aware loading. If this request fails, a
+    // reload with original request will be triggered in didFail().
+    ResourceRequest cacheAwareRequest(request);
+    cacheAwareRequest.setCachePolicy(WebCachePolicy::ReturnCacheDataIfValid);
+    m_loader->loadAsynchronously(WrappedResourceRequest(cacheAwareRequest),
+                                 this);

[kinuko, 2016/11/09 04:34:24]

nit: we can remove else's from this if-elseif-else by returning early in each
block

+  } else {
     m_loader->loadAsynchronously(WrappedResourceRequest(request), this);
+  }
 }
 
 void ResourceLoader::restart(const ResourceRequest& request,
@@ -137,6 +148,13 @@ bool ResourceLoader::willFollowRedirect(
   DCHECK(!passedNewRequest.isNull());
   DCHECK(!passedRedirectResponse.isNull());
 
+  if (m_isCacheAwareLoadingActivated) {
+    // Fail as cache miss if cached response is a redirect.
+    didFail(
+        ResourceError::cacheMissError(m_resource->lastResourceRequest().url()));
+    return false;
+  }
+
   ResourceRequest& newRequest(passedNewRequest.toMutableResourceRequest());
   const ResourceResponse& redirectResponse(
       passedRedirectResponse.toResourceResponse());
@@ -226,6 +244,15 @@ void ResourceLoader::didFail(WebURLLoader*, const WebURLError& error) {
 }
 
 void ResourceLoader::didFail(const ResourceError& error) {
+  if (m_isCacheAwareLoadingActivated && error.isCacheMiss()) {
+    m_resource->willReloadAfterDiskCacheMiss();
+    m_isCacheAwareLoadingActivated = false;
+    restart(m_resource->resourceRequest(),
+            m_fetcher->context().loadingTaskRunner(),
+            m_fetcher->context().defersLoading());
+    return;
+  }
+
   m_loader.reset();
   m_fetcher->didFailLoading(m_resource.get(), error);
 }
@@ -269,4 +296,27 @@ void ResourceLoader::requestSynchronously(const ResourceRequest& request) {
   didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
+void ResourceLoader::activateCacheAwareLoadingIfNeeded(
+    const ResourceRequest& request) {
+  DCHECK(!m_isCacheAwareLoadingActivated);
+
+  if (m_resource->options().cacheAwareLoadingEnabled !=
+      IsCacheAwareLoadingEnabled)
+    return;
+
+  // Synchronous requests are not supported.
+  if (m_resource->options().synchronousPolicy == RequestSynchronously)
+    return;
+
+  // Don't activate on Resource revalidation.
+  if (m_resource->isCacheValidator())
+    return;
+
+  // Don't activate if cache policy is explicitly set.
+  if (request.getCachePolicy() != WebCachePolicy::UseProtocolCachePolicy)
+    return;
+
+  m_isCacheAwareLoadingActivated = true;
+}
+
 }  // namespace blink