ResourceFetcher: Refactor ResourceForStaticData().

third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.cpp

Index: third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.cpp
diff --git a/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.cpp b/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.cpp
index 1816f8d687c68baf6db35b3566b50c292c224325..86806176d34dcc9843ad2a8e21bc7d446f8e0db3 100644
--- a/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.cpp
+++ b/third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.cpp
@@ -366,12 +366,50 @@ static std::unique_ptr<TracedValue> UrlForTraceEvent(const KURL& url) {
   return value;
 }
 
-Resource* ResourceFetcher::ResourceForStaticData(
-    const FetchParameters& params,
+Resource* ResourceFetcher::ResourceForStaticDataFromCache(
+    const FetchParameters& request) {
+  if (Resource* old_resource = GetMemoryCache()->ResourceForURL(
+          request.GetResourceRequest().Url(), GetCacheIdentifier())) {
+    // There's no reason to re-parse if we saved the data from the previous
+    // parse.
+    if (request.Options().data_buffering_policy != kDoNotBufferData)
+      return old_resource;
+    GetMemoryCache()->Remove(old_resource);
+  }
+  return nullptr;
+}
+
+Resource* ResourceFetcher::ResourceForSubstituteData(
+    const FetchParameters& request,
     const ResourceFactory& factory,
     const SubstituteData& substitute_data) {
-  const KURL& url = params.GetResourceRequest().Url();
-  DCHECK(url.ProtocolIsData() || substitute_data.IsValid() || archive_);
+  DCHECK(substitute_data.IsValid());
+  // TODO(arthursonzogni): should we use the cache? Even with substitute data?
+  if (Resource* resource = ResourceForStaticDataFromCache(request)) {
+    return resource;
+  }
+
+  ResourceResponse response;
+  RefPtr<SharedBuffer> data;
+  data = substitute_data.Content();
+  response.SetURL(request.GetResourceRequest().Url());
+  response.SetMimeType(substitute_data.MimeType());
+  response.SetExpectedContentLength(data->size());
+  response.SetTextEncodingName(substitute_data.TextEncoding());
+
+  return CreateResourceFromStaticData(request, factory, response, data,
+                                      substitute_data);
+}
+
+Resource* ResourceFetcher::ResourceForDataUrl(
+    const FetchParameters& request,
+    const ResourceFactory& factory,
+    const SubstituteData& substitute_data) {
+  const KURL& url = request.GetResourceRequest().Url();
+  DCHECK(url.ProtocolIsData());
+  if (Resource* resource = ResourceForStaticDataFromCache(request)) {
+    return resource;
+  }
 
   // TODO(japhet): We only send main resource data: urls through WebURLLoader
   // for the benefit of a service worker test
@@ -379,50 +417,63 @@ Resource* ResourceFetcher::ResourceForStaticData(
   // where it isn't easy to mock out a network load. It uses data: urls to
   // emulate the behavior it wants to test, which would otherwise be reserved
   // for network loads.
-  if (!archive_ && !substitute_data.IsValid() &&
-      (factory.GetType() == Resource::kMainResource ||
-       factory.GetType() == Resource::kRaw))
+  if (factory.GetType() == Resource::kMainResource ||
+      factory.GetType() == Resource::kRaw) {
     return nullptr;
-
-  const String cache_identifier = GetCacheIdentifier();
-  if (Resource* old_resource =
-          GetMemoryCache()->ResourceForURL(url, cache_identifier)) {
-    // There's no reason to re-parse if we saved the data from the previous
-    // parse.
-    if (params.Options().data_buffering_policy != kDoNotBufferData)
-      return old_resource;
-    GetMemoryCache()->Remove(old_resource);
   }
 
   ResourceResponse response;
-  RefPtr<SharedBuffer> data;
-  if (substitute_data.IsValid()) {
-    data = substitute_data.Content();
-    response.SetURL(url);
-    response.SetMimeType(substitute_data.MimeType());
-    response.SetExpectedContentLength(data->size());
-    response.SetTextEncodingName(substitute_data.TextEncoding());
-  } else if (url.ProtocolIsData()) {
-    data = NetworkUtils::ParseDataURLAndPopulateResponse(url, response);
-    if (!data)
-      return nullptr;
+  if (RefPtr<SharedBuffer> data =
+          NetworkUtils::ParseDataURLAndPopulateResponse(url, response)) {
     // |response| is modified by parseDataURLAndPopulateResponse() and is
     // ready to be used.
-  } else {
-    ArchiveResource* archive_resource =
-        archive_->SubresourceForURL(params.Url());
-    // Fall back to the network if the archive doesn't contain the resource.
-    if (!archive_resource)
-      return nullptr;
-    data = archive_resource->Data();
+    Resource* resource = CreateResourceFromStaticData(
+        request, factory, response, data, substitute_data);
+
+    GetMemoryCache()->Add(resource);
+    return resource;
+  }
+
+  return nullptr;
+}
+
+Resource* ResourceFetcher::ResourceForArchive(
+    const FetchParameters& request,
+    const ResourceFactory& factory,
+    const SubstituteData& substitute_data) {
+  const KURL& url = request.GetResourceRequest().Url();
+  DCHECK(archive_);
+  if (Resource* resource = ResourceForStaticDataFromCache(request)) {
+    return resource;
+  }
+
+  if (ArchiveResource* archive_resource =
+          archive_->SubresourceForURL(request.Url())) {
+    RefPtr<SharedBuffer> data = archive_resource->Data();
+    ResourceResponse response;
     response.SetURL(url);
     response.SetMimeType(archive_resource->MimeType());
     response.SetExpectedContentLength(data->size());
     response.SetTextEncodingName(archive_resource->TextEncoding());
+
+    Resource* resource = CreateResourceFromStaticData(
+        request, factory, response, data, substitute_data);
+
+    GetMemoryCache()->Add(resource);
+    return resource;
   }
 
-  Resource* resource = factory.Create(params.GetResourceRequest(),
-                                      params.Options(), params.Charset());
+  return nullptr;
+}
+
+Resource* ResourceFetcher::CreateResourceFromStaticData(
+    const FetchParameters& request,
+    const ResourceFactory& factory,
+    const ResourceResponse& response,
+    const RefPtr<SharedBuffer>& data,
+    const SubstituteData& substitute_data) {
+  Resource* resource = factory.Create(request.GetResourceRequest(),
+                                      request.Options(), request.Charset());
   resource->SetNeedsSynchronousCacheHit(substitute_data.ForceSynchronousLoad());
   // FIXME: We should provide a body stream here.
   resource->ResponseReceived(response, nullptr);
@@ -430,12 +481,9 @@ Resource* ResourceFetcher::ResourceForStaticData(
   if (data->size())
     resource->SetResourceBuffer(data);
   resource->SetIdentifier(CreateUniqueIdentifier());
-  resource->SetCacheIdentifier(cache_identifier);
+  resource->SetCacheIdentifier(GetCacheIdentifier());
   resource->Finish();
 
-  if (!substitute_data.IsValid())
-    GetMemoryCache()->Add(resource);
-
   return resource;
 }
 
@@ -556,7 +604,6 @@ Resource* ResourceFetcher::RequestResource(
   TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",
                UrlForTraceEvent(params.Url()));
 
-  Resource* resource = nullptr;
   ResourceRequestBlockedReason blocked_reason =
       ResourceRequestBlockedReason::kNone;
 
@@ -574,17 +621,29 @@ Resource* ResourceFetcher::RequestResource(
                                     params.Options().initiator_info.name);
   }
 
+  Resource* resource = nullptr;
   bool is_data_url = resource_request.Url().ProtocolIsData();
   bool is_static_data = is_data_url || substitute_data.IsValid() || archive_;
-  if (is_static_data) {
-    resource = ResourceForStaticData(params, factory, substitute_data);
-    // Abort the request if the archive doesn't contain the resource, except in
-    // the case of data URLs which might have resources such as fonts that need
-    // to be decoded only on demand.  These data URLs are allowed to be
+
+  if (substitute_data.IsValid()) {
+    resource = ResourceForSubstituteData(params, factory, substitute_data);
+  } else if (is_data_url) {
+    resource = ResourceForDataUrl(params, factory, substitute_data);
+    // In the some cases, the data URLs might have resources such as fonts that
+    // need to be decoded only on demand. These data URLs are allowed to be
     // processed using the normal ResourceFetcher machinery.
-    if (!resource && !is_data_url && archive_)
+  } else if (archive_) {
+    resource = ResourceForArchive(params, factory, substitute_data);
+    // TODO(arthursonzogni): In past version of ResourceForStaticData, when
+    // there is an |archive_| but the resource is not found. It is stated:
+    // "Fall back to the network if the archive doesn't contain the resource.",
+    // but then the caller abort the request whatever happens:
+    // "Abort the request if the archive doesn't contain the resource".
+    // It is contradictory.
+    if (!resource)
       return nullptr;
   }
+
   if (!resource) {
     resource =
         GetMemoryCache()->ResourceForURL(params.Url(), GetCacheIdentifier());