Cache-aware Resource loading

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

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 19 matching lines @@
 #include "core/fetch/ResourceLoader.h"
 
 #include "core/fetch/CSSStyleSheetResource.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "platform/SharedBuffer.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #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"
 #include "public/platform/WebURLResponse.h"
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 ResourceLoader* ResourceLoader::create(ResourceFetcher* fetcher,
                                        Resource* resource) {
   return new ResourceLoader(fetcher, resource);
 }
 
 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);
 }
 
 ResourceLoader::~ResourceLoader() {
   DCHECK(!m_loader);
 }
 
 DEFINE_TRACE(ResourceLoader) {
   visitor->trace(m_fetcher);
   visitor->trace(m_resource);
 }
 
-void ResourceLoader::start(const ResourceRequest& request,
+void ResourceLoader::start(const ResourceRequest& originalRequest,
                            WebTaskRunner* loadingTaskRunner,
                            bool defersLoading) {
   DCHECK(!m_loader);
   if (m_resource->options().synchronousPolicy == RequestSynchronously &&
       defersLoading) {
     cancel();
     return;
   }
 
+  // This is only for overriding cache policy if cache-aware loading is
+  // activated.
+  ResourceRequest request(originalRequest);
+
+  if (m_isCacheAwareLoadingActivated) {
+    // TODO(shaochuan): Use new flag
+    request.setCachePolicy(WebCachePolicy::ReturnCacheDataDontLoad);
+  }
+
   m_loader = wrapUnique(Platform::current()->createURLLoader());
   DCHECK(m_loader);
   m_loader->setDefersLoading(defersLoading);
   m_loader->setLoadingTaskRunner(loadingTaskRunner);
 
   if (m_resource->options().synchronousPolicy == RequestSynchronously)
     requestSynchronously(request);
   else
     m_loader->loadAsynchronously(WrappedResourceRequest(request), this);
 }
@@ skipping 38 matching lines @@
     didFail(ResourceError::cancelledDueToAccessCheckError(newURL));
 }
 
 bool ResourceLoader::willFollowRedirect(
     WebURLLoader*,
     WebURLRequest& passedNewRequest,
     const WebURLResponse& passedRedirectResponse) {
   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());
   newRequest.setRedirectStatus(
       ResourceRequest::RedirectStatus::FollowedRedirect);
 
   const KURL originalURL = newRequest.url();
 
   if (!m_fetcher->willFollowRedirect(m_resource.get(), newRequest,
                                      redirectResponse)) {
@@ skipping 112 matching lines @@
   // empty buffer is a noop in most cases, but is destructive in the case of
   // a 304, where it will overwrite the cached data we should be reusing.
   if (dataOut.size()) {
     m_fetcher->didReceiveData(m_resource.get(), dataOut.data(), dataOut.size(),
                               encodedDataLength);
     m_resource->setResourceBuffer(dataOut);
   }
   didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
+bool ResourceLoader::activateCacheAwareLoading(const ResourceRequest& request) {
+  DCHECK(!m_isCacheAwareLoadingActivated);
+
+  // Don't activate on Resource revalidation.
+  if (m_resource->isCacheValidator())
+    return false;
+
+  // Don't activate if cache policy is explicitly set.
+  if (request.getCachePolicy() != WebCachePolicy::UseProtocolCachePolicy)
+    return false;
+
+  m_isCacheAwareLoadingActivated = true;
+  return true;
+}
+
+void ResourceLoader::deactivateCacheAwareLoading() {
+  DCHECK(m_isCacheAwareLoadingActivated);
+  m_isCacheAwareLoadingActivated = false;
+}
+
 }  // namespace blink