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 26 matching lines @@
 #include "core/platform/SharedBuffer.h"
 #include "core/platform/chromium/support/WrappedResourceRequest.h"
 #include "core/platform/chromium/support/WrappedResourceResponse.h"
 #include "core/platform/network/ResourceError.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
 #include "wtf/Assertions.h"
+#include "wtf/CurrentTime.h"

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

Is this still needed?

 
 namespace WebCore {
 
 ResourceLoader::RequestCountTracker::RequestCountTracker(ResourceLoaderHost* host, Resource* resource)
     : m_host(host)
     , m_resource(resource)
 {
     m_host->incrementRequestCount(m_resource);
 }
 
 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();

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

This is moved to Resource.cpp so that Resource::m_loader is guaranteed non-null
when start() is called. Otherwise, if a sync request tries to revalidate a
resource and the revalidation fails, we might use-after-free when
Resource::canDelete() doesn't see a valid m_loader.

     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();
+    didReceiveData(0, dataOut.data(), dataOut.size(), resourceLoadInfo ? resourceLoadInfo->encodedDataLength : -1);

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

Does this introduce a memcpy?  Previously, we were able to move the data
directly from the network stack to |data|.  Now we're passing a pointer and a
length into didReceiveData.  Is it copied into a SharedBuffer by that function? 
We can look at the revision history, but I remember that this memcpy was blowing
through a ton of memory on some pages.

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

Yeah, I think it will memcpy. I guess we could expose a
setResourceBuffer(PassRefPtr<SharedBuffer>) on Resource for this.

+    didFinishLoading(0, monotonicallyIncreasingTime());
 }
 
 }