Cache-aware Resource loading

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 1155 matching lines @@
   context().didLoadResource(resource);
 
   if (resource->isImage() &&
       toImageResource(resource)->shouldReloadBrokenPlaceholder()) {
     toImageResource(resource)->reloadIfLoFiOrPlaceholder(this);
   }
 }
 
 void ResourceFetcher::didFailLoading(Resource* resource,
                                      const ResourceError& error) {
+  if (resource->loader()->isCacheAwareLoadingActivated() &&
+      error.isCacheMiss()) {
+    resource->willReloadAfterDiskCacheMiss();
+    resource->loader()->deactivateCacheAwareLoading();
+    resource->loader()->restart(resource->resourceRequest(),
+                                context().loadingTaskRunner(),
+                                context().defersLoading());
+    return;
+  }

[hiroshige, 2016/10/27 08:21:48]

Can we move this block to ResourceLoader::didFail() and make
ResourceLoader::deactivateCacheAwareLoading() private?
(Probably we can also make ResourceLoader::isCacheAwareLoadingActivated()
private)

[Shao-Chuan Lee, 2016/10/28 04:14:14]

Done.
As for isCacheAwareLoadingActivated() I'm planning to have it exposed to
Resource and ResourceClient.

+
   TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource->identifier());
   removeResourceLoader(resource->loader());
   m_resourceTimingInfoMap.take(const_cast<Resource*>(resource));
   bool isInternalRequest = resource->options().initiatorInfo.name ==
                            FetchInitiatorTypeNames::internal;
   context().dispatchDidFail(resource->identifier(), error, isInternalRequest);
   resource->error(error);
   context().didLoadResource(resource);
 
   if (resource->isImage() &&
@@ skipping 91 matching lines @@
   DCHECK(resource->stillNeedsLoad());
   if (!context().shouldLoadNewResource(resource->getType())) {
     memoryCache()->remove(resource);
     return false;
   }
 
   ResourceRequest request(resource->resourceRequest());
   willSendRequest(resource->identifier(), request, ResourceResponse(),
                   resource->options());
 
+  // TODO(shaochuan): Saving modified ResourceRequest back to |resource|, remove
+  // once willSendRequest() takes const ResourceRequest. crbug.com/632580
+  resource->setResourceRequest(request);
+
   // Resource requests from suborigins should not be intercepted by the service
   // worker of the physical origin. This has the effect that, for now,
   // suborigins do not work with service workers. See
   // https://w3c.github.io/webappsec-suborigins/.
   SecurityOrigin* sourceOrigin = context().getSecurityOrigin();
   if (sourceOrigin && sourceOrigin->hasSuborigin())
     request.setSkipServiceWorker(WebURLRequest::SkipServiceWorker::All);
 
   ResourceLoader* loader = ResourceLoader::create(this, resource);
   if (resource->shouldBlockLoadEvent())
     m_loaders.add(loader);
   else
     m_nonBlockingLoaders.add(loader);
 
   storeResourceTimingInitiatorInformation(resource);
   resource->setFetcherSecurityOrigin(sourceOrigin);
+
+  if (resource->options().cacheAwareLoadingEnabled ==
+      IsCacheAwareLoadingEnabled) {
+    // Call cache miss callback immediately if cache-aware loading is enabled
+    // but cannot be activated.
+    if (!loader->activateCacheAwareLoading(request))
+      resource->willReloadAfterDiskCacheMiss();
+  }

[hiroshige, 2016/10/27 08:21:48]

Can we move this block to ResourceLoader::start() and make
activateCacheAwareLoading() private?

[Shao-Chuan Lee, 2016/10/28 04:14:14]

The activation should only occur in startLoad(), if put in
ResourceLoader::start() it cannot determine whether it's called from startLoad()
or restart().

[hiroshige, 2016/10/31 08:25:19]

Makes sense. There might be a room for refactoring but it should not block this
issue.

+
   loader->start(request, context().loadingTaskRunner(),
                 context().defersLoading());
   return true;
 }
 
 void ResourceFetcher::removeResourceLoader(ResourceLoader* loader) {
   if (m_loaders.contains(loader))
     m_loaders.remove(loader);
   else if (m_nonBlockingLoaders.contains(loader))
     m_nonBlockingLoaders.remove(loader);
@@ skipping 309 matching lines @@
   visitor->trace(m_context);
   visitor->trace(m_archive);
   visitor->trace(m_loaders);
   visitor->trace(m_nonBlockingLoaders);
   visitor->trace(m_documentResources);
   visitor->trace(m_preloads);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink