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..97fddee1eedf1c24688bf5ac98d75139bc7a9555 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);
@@ -69,7 +72,7 @@ DEFINE_TRACE(ResourceLoader) {
   visitor->trace(m_resource);
 }
 
-void ResourceLoader::start(const ResourceRequest& request,
+void ResourceLoader::start(const ResourceRequest& originalRequest,
                            WebTaskRunner* loadingTaskRunner,
                            bool defersLoading) {
   DCHECK(!m_loader);
@@ -79,6 +82,13 @@ void ResourceLoader::start(const ResourceRequest& request,
     return;
   }
 
+  // This is only for overriding cache policy if cache-aware loading is
+  // activated.
+  ResourceRequest request(originalRequest);

[kinuko, 2016/11/08 12:21:55]

Always making an extra copy here seems a bit unfortunate.  Wondering if this
method should just take the request by value?  Given that it's activated only
for async if WrappedResourceRequest supported overriding fields it might have
been useful?

[Shao-Chuan Lee, 2016/11/09 03:48:01]

I thought of using pointers but ResourceRequest has to be allocated on stack.
Now I moved the copy into a separate if block below to avoid copies in most
cases.

+
+  if (m_isCacheAwareLoadingActivated)
+    request.setCachePolicy(WebCachePolicy::ReturnCacheDataIfValid);
+
   m_loader = wrapUnique(Platform::current()->createURLLoader());
   DCHECK(m_loader);
   m_loader->setDefersLoading(defersLoading);
@@ -137,6 +147,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 +243,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 +295,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