Send synchronous loads through the cache.

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 98 matching lines @@
 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::Raw:
     case Resource::ImportResource:
         return ResourceLoadPriorityMedium;
     case Resource::Image:
         return request.forPreload() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityLow;
     case Resource::XSLStyleSheet:
         return ResourceLoadPriorityHigh;
     case Resource::SVGDocument:
         return ResourceLoadPriorityLow;
     case Resource::LinkPrefetch:
         return ResourceLoadPriorityVeryLow;
@@ skipping 72 matching lines @@
     return 0;
 }
 
 FetchContext& ResourceFetcher::context() const
 {
     if (Frame* frame = this->frame())
         return frame->fetchContext();
     return FetchContext::nullInstance();
 }
 
-unsigned long ResourceFetcher::fetchSynchronously(const ResourceRequest& passedRequest, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
+ResourcePtr<Resource> ResourceFetcher::fetchSynchronously(FetchRequest& request)
 {
     ASSERT(document());
-    ResourceRequest request(passedRequest);
-    request.setTimeoutInterval(10);
-    addAdditionalRequestHeaders(request, Resource::Raw);
-
-    unsigned long identifier = createUniqueIdentifier();
-    context().dispatchWillSendRequest(m_documentLoader, identifier, request, ResourceResponse());
-    documentLoader()->applicationCacheHost()->willStartLoadingSynchronously(request);
-    ResourceLoader::loadResourceSynchronously(request, storedCredentials, error, response, data);
-    int encodedDataLength = response.resourceLoadInfo() ? static_cast<int>(response.resourceLoadInfo()->encodedDataLength) : -1;
-    context().sendRemainingDelegateMessages(m_documentLoader, identifier, response, data.data(), data.size(), encodedDataLength, error);
-    return identifier;
+    request.mutableResourceRequest().setTimeoutInterval(10);
+    ResourceLoaderOptions options(request.options());
+    options.synchronousPolicy = RequestSynchronously;

[abarth-chromium, 2013/09/13 23:48:28]

Should the async pathway ASSERT that the options aren't set to synchronous?

[Nate Chapin, 2013/09/16 20:32:50]

There are a lot of pathways :/

I'd say we should assert in requestResource() that sync requests are only done
on raw resources, since there are assumptions about that.

+    request.setOptions(options);
+    return requestResource(Resource::Raw, request);

[abarth-chromium, 2013/09/13 23:48:28]

Should this function return a ResourcePtr<RawResource> ?

[Nate Chapin, 2013/09/16 20:32:50]

Probably not? Technically it's a raw resource under the hood, but that's only so
that the primary user of synchronous fetching (XHRs) can share data between sync
and async loads. There's nothing in how the synchronously loaded resource is
used that requires the special stuff in RawResource, which mostly just lets the
client hook the resource load callbacks for async loads.

 }
 
 ResourcePtr<ImageResource> ResourceFetcher::fetchImage(FetchRequest& request)
 {
     if (Frame* f = frame()) {
         if (f->document()->pageDismissalEventBeingDispatched() != Document::NoDismissal) {
             KURL requestURL = request.resourceRequest().url();
             if (requestURL.isValid() && canRequest(Resource::Image, requestURL, request.options(), request.forPreload()))
                 PingLoader::loadImage(f, requestURL);
             return 0;
@@ skipping 334 matching lines @@
             return 0;
         }
 
         if (!m_documentLoader || !m_documentLoader->scheduleArchiveLoad(resource.get(), request.resourceRequest()))
             resource->load(this, request.options());
 
         // We don't support immediate loads, but we do support immediate failure.
         if (resource->errorOccurred()) {
             if (resource->inCache())
                 memoryCache()->remove(resource.get());
-            return 0;
+            return request.options().synchronousPolicy == RequestSynchronously ? resource : 0;

[Nate Chapin, 2013/09/12 23:28:46]

This is kind of lame, wherein we let both sync and async loads fail
synchronously, but only return a null Resource for async loads, because
otherwise sync loads have no way to get the information they require (e.g., the
ResourceError).

[abarth-chromium, 2013/09/13 23:48:28]

I might add this information as a comment.

[Nate Chapin, 2013/09/16 20:32:50]

Will do.

         }
     }
 
     // FIXME: Temporarily leave main resource caching disabled for chromium,
     // see https://bugs.webkit.org/show_bug.cgi?id=107962. Before caching main
     // resources, we should be sure to understand the implications for memory
     // use.
     //
     // Ensure main resources aren't preloaded, and other main resource loads
     // are removed from cache to prevent reuse.
@@ skipping 717 matching lines @@
 }
 #endif
 
 const ResourceLoaderOptions& ResourceFetcher::defaultResourceOptions()
 {
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck, CheckContentSecurityPolicy, UseDefaultOriginRestrictionsForType, DocumentContext));
     return options;
 }
 
 }