Send synchronous loads through the cache.

Source/core/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 45 matching lines @@
 
 ResourceLoader::RequestCountTracker::~RequestCountTracker()
 {
     m_host->decrementRequestCount(m_resource);
 }
 
 PassRefPtr<ResourceLoader> ResourceLoader::create(ResourceLoaderHost* host, Resource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
 {
     RefPtr<ResourceLoader> loader(adoptRef(new ResourceLoader(host, resource, options)));
     loader->init(request);
-    loader->start();
     return loader.release();
 }
 
 ResourceLoader::ResourceLoader(ResourceLoaderHost* host, Resource* resource, const ResourceLoaderOptions& options)
     : m_host(host)
     , m_notifiedLoadComplete(false)
     , m_defersLoading(host->defersLoading())
     , m_options(options)
     , m_resource(resource)
     , m_state(Initialized)
@@ skipping 48 matching lines @@
 }
 
 void ResourceLoader::start()
 {
     ASSERT(!m_loader);
     ASSERT(!m_request.isNull());
     ASSERT(m_deferredRequest.isNull());
 
     m_host->willStartLoadingResource(m_request);
 
+    if (m_options.synchronousPolicy == RequestSynchronously) {
+        requestSynchronously();
+        return;
+    }
+
     if (m_defersLoading) {
         m_deferredRequest = m_request;
         return;
     }
 
     if (m_state == Terminated)
         return;
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
@@ skipping 236 matching lines @@
     }
 
     releaseResources();
 }
 
 bool ResourceLoader::isLoadedBy(ResourceLoaderHost* loader) const
 {
     return m_host->isLoadedBy(loader);
 }
 
-void ResourceLoader::loadResourceSynchronously(const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
+void ResourceLoader::requestSynchronously()
 {
     OwnPtr<WebKit::WebURLLoader> loader = adoptPtr(WebKit::Platform::current()->createURLLoader());
     ASSERT(loader);
 
-    WebKit::WrappedResourceRequest requestIn(request);
-    requestIn.setAllowStoredCredentials(storedCredentials == AllowStoredCredentials);
-    WebKit::WrappedResourceResponse responseOut(response);
+    RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
+    m_connectionState = ConnectionStateStarted;
+
+    WebKit::WrappedResourceRequest requestIn(m_request);
+    requestIn.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
+    WebKit::WebURLResponse responseOut;
+    responseOut.initialize();
     WebKit::WebURLError errorOut;
     WebKit::WebData dataOut;
-
     loader->loadSynchronously(requestIn, responseOut, errorOut, dataOut);
-
-    error = errorOut;
-    data.clear();
-    RefPtr<SharedBuffer> buffer = dataOut;
-    if (buffer)
-        buffer->moveTo(data);
+    if (errorOut.reason) {
+        didFail(0, errorOut);
+        return;
+    }
+    didReceiveResponse(0, responseOut);
+    RefPtr<ResourceLoadInfo> resourceLoadInfo = responseOut.toResourceResponse().resourceLoadInfo();
+    m_host->didReceiveData(m_resource, dataOut.data(), dataOut.size(), resourceLoadInfo ? resourceLoadInfo->encodedDataLength : -1, m_options);
+    m_resource->setResourceBuffer(dataOut);
+    didFinishLoading(0, responseOut.responseTime());
 }
 
 }