ResourceFetcher: Refactor ResourceForStaticData().

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 348 matching lines @@
   Context().DispatchDidFinishLoading(
       identifier, 0, 0, resource->GetResponse().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 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
   // (RenderViewImplTest.ServiceWorkerNetworkProviderSetup), which is at a layer
   // 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);
   resource->SetDataBufferingPolicy(kBufferData);
   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;
 }
 
 Resource* ResourceFetcher::ResourceForBlockedRequest(
     const FetchParameters& params,
     const ResourceFactory& factory,
     ResourceRequestBlockedReason blocked_reason) {
   Resource* resource = factory.Create(params.GetResourceRequest(),
                                       params.Options(), params.Charset());
   resource->GetError(ResourceError::CancelledDueToAccessCheckError(
@@ skipping 100 matching lines @@
     const SubstituteData& substitute_data) {
   unsigned long identifier = CreateUniqueIdentifier();
   ResourceRequest& resource_request = params.MutableResourceRequest();
   network_instrumentation::ScopedResourceLoadTracker
       scoped_resource_load_tracker(identifier, resource_request);
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Fetch.RequestResourceTime");
   // TODO(dproy): Remove this. http://crbug.com/659666
   TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",
                UrlForTraceEvent(params.Url()));
 
-  Resource* resource = nullptr;
   ResourceRequestBlockedReason blocked_reason =
       ResourceRequestBlockedReason::kNone;
 
   PrepareRequestResult result = PrepareRequest(params, factory, substitute_data,
                                                identifier, blocked_reason);
   if (result == kAbort)
     return nullptr;
   if (result == kBlock)
     return ResourceForBlockedRequest(params, factory, blocked_reason);
 
   if (!params.IsSpeculativePreload()) {
     // Only log if it's not for speculative preload.
     Context().RecordLoadingActivity(identifier, resource_request,
                                     factory.GetType(),
                                     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());
   }
 
   // If we got a preloaded resource from the cache for a non-preload request,
   // we may need to make it block the onload event.
   MakePreloadedResourceBlockOnloadIfNeeded(resource, params);
 
   const RevalidationPolicy policy = DetermineRevalidationPolicy(
@@ skipping 979 matching lines @@
   visitor->Trace(context_);
   visitor->Trace(archive_);
   visitor->Trace(loaders_);
   visitor->Trace(non_blocking_loaders_);
   visitor->Trace(document_resources_);
   visitor->Trace(preloads_);
   visitor->Trace(resource_timing_info_map_);
 }
 
 }  // namespace blink