Move synchronously fetching to ResourceFetcher, as well as most of the logic

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 19 matching lines @@
 #include "bindings/v8/ScriptController.h"
 #include "core/dom/Document.h"
 #include "core/fetch/CSSStyleSheetResource.h"
 #include "core/fetch/DocumentResource.h"
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/FontResource.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/RawResource.h"
+#include "core/fetch/ResourceLoader.h"
 #include "core/fetch/ResourceLoaderSet.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/fetch/ShaderResource.h"
 #include "core/fetch/TextTrackResource.h"
 #include "core/fetch/XSLStyleSheetResource.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLImport.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/DocumentLoader.h"
@@ skipping 153 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)
+{
+    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;
+}
+
 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 750 matching lines @@
         m_documentResources.remove(*it);
 }
 
 void ResourceFetcher::performPostLoadActions()
 {
     checkForPendingPreloads();
 }
 
 void ResourceFetcher::notifyLoadedFromMemoryCache(Resource* resource)
 {
-    if (!frame() || resource->status() != Resource::Cached || m_validatedURLs.contains(resource->url()))
+    if (!frame() || !frame()->page() || resource->status() != Resource::Cached || m_validatedURLs.contains(resource->url()))
+        return;
+    if (!resource->shouldSendResourceLoadCallbacks())
         return;
 
-    // FIXME: If the WebKit client changes or cancels the request, WebCore does not respect this and continues the load.
-    frame()->loader()->loadedResourceFromMemoryCache(resource);
+    ResourceRequest request(resource->url());
+    unsigned long identifier = createUniqueIdentifier();
+    context().dispatchDidLoadResourceFromMemoryCache(request, resource->response());
+    // FIXME: If willSendRequest changes the request, we don't respect it.
+    willSendRequest(resource, request, ResourceResponse(), resource->options());
+    InspectorInstrumentation::markResourceAsCached(frame()->page(), identifier);
+    context().sendRemainingDelegateMessages(m_documentLoader, identifier, resource->response(), 0, resource->encodedSize(), 0, ResourceError());
 }
 
 void ResourceFetcher::incrementRequestCount(const Resource* res)
 {
     if (res->ignoreForRequestCount())
         return;
 
     ++m_requestCount;
 }
 
@@ skipping 288 matching lines @@
 }
 #endif
 
 const ResourceLoaderOptions& ResourceFetcher::defaultResourceOptions()
 {
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck, CheckContentSecurityPolicy, UseDefaultOriginRestrictionsForType, DocumentContext));
     return options;
 }
 
 }