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 283 matching lines @@
   return policy != Use || resource->stillNeedsLoad();
 }
 
 // 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,
+                                         RevalidationPolicy policy,
                                          bool isStaticData) {
-  if (type == ResourceLoadingFromCache &&
-      resource->getStatus() == ResourceStatus::Cached &&
+  if (policy == Use && 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.resourceRequest());
   }
 
   if (isStaticData)
     return;
 
-  if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() &&
+  if (policy == Use && !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 ResourceRequest& originalResourceRequest) {
+  ResourceRequest resourceRequest(resource->url());
+  resourceRequest.setFrameType(originalResourceRequest.frameType());
+  resourceRequest.setRequestContext(originalResourceRequest.requestContext());
+  context().dispatchDidLoadResourceFromMemoryCache(identifier, resourceRequest,
+                                                   resource->response());
+  context().dispatchWillSendRequest(identifier, resourceRequest,
+                                    ResourceResponse() /* redirects */,
+                                    resource->options().initiatorInfo);
+  context().dispatchDidReceiveResponse(
+      identifier, resource->response(), resourceRequest.frameType(),
+      resourceRequest.requestContext(), resource,
+      FetchContext::ResourceResponseType::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 263 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, 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 859 matching lines @@
     const AtomicString& initiatorName) {
   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);
+  requestLoadStarted(resource->identifier(), resource, request, Use);
 }
 
 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