Move FrameFetchContext::dispatchDidLoadResourceFromMemoryCache logic into ResourceFetcher

third_party/WebKit/Source/platform/loader/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 279 matching lines @@
 
 // Limit the number of URLs in m_validatedURLs to avoid memory bloat.
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
 void ResourceFetcher::requestLoadStarted(unsigned long identifier,
                                          Resource* resource,
                                          const FetchRequest& request,
                                          ResourceLoadStartType type,
                                          bool isStaticData) {
-  if (type == ResourceLoadingFromCache &&
+  if (type == ResourceLoadStartType::kFromMemoryCache &&
       resource->getStatus() == ResourceStatus::Cached &&
       !m_validatedURLs.contains(resource->url())) {
-    context().dispatchDidLoadResourceFromMemoryCache(
-        identifier, resource, request.resourceRequest().frameType(),
-        request.resourceRequest().requestContext());
+    // Loaded from MemoryCache.
+    didLoadResourceFromMemoryCache(identifier, resource, request);
   }
 
   if (isStaticData)
     return;
 
-  if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() &&
+  if (type == ResourceLoadStartType::kFromMemoryCache &&
+      !resource->stillNeedsLoad() &&
       !m_validatedURLs.contains(request.resourceRequest().url())) {
     // Resources loaded from memory cache should be reported the first time
     // they're used.
     RefPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(
         request.options().initiatorInfo.name, monotonicallyIncreasingTime(),
         resource->getType() == Resource::MainResource);
     populateTimingInfo(info.get(), resource);
     info->clearLoadTimings();
     info->setLoadFinishTime(info->initialTime());
     m_scheduledResourceTimingReports.push_back(info.release());
     if (!m_resourceTimingReportTimer.isActive())
       m_resourceTimingReportTimer.startOneShot(0, BLINK_FROM_HERE);
   }
 
   if (m_validatedURLs.size() >= kMaxValidatedURLsSize) {
     m_validatedURLs.clear();
   }
   m_validatedURLs.insert(request.resourceRequest().url());
 }
 
+void ResourceFetcher::didLoadResourceFromMemoryCache(
+    unsigned long identifier,
+    Resource* resource,
+    const FetchRequest& request) {

[Nate Chapin, 2017/03/22 19:02:02]

Nit: take const ResourceRequest& instead of const FetchRequest&, since this
function doesn't use anything else from the FetchRequest.

[kinuko, 2017/03/24 13:51:51]

Done.

+  context().dispatchDidLoadResourceFromMemoryCache(
+      identifier, request.resourceRequest(), resource->response());

[Nate Chapin, 2017/03/22 19:02:02]

We're sending a different ResoruceRequest for
dispatchDidLoadResourceFromMemoryCache() and dispatchWillSendRequest(). Can we
send the same one? I don't think it matters at the moment, but it might cause
confusion later.

[kinuko, 2017/03/24 13:51:51]

Done.

+  {
+    // dispatchWillSendRequest can modify resourceRequest, while we don't
+    // really use the modified request here.
+    // TODO(https://crbug.com/632580): Avoid allowing dispatchWillSendRequest
+    // to modify requests.
+    ResourceRequest resourceRequest(resource->url());
+    resourceRequest.setFrameType(request.resourceRequest().frameType());
+    resourceRequest.setRequestContext(
+        request.resourceRequest().requestContext());
+    context().dispatchWillSendRequest(identifier, resourceRequest,
+                                      ResourceResponse() /* redirects */,
+                                      resource->options().initiatorInfo);
+  }
+  context().dispatchDidReceiveResponse(
+      identifier, resource->response(), request.resourceRequest().frameType(),
+      request.resourceRequest().requestContext(), resource,
+      ResourceLoadStartType::kFromMemoryCache);
+
+  if (resource->encodedSize() > 0)
+    context().dispatchDidReceiveData(identifier, 0, resource->encodedSize());
+
+  context().dispatchDidFinishLoading(identifier, 0, 0,
+                                     resource->response().decodedBodyLength());
+}
+
 static std::unique_ptr<TracedValue> urlForTraceEvent(const KURL& url) {
   std::unique_ptr<TracedValue> value = TracedValue::create();
   value->setString("url", url.getString());
   return value;
 }
 
 Resource* ResourceFetcher::resourceForStaticData(
     const FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData) {
@@ skipping 259 matching lines @@
     // and then another reference to the image is parsed (which would be at a
     // lower priority).
     if (resourceRequest.priority() > resource->resourceRequest().priority())
       resource->didChangePriority(resourceRequest.priority(), 0);
     // TODO(yoav): I'd expect the stated scenario to not go here, as its policy
     // would be Use.
   }
 
   // If only the fragment identifiers differ, it is the same resource.
   DCHECK(equalIgnoringFragmentIdentifier(resource->url(), request.url()));
-  requestLoadStarted(
-      identifier, resource, request,
-      policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork,
-      isStaticData);
+  requestLoadStarted(identifier, resource, request,
+                     policy == Use ? ResourceLoadStartType::kFromMemoryCache
+                                   : ResourceLoadStartType::kNotFromMemoryCache,
+                     isStaticData);
   m_documentResources.set(
       MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), resource);
 
   // Returns with an existing resource if the resource does not need to start
   // loading immediately. If revalidation policy was determined as |Revalidate|,
   // the resource was already initialized for the revalidation here, but won't
   // start loading.
   if (!resourceNeedsLoad(resource, request, policy))
     return resource;
 
@@ skipping 870 matching lines @@
   if (cachedResource(url))
     return;
   ResourceRequest resourceRequest(url);
   resourceRequest.setRequestContext(requestContext);
   FetchRequest request(resourceRequest, initiatorName, resource->options());
   context().canRequest(resource->getType(), resource->lastResourceRequest(),
                        resource->lastResourceRequest().url(), request.options(),
                        SecurityViolationReportingPolicy::Report,
                        request.getOriginRestriction());
   requestLoadStarted(resource->identifier(), resource, request,
-                     ResourceLoadingFromCache);
+                     ResourceLoadStartType::kFromMemoryCache);
 }
 
 ResourceFetcher::DeadResourceStatsRecorder::DeadResourceStatsRecorder()
     : m_useCount(0), m_revalidateCount(0), m_loadCount(0) {}
 
 ResourceFetcher::DeadResourceStatsRecorder::~DeadResourceStatsRecorder() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       CustomCountHistogram, hitCountHistogram,
       new CustomCountHistogram("WebCore.ResourceFetcher.HitCount", 0, 1000,
                                50));
@@ skipping 30 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