Phase II Step 3: Reload LoFi/placeholder images via new ImageResource

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 764 matching lines @@
 ResourceFetcher::RevalidationPolicy
 ResourceFetcher::determineRevalidationPolicy(Resource::Type type,
                                              const FetchRequest& fetchRequest,
                                              Resource* existingResource,
                                              bool isStaticData) const {
   const ResourceRequest& request = fetchRequest.resourceRequest();
 
   if (!existingResource)
     return Load;
 
+  if (fetchRequest.enforceNewResource())

[Nate Chapin, 2016/12/28 00:14:57]

Adding yet another clause to this function makes me sad. Could ImageResource
override canReuse() and get the same effect?

[hiroshige, 2017/01/25 02:01:49]

ACK, I'll handle this.

[hiroshige, 2017/03/13 21:27:04]

Removed.

[hiroshige, 2017/03/13 21:29:16]

In Patch Set 31, I merged FetchRequest::enforceNewResource() into
placeholderImageRequestType() and put the condition to ImageResource::canReuse()
to avoid a new clause in determineRevalidationPolicy().

However in Patch Set 32, as commented above, I use startLoad() directly and
bypass requestResource() when reloading.
Therefore, this condition is not needed in Patch Set 32 and thus it is simply
removed.

+    return Reload;
+
   // Checks if the resource has an explicit policy about integrity metadata.
   //
   // This is necessary because ScriptResource and CSSStyleSheetResource objects
   // do not keep the raw data around after the source is accessed once, so if
   // the resource is accessed from the MemoryCache for a second time, there is
   // no way to redo an integrity check.
   //
   // Thus, Blink implements a scheme where it caches the integrity information
   // for those resources after the first time it is checked, and if there is
   // another request for that resource, with the same integrity metadata, Blink
@@ skipping 313 matching lines @@
   if (!context().isMainFrame())
     return nullptr;
   m_archive = MHTMLArchive::create(resource->url(), resource->resourceBuffer());
   return m_archive ? m_archive->mainResource() : nullptr;
 }
 
 ResourceTimingInfo* ResourceFetcher::getNavigationTimingInfo() {
   return m_navigationTimingInfo.get();
 }
 
 void ResourceFetcher::handleLoadCompletion(Resource* resource) {

[Nate Chapin, 2016/12/28 00:14:57]

This helper seems like it's not useful if it's only the
context().didLoadResource() call.

[hiroshige, 2016/12/28 01:04:21]

+tyoshino@ (who introduced this method), is it fine with you to revert
handleLoadCompletion() back to didLoadResource()?

[hiroshige, 2017/01/25 02:01:49]

I reverted this change (while I was removing reload-initiating code from
ImageResourceContent) and thus we no longer have to handle this issue.

   context().didLoadResource(resource);
-
-  resource->reloadIfLoFiOrPlaceholderImage(this, Resource::kReloadIfNeeded);
 }
 
 void ResourceFetcher::handleLoaderFinish(Resource* resource,
                                          double finishTime,
                                          LoaderFinishType type) {
   DCHECK(resource);
 
   ResourceLoader* loader = resource->loader();
   if (type == DidFinishFirstPartInMultipart) {
     // When loading a multipart resource, make the loader non-block when
@@ skipping 35 matching lines @@
       if (resource->options().requestInitiatorContext == DocumentContext)
         context().addResourceTiming(*info);
       resource->reportResourceTimingToClients(*info);
     }
   }
 
   context().dispatchDidFinishLoading(resource->identifier(), finishTime,
                                      encodedDataLength);
 
   if (type == DidFinishLoading)
-    resource->finish(finishTime);
+    resource->finish(finishTime, this);
 
   handleLoadCompletion(resource);
 }
 
 void ResourceFetcher::handleLoaderError(Resource* resource,
                                         const ResourceError& error) {
   DCHECK(resource);
 
   removeResourceLoader(resource->loader());
 
   m_resourceTimingInfoMap.take(resource);
 
   bool isInternalRequest = resource->options().initiatorInfo.name ==
                            FetchInitiatorTypeNames::internal;
 
   context().dispatchDidFail(resource->identifier(), error,
                             resource->response().encodedDataLength(),
                             isInternalRequest);
 
-  resource->error(error);
+  resource->error(error, this);
 
   handleLoadCompletion(resource);
 }
 
 void ResourceFetcher::moveResourceLoaderToNonBlocking(ResourceLoader* loader) {
   DCHECK(loader);
   // TODO(yoav): Convert CHECK to DCHECK if no crash reports come in.
   CHECK(m_loaders.contains(loader));
   m_nonBlockingLoaders.add(loader);
   m_loaders.remove(loader);
@@ skipping 94 matching lines @@
                                 resourcePriority.intraPriorityValue);
     network_instrumentation::resourcePrioritySet(resource->identifier(),
                                                  resourceLoadPriority);
     context().dispatchDidChangeResourcePriority(
         resource->identifier(), resourceLoadPriority,
         resourcePriority.intraPriorityValue);
   }
 }
 
 void ResourceFetcher::reloadLoFiImages() {
-  for (const auto& documentResource : m_documentResources) {
+  for (auto& documentResource : m_documentResources) {
     Resource* resource = documentResource.value.get();
     if (resource)
       resource->reloadIfLoFiOrPlaceholderImage(this, Resource::kReloadAlways);
   }
 }
 
 void ResourceFetcher::logPreloadStats(ClearPreloadsPolicy policy) {
   if (!m_preloads)
     return;
   unsigned scripts = 0;
@@ skipping 199 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