[NotLanded] Implement the fetching algorithm of the Web Manifest.

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
     License as published by the Free Software Foundation; either
@@ skipping 78 matching lines @@
     case Resource::Script:
         return new ScriptResource(request, charset);
     case Resource::SVGDocument:
         return new DocumentResource(request, Resource::SVGDocument);
     case Resource::Font:
         return new FontResource(request);
     case Resource::MainResource:
     case Resource::Raw:
     case Resource::TextTrack:
     case Resource::Media:
+    case Resource::ImportResource:
         return new RawResource(request, type);
     case Resource::XSLStyleSheet:
         return new XSLStyleSheetResource(request, charset);
     case Resource::LinkPrefetch:
-        return new Resource(request, Resource::LinkPrefetch);
     case Resource::LinkSubresource:
-        return new Resource(request, Resource::LinkSubresource);
-    case Resource::ImportResource:
-        return new RawResource(request, type);
+    case Resource::Manifest:
+        return new Resource(request, type);
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static ResourceLoadPriority loadPriority(Resource::Type type, const FetchRequest& request)
 {
     if (request.priority() != ResourceLoadPriorityUnresolved)
         return request.priority();
 
     switch (type) {
     case Resource::MainResource:
         return ResourceLoadPriorityVeryHigh;
     case Resource::CSSStyleSheet:
         return ResourceLoadPriorityHigh;
     case Resource::Raw:
         return request.options().synchronousPolicy == RequestSynchronously ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
     case Resource::Script:
     case Resource::Font:
     case Resource::ImportResource:
+    case Resource::Manifest:

[Nate Chapin, 2014/08/25 20:43:11]

Is there any case loading a manifest will block the user? If not, this should
probably be priority Low or VeryLow

[mlamouri (slow - plz ping), 2014/08/26 17:25:22]

For the moment, we expect to load the manifest only as needed. In the short
term, that means when the user wants to add the page to homescreen, or bookmark
it in some ways. I guess it can be considered as blocking the user.

         return ResourceLoadPriorityMedium;
     case Resource::Image:
         // We'll default images to VeryLow, and promote whatever is visible. This improves
         // speed-index by ~5% on average, ~14% at the 99th percentile.
         return ResourceLoadPriorityVeryLow;
     case Resource::Media:
         return ResourceLoadPriorityLow;
     case Resource::XSLStyleSheet:
         ASSERT(RuntimeEnabledFeatures::xsltEnabled());
         return ResourceLoadPriorityHigh;
@@ skipping 72 matching lines @@
     case Resource::Image:
         return WebURLRequest::RequestContextImage;
     case Resource::Raw:
         return WebURLRequest::RequestContextSubresource;
     case Resource::ImportResource:
         return WebURLRequest::RequestContextImport;
     case Resource::LinkPrefetch:
         return WebURLRequest::RequestContextPrefetch;
     case Resource::LinkSubresource:
         return WebURLRequest::RequestContextSubresource;
+    case Resource::Manifest:
+        return WebURLRequest::RequestContextManifest;
     case Resource::TextTrack:
         return WebURLRequest::RequestContextTrack;
     case Resource::SVGDocument:
         return WebURLRequest::RequestContextImage;
     case Resource::Media: // TODO: Split this.
         return WebURLRequest::RequestContextVideo;
     }
     ASSERT_NOT_REACHED();
     return WebURLRequest::RequestContextSubresource;
 }
@@ skipping 175 matching lines @@
     return toRawResource(requestResource(Resource::Media, request));
 }
 
 ResourcePtr<RawResource> ResourceFetcher::fetchTextTrack(FetchRequest& request)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextTrack);
     return toRawResource(requestResource(Resource::TextTrack, request));
 }
 
+ResourcePtr<Resource> ResourceFetcher::fetchManifest(FetchRequest& request)
+{
+    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
+    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextManifest);
+    return requestResource(Resource::Manifest, request);
+}
+
 void ResourceFetcher::preCacheSubstituteDataForMainResource(const FetchRequest& request, const SubstituteData& substituteData)
 {
     const KURL& url = request.url();
     if (Resource* oldResource = memoryCache()->resourceForURL(url))
         memoryCache()->remove(oldResource);
 
     ResourceResponse response(url, substituteData.mimeType(), substituteData.content()->size(), substituteData.textEncoding(), emptyString());
     ResourcePtr<Resource> resource = createResource(Resource::MainResource, request.resourceRequest(), substituteData.textEncoding());
     resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
     resource->setOptions(request.options());
@@ skipping 14 matching lines @@
         case Resource::Script:
         case Resource::SVGDocument:
         case Resource::CSSStyleSheet:
         case Resource::ImportResource:
             // These resource can inject script into the current document (Script,
             // XSL) or exfiltrate the content of the current document (CSS).
             treatment = TreatAsActiveContent;
             break;
 
         case Resource::Font:
+        case Resource::Manifest:
         case Resource::TextTrack:
             // These resources are passive, but mixed usage is low enough that we
             // can block them in a mixed context.
             treatment = TreatAsActiveContent;
             break;
 
         case Resource::Raw:
         case Resource::Image:
         case Resource::Media:
             // These resources can corrupt only the frame's pixels.
@@ skipping 63 matching lines @@
     case Resource::Image:
     case Resource::CSSStyleSheet:
     case Resource::Script:
     case Resource::Font:
     case Resource::Raw:
     case Resource::LinkPrefetch:
     case Resource::LinkSubresource:
     case Resource::TextTrack:
     case Resource::ImportResource:
     case Resource::Media:
+    case Resource::Manifest:
         // By default these types of resources can be loaded from any origin.
         // FIXME: Are we sure about Resource::Font?
         if (originRestriction == FetchRequest::RestrictToSameOrigin && !securityOrigin->canRequest(url)) {
             printAccessDeniedMessage(url);
             return false;
         }
         break;
     case Resource::XSLStyleSheet:
         ASSERT(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::SVGDocument:
@@ skipping 49 matching lines @@
         break;
     case Resource::Font: {
         if (!shouldBypassMainWorldCSP && !csp->allowFontFromSource(url, cspReporting))
             return false;
         break;
     }
     case Resource::MainResource:
     case Resource::Raw:
     case Resource::LinkPrefetch:
     case Resource::LinkSubresource:
+    case Resource::Manifest:
         break;
     case Resource::Media:
     case Resource::TextTrack:
         if (!shouldBypassMainWorldCSP && !csp->allowMediaFromSource(url, cspReporting))
             return false;
 
         if (frame()) {
             if (!frame()->loader().client()->allowMedia(url))
                 return false;
         }
@@ skipping 941 matching lines @@
 
 void ResourceFetcher::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
     visitor->trace(m_loaders);
     visitor->trace(m_multipartLoaders);
     ResourceLoaderHost::trace(visitor);
 }
 
 }