[WIP] WebFonts cache-aware timeout adaption

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
     License as published by the Free Software Foundation; either
@@ skipping 1090 matching lines @@
   }
   context().dispatchDidFinishLoading(resource->identifier(), finishTime,
                                      encodedDataLength);
   if (finishReason == DidFinishLoading)
     resource->finish(finishTime);
   context().didLoadResource(resource);
 }
 
 void ResourceFetcher::didFailLoading(Resource* resource,
                                      const ResourceError& error) {
+  if (resource->resourceRequest().isCacheAwareLoadingActivated() &&
+      !error.isCancellation() && !error.isAccessCheck()) {
+    // Assume error.errorCode() == net::ERR_CACHE_MISS, resend request with
+    // existing ResourceLoader.

[Takashi Toyoshima, 2016/10/05 07:06:18]

Is it difficult to have an explicit method to know the missed cache case, like
adding error.isMissedCache() or something? Having this sort of code based on an
assumption that just rely on current implementation sounds not safe to me in
terms of future-changes-proof.

[Shao-Chuan Lee, 2016/10/05 10:16:10]

Should we add a field for this in WebURLError and set it on content side?

[Shao-Chuan Lee, 2016/10/07 08:10:06]

Done.

+    resource->willReloadAfterDiskCacheMiss();
+    resource->loader()->start(resource->resourceRequest(),
+                              context().loadingTaskRunner(),
+                              context().defersLoading());
+    return;
+  }
+
   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);
 }
 
@@ skipping 92 matching lines @@
                   resource->options());
 
   // 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);
 
+  // TODO(632580): Workaround to persist cache-aware state, remove after fixed.
+  resource->setResourceRequest(request);
+
   ResourceLoader* loader = ResourceLoader::create(this, resource);
   if (resource->shouldBlockLoadEvent())
     m_loaders.add(loader);
   else
     m_nonBlockingLoaders.add(loader);
 
   storeResourceTimingInitiatorInformation(resource);
   resource->setFetcherSecurityOrigin(sourceOrigin);
   loader->start(request, context().loadingTaskRunner(),
                 context().defersLoading());
@@ skipping 92 matching lines @@
                   resource->options());
   return true;
 }
 
 void ResourceFetcher::willSendRequest(unsigned long identifier,
                                       ResourceRequest& newRequest,
                                       const ResourceResponse& redirectResponse,
                                       const ResourceLoaderOptions& options) {
   context().dispatchWillSendRequest(identifier, newRequest, redirectResponse,
                                     options.initiatorInfo);
+  newRequest.mayActivateCacheAwareLoading();
 }
 
 void ResourceFetcher::updateAllImageResourcePriorities() {
   TRACE_EVENT0(
       "blink",
       "ResourceLoadPriorityOptimizer::updateAllImageResourcePriorities");
   for (const auto& documentResource : m_documentResources) {
     Resource* resource = documentResource.value.get();
     if (!resource || !resource->isImage() || !resource->isLoading())
       continue;
@@ skipping 211 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