Change all ResourceHandleClients to be SubresourceLoaderClients instead. Also,
make SubresourceLoader a ResourceHandleClient. This is a first step towards turning ResourceHandle into a
standalone class which doesn't need to know about SubresourceLoader.
* WebCore.xcodeproj/project.pbxproj:
* loader/ResourceLoader.cpp:
(WebCore::ResourceLoader::~ResourceLoader):
(WebCore::ResourceLoader::ResourceLoader):
(WebCore::ResourceLoader::setDefersLoading):
* loader/SubresourceLoader.cpp:
(WebCore::SubresourceLoader::SubresourceLoader):
(WebCore::SubresourceLoader::~SubresourceLoader):
(WebCore::SubresourceLoader::create):
(WebCore::SubresourceLoader::willSendRequest):
(WebCore::SubresourceLoader::didReceiveResponse):
(WebCore::SubresourceLoader::didReceiveData):
(WebCore::SubresourceLoader::didFinishLoading):
(WebCore::SubresourceLoader::didFailWithError):
(WebCore::SubresourceLoader::receivedAllData):
* loader/SubresourceLoader.h:
(WebCore::SubresourceLoader::loaderAsResourceHandleClient):
(WebCore::SubresourceLoader::handle):
* loader/SubresourceLoaderClient.h: Added.
(WebCore::SubresourceLoaderClient::~SubresourceLoaderClient):
(WebCore::SubresourceLoaderClient::willSendRequest):
(WebCore::SubresourceLoaderClient::didReceiveResponse):
(WebCore::SubresourceLoaderClient::didReceiveData):
(WebCore::SubresourceLoaderClient::didFinishLoading):
(WebCore::SubresourceLoaderClient::didFailWithError):
(WebCore::SubresourceLoaderClient::receivedAllData):
* loader/icon/IconLoader.cpp:
(WebCore::IconLoader::startLoading):
(WebCore::IconLoader::stopLoading):
(WebCore::IconLoader::didReceiveResponse):
(WebCore::IconLoader::didReceiveData):
(WebCore::IconLoader::didFailWithError):
(WebCore::IconLoader::didFinishLoading):
(WebCore::IconLoader::clearLoadingState):
* loader/icon/IconLoader.h:
* loader/loader.cpp:
(WebCore::Loader::servePendingRequests):
(WebCore::Loader::receivedAllData):
(WebCore::Loader::didFailWithError):
(WebCore::Loader::didReceiveResponse):
(WebCore::Loader::didReceiveData):
(WebCore::Loader::cancelRequests):
* loader/loader.h:
* loader/mac/SubresourceLoaderMac.mm:
(WebCore::SubresourceLoader::SubresourceLoader):
(WebCore::SubresourceLoader::create):
(WebCore::SubresourceLoader::willSendRequest):
(WebCore::SubresourceLoader::didReceiveResponse):
(WebCore::SubresourceLoader::didReceiveData):
(WebCore::SubresourceLoader::didFinishLoading):
(WebCore::SubresourceLoader::didFail):
(WebCore::SubresourceLoader::didCancel):
* platform/network/ResourceHandle.cpp:
(WebCore::ResourceHandle::ResourceHandle):
(WebCore::ResourceHandle::create):
* platform/network/ResourceHandle.h:
* platform/network/ResourceHandleClient.h:
* platform/network/ResourceHandleInternal.h:
(WebCore::ResourceHandleInternal::ResourceHandleInternal):
* platform/network/mac/ResourceHandleMac.mm:
(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::finishJobAndHandle):
(WebCore::ResourceHandle::loader):
* xml/xmlhttprequest.cpp:
(WebCore::XMLHttpRequest::send):
(WebCore::XMLHttpRequest::didFailWithError):
(WebCore::XMLHttpRequest::didFinishLoading):
(WebCore::XMLHttpRequest::willSendRequest):
(WebCore::XMLHttpRequest::didReceiveResponse):
(WebCore::XMLHttpRequest::didReceiveData):
* xml/xmlhttprequest.h:
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@18013
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2006-12-04 Anders Carlsson <acarlsson@apple.com>
+
+ Reviewed by Darin.
+
+ Change all ResourceHandleClients to be SubresourceLoaderClients instead. Also,
+ make SubresourceLoader a ResourceHandleClient. This is a first step towards turning ResourceHandle into a
+ standalone class which doesn't need to know about SubresourceLoader.
+
+ * WebCore.xcodeproj/project.pbxproj:
+ * loader/ResourceLoader.cpp:
+ (WebCore::ResourceLoader::~ResourceLoader):
+ (WebCore::ResourceLoader::ResourceLoader):
+ (WebCore::ResourceLoader::setDefersLoading):
+ * loader/SubresourceLoader.cpp:
+ (WebCore::SubresourceLoader::SubresourceLoader):
+ (WebCore::SubresourceLoader::~SubresourceLoader):
+ (WebCore::SubresourceLoader::create):
+ (WebCore::SubresourceLoader::willSendRequest):
+ (WebCore::SubresourceLoader::didReceiveResponse):
+ (WebCore::SubresourceLoader::didReceiveData):
+ (WebCore::SubresourceLoader::didFinishLoading):
+ (WebCore::SubresourceLoader::didFailWithError):
+ (WebCore::SubresourceLoader::receivedAllData):
+ * loader/SubresourceLoader.h:
+ (WebCore::SubresourceLoader::loaderAsResourceHandleClient):
+ (WebCore::SubresourceLoader::handle):
+ * loader/SubresourceLoaderClient.h: Added.
+ (WebCore::SubresourceLoaderClient::~SubresourceLoaderClient):
+ (WebCore::SubresourceLoaderClient::willSendRequest):
+ (WebCore::SubresourceLoaderClient::didReceiveResponse):
+ (WebCore::SubresourceLoaderClient::didReceiveData):
+ (WebCore::SubresourceLoaderClient::didFinishLoading):
+ (WebCore::SubresourceLoaderClient::didFailWithError):
+ (WebCore::SubresourceLoaderClient::receivedAllData):
+ * loader/icon/IconLoader.cpp:
+ (WebCore::IconLoader::startLoading):
+ (WebCore::IconLoader::stopLoading):
+ (WebCore::IconLoader::didReceiveResponse):
+ (WebCore::IconLoader::didReceiveData):
+ (WebCore::IconLoader::didFailWithError):
+ (WebCore::IconLoader::didFinishLoading):
+ (WebCore::IconLoader::clearLoadingState):
+ * loader/icon/IconLoader.h:
+ * loader/loader.cpp:
+ (WebCore::Loader::servePendingRequests):
+ (WebCore::Loader::receivedAllData):
+ (WebCore::Loader::didFailWithError):
+ (WebCore::Loader::didReceiveResponse):
+ (WebCore::Loader::didReceiveData):
+ (WebCore::Loader::cancelRequests):
+ * loader/loader.h:
+ * loader/mac/SubresourceLoaderMac.mm:
+ (WebCore::SubresourceLoader::SubresourceLoader):
+ (WebCore::SubresourceLoader::create):
+ (WebCore::SubresourceLoader::willSendRequest):
+ (WebCore::SubresourceLoader::didReceiveResponse):
+ (WebCore::SubresourceLoader::didReceiveData):
+ (WebCore::SubresourceLoader::didFinishLoading):
+ (WebCore::SubresourceLoader::didFail):
+ (WebCore::SubresourceLoader::didCancel):
+ * platform/network/ResourceHandle.cpp:
+ (WebCore::ResourceHandle::ResourceHandle):
+ (WebCore::ResourceHandle::create):
+ * platform/network/ResourceHandle.h:
+ * platform/network/ResourceHandleClient.h:
+ * platform/network/ResourceHandleInternal.h:
+ (WebCore::ResourceHandleInternal::ResourceHandleInternal):
+ * platform/network/mac/ResourceHandleMac.mm:
+ (WebCore::ResourceHandle::start):
+ (WebCore::ResourceHandle::finishJobAndHandle):
+ (WebCore::ResourceHandle::loader):
+ * xml/xmlhttprequest.cpp:
+ (WebCore::XMLHttpRequest::send):
+ (WebCore::XMLHttpRequest::didFailWithError):
+ (WebCore::XMLHttpRequest::didFinishLoading):
+ (WebCore::XMLHttpRequest::willSendRequest):
+ (WebCore::XMLHttpRequest::didReceiveResponse):
+ (WebCore::XMLHttpRequest::didReceiveData):
+ * xml/xmlhttprequest.h:
+
2006-12-04 Darin Adler <darin@apple.com>
Reviewed by Adele.
1A0D57410A5C7867007EDD4C /* JSOverflowEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A0D573F0A5C7867007EDD4C /* JSOverflowEvent.h */; };
1A1D13800A5325520064BF5F /* DOMXPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A1D137E0A5325520064BF5F /* DOMXPath.h */; settings = {ATTRIBUTES = (Private, ); }; };
1A1D13810A5325520064BF5F /* DOMXPath.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1A1D137F0A5325520064BF5F /* DOMXPath.mm */; };
+ 1A3178930B20A81600316987 /* SubresourceLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A3178920B20A81600316987 /* SubresourceLoaderClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
1A494BFA0A122F4400FDAFC1 /* JSHTMLElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A494BF80A122F4400FDAFC1 /* JSHTMLElement.cpp */; };
1A494BFB0A122F4400FDAFC1 /* JSHTMLElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A494BF90A122F4400FDAFC1 /* JSHTMLElement.h */; };
1A494E340A12358B00FDAFC1 /* JSHTMLDocument.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A494E320A12358A00FDAFC1 /* JSHTMLDocument.cpp */; };
1A0D573F0A5C7867007EDD4C /* JSOverflowEvent.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSOverflowEvent.h; sourceTree = "<group>"; };
1A1D137E0A5325520064BF5F /* DOMXPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DOMXPath.h; sourceTree = "<group>"; };
1A1D137F0A5325520064BF5F /* DOMXPath.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DOMXPath.mm; sourceTree = "<group>"; };
+ 1A3178920B20A81600316987 /* SubresourceLoaderClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SubresourceLoaderClient.h; sourceTree = "<group>"; };
1A494BBB0A122DCD00FDAFC1 /* HTMLElement.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = HTMLElement.idl; sourceTree = "<group>"; };
1A494BF80A122F4400FDAFC1 /* JSHTMLElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSHTMLElement.cpp; sourceTree = "<group>"; };
1A494BF90A122F4400FDAFC1 /* JSHTMLElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSHTMLElement.h; sourceTree = "<group>"; };
656D37270ADBA5DE00A4554D /* ResourceLoader.h */,
93E227DF0AF589AD00D48324 /* SubresourceLoader.cpp */,
656D37300ADBA5DE00A4554D /* SubresourceLoader.h */,
+ 1A3178920B20A81600316987 /* SubresourceLoaderClient.h */,
1A6937FF0A11100A00C127FE /* TextDocument.cpp */,
1A6938000A11100A00C127FE /* TextDocument.h */,
F523D27802DE43D7018635CA /* TextResourceDecoder.cpp */,
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
+ 1A3178930B20A81600316987 /* SubresourceLoaderClient.h in Headers */,
93F198E608245E59001E9ABC /* HTMLElement.h in Headers */,
93F198E508245E59001E9ABC /* HTMLDocument.h in Headers */,
93F198EF08245E59001E9ABC /* HTMLParser.h in Headers */,
#include "config.h"
#include "ResourceLoader.h"
+#include "Frame.h"
+#include "Page.h"
+
namespace WebCore {
+#if !PLATFORM(MAC)
+// FIXME: This is only temporary until ResourceLoader is truly platform independent.
+
+ResourceLoader::~ResourceLoader()
+{
+}
+
+ResourceLoader::ResourceLoader(Frame* frame)
+ : m_reachedTerminalState(false)
+ , m_cancelled(false)
+ , m_calledDidFinishLoad(false)
+ , m_frame(frame)
+ , m_defersLoading(frame->page()->defersLoading())
+{
+}
+
+void ResourceLoader::setDefersLoading(bool)
+{
+}
+
+#endif
+
}
#include "config.h"
#include "SubresourceLoader.h"
+#include "Document.h"
+#include "Frame.h"
+#include "ResourceHandle.h"
+#include "ResourceRequest.h"
+#include "SubresourceLoaderClient.h"
+
namespace WebCore {
+#if !PLATFORM(MAC)
+
+SubresourceLoader::SubresourceLoader(Frame* frame, SubresourceLoaderClient* client, ResourceHandle* handle)
+ : ResourceLoader(frame)
+ , m_client(client)
+ , m_handle(handle)
+ , m_loadingMultipartContent(false)
+{
+}
+
+SubresourceLoader::~SubresourceLoader()
+{
+}
+
+PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request)
+{
+ // FIXME: This is only temporary until we get the Mac version of SubresourceLoader::create cross-platform.
+ RefPtr<SubresourceLoader> subloader(new SubresourceLoader(frame, client, 0));
+
+ subloader->m_handle = ResourceHandle::create(request, subloader.get(), frame->document()->docLoader());
+
+ return subloader.release();
+}
+
+#endif
+
+void SubresourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
+{
+ if (m_client)
+ m_client->willSendRequest(this, request, redirectResponse);
+}
+
+void SubresourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
+{
+ if (m_client)
+ m_client->didReceiveResponse(this, response);
+}
+
+void SubresourceLoader::didReceiveData(ResourceHandle*, const char* data, int length)
+{
+ if (m_client)
+ m_client->didReceiveData(this, data, length);
+}
+
+void SubresourceLoader::didFinishLoading(ResourceHandle*)
+{
+ if (m_client) {
+ // We must protect the resource loader in case the call to receivedAllData causes a deref.
+ RefPtr<SubresourceLoader> protect(this);
+
+#if PLATFORM(MAC)
+ m_client->receivedAllData(this, resourceData());
+#else
+ m_client->receivedAllData(this, 0);
+#endif
+ m_client->didFinishLoading(this);
+ }
+}
+
+void SubresourceLoader::didFailWithError(ResourceHandle*, const ResourceError& error)
+{
+ if (m_client)
+ m_client->didFailWithError(this, error);
+}
+
+void SubresourceLoader::receivedAllData(ResourceHandle*, PlatformData data)
+{
+ if (m_client)
+ m_client->receivedAllData(this, data);
+}
+
}
#ifndef SubresourceLoader_H_
#define SubresourceLoader_H_
+#include "ResourceHandleClient.h"
#include "ResourceLoader.h"
#include <wtf/PassRefPtr.h>
class String;
class ResourceHandle;
class ResourceRequest;
+ class SubresourceLoaderClient;
- class SubresourceLoader : public ResourceLoader {
+ class SubresourceLoader : public ResourceLoader, ResourceHandleClient {
public:
- static PassRefPtr<SubresourceLoader> create(Frame*, ResourceHandle*, ResourceRequest&);
+ static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&);
+
+#if PLATFORM(MAC)
+ static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, ResourceHandle*, ResourceRequest&);
+#endif
virtual ~SubresourceLoader();
virtual void didReceiveData(NSData *, long long lengthReceived, bool allAtOnce);
virtual void didFinishLoading();
virtual void didFail(NSError *);
+
+ // FIXME: This function is here because we want ResourceHandleClient to be privately inherited, but
+ // ResourceHandle needs to be passed a ResourceHandleClient.
+ ResourceHandleClient* loaderAsResourceHandleClient() { return this; }
#endif
+ // ResourceHandleClient
+ virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);
+
+ virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
+ virtual void didReceiveData(ResourceHandle*, const char*, int);
+ virtual void didFinishLoading(ResourceHandle*);
+ virtual void didFailWithError(ResourceHandle*, const ResourceError&);
+
+ virtual void receivedAllData(ResourceHandle*, PlatformData);
+
+ ResourceHandle* handle() const { return m_handle.get(); }
private:
static PassRefPtr<SubresourceLoader> create(Frame*, ResourceHandle*,
NSMutableURLRequest *, NSDictionary *customHeaders, const String& referrer);
- SubresourceLoader(Frame*, ResourceHandle*);
+ SubresourceLoader(Frame*, SubresourceLoaderClient*, ResourceHandle*);
#if PLATFORM(MAC)
virtual void didCancel(NSError *);
#endif
-
+ SubresourceLoaderClient* m_client;
RefPtr<ResourceHandle> m_handle;
bool m_loadingMultipartContent;
};
--- /dev/null
+/*
+ * Copyright (C) 2006 Apple Computer, Inc. All rights reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SubresourceLoaderClient_h
+#define SubresourceLoaderClient_h
+
+// FIXME: This is just to define PlatformData, it should go away
+#include "ResourceHandleClient.h"
+
+namespace WebCore {
+
+class ResourceRequest;
+class ResourceResponse;
+class SubresourceLoader;
+
+class SubresourceLoaderClient {
+public:
+ virtual ~SubresourceLoaderClient() { }
+
+ // request may be modified
+ virtual void willSendRequest(SubresourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse) { }
+
+ virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&) { }
+ virtual void didReceiveData(SubresourceLoader*, const char*, int) { }
+ virtual void didFinishLoading(SubresourceLoader*) { }
+ virtual void didFailWithError(SubresourceLoader*, const ResourceError&) { }
+
+ // FIXME: Get rid of this function
+ virtual void receivedAllData(SubresourceLoader*, PlatformData) { }
+};
+
+}
+
+#endif
#include "ResourceHandle.h"
#include "ResourceResponse.h"
#include "ResourceRequest.h"
+#include "SubresourceLoader.h"
using namespace std;
void IconLoader::startLoading()
{
- if (m_handle)
+ if (m_resourceLoader)
return;
// FIXME: http://bugs.webkit.org/show_bug.cgi?id=10902
}
// Set flag so we can detect the case where the load completes before
- // ResourceHandle::create returns.
+ // SubresourceLoader::create returns.
m_loadIsInProgress = true;
m_buffer.reserveCapacity(defaultBufferSize);
- RefPtr<ResourceHandle> loader = ResourceHandle::create(m_frame->loader()->iconURL(),
- this, m_frame->document()->docLoader());
+ RefPtr<SubresourceLoader> loader = SubresourceLoader::create(m_frame, this, m_frame->loader()->iconURL());
if (!loader)
LOG_ERROR("Failed to start load for icon at url %s", m_frame->loader()->iconURL().url().ascii());
// Store the handle so we can cancel the load if stopLoading is called later.
// But only do it if the load hasn't already completed.
if (m_loadIsInProgress)
- m_handle = loader.release();
+ m_resourceLoader = loader.release();
}
void IconLoader::stopLoading()
{
- m_handle = 0;
+ m_resourceLoader = 0;
clearLoadingState();
}
-void IconLoader::didReceiveResponse(ResourceHandle* handle, const ResourceResponse& response)
+void IconLoader::didReceiveResponse(SubresourceLoader* resourceLoader, const ResourceResponse& response)
{
// If we got a status code indicating an invalid response, then lets
// ignore the data and not try to decode the error page as an icon.
int status = response.httpStatusCode();
if (status && (status < 200 || status > 299)) {
- KURL iconURL = handle->url();
- m_handle = 0;
+ KURL iconURL = resourceLoader->handle()->url();
+ m_resourceLoader = 0;
finishLoading(iconURL);
}
}
-void IconLoader::didReceiveData(ResourceHandle*, const char* data, int size)
+void IconLoader::didReceiveData(SubresourceLoader*, const char* data, int size)
{
ASSERT(data || size == 0);
ASSERT(size >= 0);
m_buffer.append(data, size);
}
-void IconLoader::didFailWithError(ResourceHandle* handle, const ResourceError&)
+void IconLoader::didFailWithError(SubresourceLoader* resourceLoader, const ResourceError&)
{
ASSERT(m_loadIsInProgress);
m_buffer.clear();
- finishLoading(handle->url());
+ finishLoading(resourceLoader->handle()->url());
}
-void IconLoader::didFinishLoading(ResourceHandle* handle)
+void IconLoader::didFinishLoading(SubresourceLoader* resourceLoader)
{
// If the icon load resulted in an error-response earlier, the ResourceHandle was killed and icon data commited via finishLoading().
// In that case this didFinishLoading callback is pointless and we bail. Otherwise, finishLoading() as expected
if (m_loadIsInProgress) {
- ASSERT(handle == m_handle);
- finishLoading(handle->url());
+ ASSERT(resourceLoader == m_resourceLoader);
+ finishLoading(resourceLoader->handle()->url());
}
}
void IconLoader::clearLoadingState()
{
- m_handle = 0;
+ m_resourceLoader = 0;
m_buffer.clear();
m_loadIsInProgress = false;
}
#define ICONLOADER_H_
#include "KURL.h"
-#include "ResourceHandleClient.h"
+#include "SubresourceLoaderClient.h"
#include <memory>
#include <wtf/Noncopyable.h>
#include <wtf/Vector.h>
class Frame;
-class IconLoader : public ResourceHandleClient, Noncopyable {
+class IconLoader : private SubresourceLoaderClient, Noncopyable {
public:
static std::auto_ptr<IconLoader> create(Frame*);
~IconLoader();
private:
IconLoader(Frame*);
- virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
- virtual void didReceiveData(ResourceHandle*, const char*, int);
- virtual void didFinishLoading(ResourceHandle*);
- virtual void didFailWithError(ResourceHandle*, const ResourceError&);
+ virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&);
+ virtual void didReceiveData(SubresourceLoader*, const char*, int);
+ virtual void didFinishLoading(SubresourceLoader*);
+ virtual void didFailWithError(SubresourceLoader*, const ResourceError&);
void finishLoading(const KURL&);
void clearLoadingState();
Frame* m_frame;
- RefPtr<ResourceHandle> m_handle;
+ RefPtr<SubresourceLoader> m_resourceLoader;
Vector<char> m_buffer;
bool m_loadIsInProgress;
}; // class IconLoader
#include "ResourceHandle.h"
#include "ResourceRequest.h"
#include "ResourceResponse.h"
+#include "SubresourceLoader.h"
#include <wtf/Assertions.h>
#include <wtf/Vector.h>
domain = static_cast<HTMLDocument*>(req->docLoader()->doc())->domain().deprecatedString();
}
- RefPtr<ResourceHandle> loader = ResourceHandle::create(request, this, req->docLoader());
+ RefPtr<SubresourceLoader> loader = SubresourceLoader::create(req->docLoader()->doc()->frame(), this, request);
if (loader)
m_requestsLoading.add(loader.release(), req);
}
-void Loader::receivedAllData(ResourceHandle* job, PlatformData allData)
+void Loader::receivedAllData(SubresourceLoader* loader, PlatformData allData)
{
- RequestMap::iterator i = m_requestsLoading.find(job);
+ loader->ref();
+ RequestMap::iterator i = m_requestsLoading.find(loader);
if (i == m_requestsLoading.end())
return;
servePendingRequests();
}
-void Loader::didFailWithError(ResourceHandle* handle, const ResourceError& error)
+void Loader::didFailWithError(SubresourceLoader* loader, const ResourceError& error)
{
- RequestMap::iterator i = m_requestsLoading.find(handle);
+ ASSERT(loader->handle());
+ RequestMap::iterator i = m_requestsLoading.find(loader);
if (i == m_requestsLoading.end())
return;
servePendingRequests();
}
-void Loader::didReceiveResponse(ResourceHandle* handle, const ResourceResponse& response)
+void Loader::didReceiveResponse(SubresourceLoader* loader, const ResourceResponse& response)
{
- Request* req = m_requestsLoading.get(handle);
+ ASSERT(loader->handle());
+ Request* req = m_requestsLoading.get(loader);
ASSERT(req);
req->cachedResource()->setResponse(response);
static_cast<CachedImage*>(req->cachedResource())->clear();
if (req->docLoader()->frame())
req->docLoader()->frame()->loader()->checkCompleted();
- } else if (response.isMultipart()) {
+ } else if (response.isMultipart()) {
req->setIsMultipart(true);
if (!req->cachedResource()->isImage())
- handle->cancel();
+ loader->handle()->cancel();
}
}
-void Loader::didReceiveData(ResourceHandle* job, const char* data, int size)
+void Loader::didReceiveData(SubresourceLoader* loader, const char* data, int size)
{
- Request* request = m_requestsLoading.get(job);
+ ASSERT(loader->handle());
+ Request* request = m_requestsLoading.get(loader);
if (!request)
return;
++pIt;
}
- Vector<ResourceHandle*, 256> jobsToCancel;
+ Vector<SubresourceLoader*, 256> loadersToCancel;
RequestMap::iterator end = m_requestsLoading.end();
for (RequestMap::iterator i = m_requestsLoading.begin(); i != end; ++i) {
Request* r = i->second;
if (r->docLoader() == dl)
- jobsToCancel.append(i->first.get());
+ loadersToCancel.append(i->first.get());
}
- for (unsigned i = 0; i < jobsToCancel.size(); ++i) {
- ResourceHandle* job = jobsToCancel[i];
- Request* r = m_requestsLoading.get(job);
- m_requestsLoading.remove(job);
+ for (unsigned i = 0; i < loadersToCancel.size(); ++i) {
+ SubresourceLoader* loader = loadersToCancel[i];
+ Request* r = m_requestsLoading.get(loader);
+ m_requestsLoading.remove(loader);
cache()->remove(r->cachedResource());
}
m_requestsBackgroundDecoding.remove(r);
}
-ResourceHandle* Loader::jobForRequest(const String& URL) const
-{
- RequestMap::const_iterator end = m_requestsLoading.end();
- for (RequestMap::const_iterator i = m_requestsLoading.begin(); i != end; ++i) {
- CachedResource* obj = i->second->cachedResource();
- if (obj && obj->url() == URL)
- return i->first.get();
- }
- return 0;
-}
-
} //namespace WebCore
#ifndef loader_h
#define loader_h
-#include "ResourceHandleClient.h"
+#include "SubresourceLoaderClient.h"
#include <wtf/HashMap.h>
#include "DeprecatedPtrList.h"
class Request;
class String;
- class Loader : ResourceHandleClient
- {
+ class Loader : private SubresourceLoaderClient {
public:
Loader();
~Loader();
void removeBackgroundDecodingRequest(Request*);
- // may return 0
- ResourceHandle* jobForRequest(const String& URL) const;
-
private:
- virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
- virtual void didReceiveData(ResourceHandle*, const char*, int);
- virtual void receivedAllData(ResourceHandle*, PlatformData);
- virtual void didFailWithError(ResourceHandle*, const ResourceError&);
+ virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&);
+ virtual void didReceiveData(SubresourceLoader*, const char*, int);
+ virtual void receivedAllData(SubresourceLoader*, PlatformData);
+ virtual void didFailWithError(SubresourceLoader*, const ResourceError&);
void servePendingRequests();
DeprecatedPtrList<Request> m_requestsPending;
- typedef HashMap<RefPtr<ResourceHandle>, Request*> RequestMap;
+ typedef HashMap<RefPtr<SubresourceLoader>, Request*> RequestMap;
RequestMap m_requestsLoading;
DeprecatedPtrList<Request> m_requestsBackgroundDecoding;
#import "config.h"
#import "SubresourceLoader.h"
+#import "Document.h"
#import "FormDataStreamMac.h"
#import "FrameLoader.h"
#import "FrameMac.h"
#import "LoaderFunctions.h"
#import "LoaderNSURLExtras.h"
#import "LoaderNSURLRequestExtras.h"
+#import "ResourceError.h"
#import "ResourceHandle.h"
#import "ResourceRequest.h"
+#import "ResourceResponse.h"
+#import "SubresourceLoaderClient.h"
#import "WebCoreSystemInterface.h"
#import <Foundation/NSURLResponse.h>
#import <wtf/Assertions.h>
namespace WebCore {
-SubresourceLoader::SubresourceLoader(Frame* frame, ResourceHandle* handle)
+SubresourceLoader::SubresourceLoader(Frame* frame, SubresourceLoaderClient* client, ResourceHandle* handle)
: ResourceLoader(frame)
+ , m_client(client)
, m_handle(handle)
, m_loadingMultipartContent(false)
{
frameLoader()->addSubresourceLoader(this);
}
-SubresourceLoader::~SubresourceLoader()
+PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request)
{
+ if (!frame)
+ return 0;
+
+ RefPtr<ResourceHandle> handle = ResourceHandle::create(request, 0, frame->document()->docLoader(), client);
+
+ if (!handle)
+ return 0;
+
+ return handle->loader();
}
-PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, ResourceHandle* handle, ResourceRequest& request)
+PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, ResourceHandle* handle, ResourceRequest& request)
{
FrameLoader* fl = frame->loader();
if (fl->state() == FrameStateProvisional)
- return nil;
+ return 0;
// Since this is a subresource, we can load any URL (we ignore the return value).
// But we still want to know whether we should hide the referrer or not, so we call the canLoadURL method.
fl->addExtraFieldsToRequest(newRequest, false, false);
- RefPtr<SubresourceLoader> subloader(new SubresourceLoader(frame, handle));
+ RefPtr<SubresourceLoader> subloader(new SubresourceLoader(frame, client, handle));
if (!subloader->load(newRequest))
return 0;
NSURLRequest *clientRequest = ResourceLoader::willSendRequest(newRequest, redirectResponse);
if (clientRequest && oldURL != [clientRequest URL] && ![oldURL isEqual:[clientRequest URL]])
clientRequest = m_handle->willSendRequest(clientRequest, redirectResponse);
+
return clientRequest;
}
RefPtr<SubresourceLoader> protect(this);
m_handle->didReceiveResponse(r);
+
// The loader can cancel a load if it receives a multipart response for a non-image
if (reachedTerminalState())
return;
// So don't deliver any data to the loader yet.
if (!m_loadingMultipartContent)
m_handle->addData(data);
+
ResourceLoader::didReceiveData(data, lengthReceived, allAtOnce);
}
// Calling removeSubresourceLoader will likely result in a call to deref, so we must protect ourselves.
RefPtr<SubresourceLoader> protect(this);
- if (RefPtr<ResourceHandle> handle = m_handle.release())
+ if (RefPtr<ResourceHandle> handle = m_handle) {
handle->finishJobAndHandle(resourceData());
+ // FIXME: Once SubresourceLoader::handle() is removed, we can move back .release() to the assignment expression
+ m_handle = 0;
+ }
if (cancelled())
return;
// Calling removeSubresourceLoader will likely result in a call to deref, so we must protect ourselves.
RefPtr<SubresourceLoader> protect(this);
- if (RefPtr<ResourceHandle> handle = m_handle.release())
+ if (RefPtr<ResourceHandle> handle = m_handle) {
handle->reportError(error);
-
+ // FIXME: Once SubresourceLoader::handle() is removed, we can move back .release() to the assignment expression
+ m_handle = 0;
+ }
+
if (cancelled())
return;
frameLoader()->removeSubresourceLoader(this);
// Calling removeSubresourceLoader will likely result in a call to deref, so we must protect ourselves.
RefPtr<SubresourceLoader> protect(this);
-
- if (RefPtr<ResourceHandle> handle = m_handle.release())
+
+ if (RefPtr<ResourceHandle> handle = m_handle) {
handle->reportError(error);
+ // FIXME: Once SubresourceLoader::handle() is removed, we can move back .release() to the assignment expression
+ m_handle = 0;
+ }
if (cancelled())
return;
namespace WebCore {
-ResourceHandle::ResourceHandle(const ResourceRequest& request, ResourceHandleClient* client)
- : d(new ResourceHandleInternal(this, request, client))
+ResourceHandle::ResourceHandle(const ResourceRequest& request, ResourceHandleClient* client, SubresourceLoaderClient* loaderClient)
+ : d(new ResourceHandleInternal(this, request, client, loaderClient))
{
}
-PassRefPtr<ResourceHandle> ResourceHandle::create(const ResourceRequest& request, ResourceHandleClient* client, DocLoader* dl)
+PassRefPtr<ResourceHandle> ResourceHandle::create(const ResourceRequest& request, ResourceHandleClient* client, DocLoader* dl, SubresourceLoaderClient* loaderClient)
{
- RefPtr<ResourceHandle> newLoader(new ResourceHandle(request, client));
+ RefPtr<ResourceHandle> newLoader(new ResourceHandle(request, client, loaderClient));
if (newLoader->start(dl))
return newLoader.release();
class FormData;
class KURL;
class ResourceHandleInternal;
+class SubresourceLoader;
+class SubresourceLoaderClient;
struct ResourceRequest;
class ResourceHandle : public Shared<ResourceHandle> {
private:
- ResourceHandle(const ResourceRequest&, ResourceHandleClient*);
+ ResourceHandle(const ResourceRequest&, ResourceHandleClient*, SubresourceLoaderClient*);
public:
// FIXME: should not need the DocLoader
- static PassRefPtr<ResourceHandle> create(const ResourceRequest&, ResourceHandleClient*, DocLoader*);
+ static PassRefPtr<ResourceHandle> create(const ResourceRequest&, ResourceHandleClient*, DocLoader*, SubresourceLoaderClient* = 0);
~ResourceHandle();
void addData(NSData *);
void finishJobAndHandle(NSData *);
void reportError(NSError* error);
+ SubresourceLoader* loader() const;
#endif
#if USE(WININET)
void cancel();
ResourceHandleClient* client() const;
-
+
const HTTPHeaderMap& requestHeaders() const;
const KURL& url() const;
const String& method() const;
// cached response may be modified
// void willCacheResponse(ResourceHandle*, CachedResourceResponse&) { }
-
- // old-style methods
- virtual void receivedResponse(ResourceHandle*, PlatformResponse) { }
- virtual void receivedAllData(ResourceHandle*, PlatformData) { }
};
}
class ResourceHandleInternal
{
public:
- ResourceHandleInternal(ResourceHandle* loader, const ResourceRequest& request, ResourceHandleClient* c)
+ ResourceHandleInternal(ResourceHandle* loader, const ResourceRequest& request, ResourceHandleClient* c, SubresourceLoaderClient* client)
: m_client(c)
+ , m_subresourceLoaderClient(client)
, m_request(request)
, status(0)
, m_loading(false)
ResourceHandleClient* client() const { return m_client; }
ResourceHandleClient* m_client;
+
+ // FIXME: This is only used on mac and should be removed when ResourceHandle no longer depends on SubresourceLoader.
+ SubresourceLoaderClient* m_subresourceLoaderClient;
ResourceRequest m_request;
#if USE(CFNETWORK)
CFURLConnectionRef m_connection;
#elif PLATFORM(MAC)
- RefPtr<WebCore::SubresourceLoader> m_subresourceLoader;
+ RefPtr<SubresourceLoader> m_subresourceLoader;
#endif
#if USE(WININET)
HANDLE m_fileHandle;
if (!frame->page())
return false;
- d->m_subresourceLoader = SubresourceLoader::create(frame, this, d->m_request);
-
+ d->m_subresourceLoader = SubresourceLoader::create(frame, d->m_subresourceLoaderClient, this, d->m_request);
+ d->m_client = d->m_subresourceLoader->loaderAsResourceHandleClient();
+
if (d->m_subresourceLoader)
return true;
void ResourceHandle::finishJobAndHandle(NSData *data)
{
- if (ResourceHandleClient* c = client()) {
- // We must protect the resource handle in case the call to receivedAllData causes a deref.
- RefPtr<ResourceHandle> protect(this);
- c->receivedAllData(this, data);
+ if (ResourceHandleClient* c = client())
c->didFinishLoading(this);
- }
}
void ResourceHandle::reportError(NSError* error)
c->didFailWithError(this, error);
}
+SubresourceLoader* ResourceHandle::loader() const
+{
+ return d->m_subresourceLoader.get();
+}
+
} // namespace WebCore
#include "ResourceHandle.h"
#include "ResourceRequest.h"
#include "Settings.h"
+#include "SubresourceLoader.h"
#include "TextEncoding.h"
#include "kjs_binding.h"
#include <kjs/protect.h>
// create can return null here, for example if we're no longer attached to a page.
// this is true while running onunload handlers
// FIXME: Maybe create can return false for other reasons too?
- m_loader = ResourceHandle::create(request, this, m_doc->docLoader());
+ m_loader = SubresourceLoader::create(m_doc->frame(), this, request);
}
void XMLHttpRequest::abort()
didFinishLoading(0);
}
-void XMLHttpRequest::didFailWithError(ResourceHandle* handle, const ResourceError&)
+void XMLHttpRequest::didFailWithError(SubresourceLoader* loader, const ResourceError&)
{
- didFinishLoading(handle);
+ didFinishLoading(loader);
}
-void XMLHttpRequest::didFinishLoading(ResourceHandle* handle)
+void XMLHttpRequest::didFinishLoading(SubresourceLoader* loader)
{
if (m_aborted)
return;
- ASSERT(handle == m_loader.get());
+ ASSERT(loader == m_loader);
if (m_state < Sent)
changeState(Sent);
}
}
-void XMLHttpRequest::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
+void XMLHttpRequest::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse)
{
if (!urlMatchesDocumentDomain(request.url()))
abort();
}
-void XMLHttpRequest::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
+void XMLHttpRequest::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
{
m_response = response;
m_encoding = getCharset(m_mimeTypeOverride);
}
-void XMLHttpRequest::didReceiveData(ResourceHandle*, const char* data, int len)
+void XMLHttpRequest::didReceiveData(SubresourceLoader*, const char* data, int len)
{
if (m_state < Sent)
changeState(Sent);
#include <wtf/HashMap.h>
#include <wtf/Vector.h>
#include "KURL.h"
-#include "ResourceHandleClient.h"
#include "ResourceResponse.h"
#include "PlatformString.h"
#include "HTTPHeaderMap.h"
#include "StringHash.h"
+#include "SubresourceLoaderClient.h"
namespace WebCore {
Loaded = 4 // The data transfer has been completed.
};
-class XMLHttpRequest : public Shared<XMLHttpRequest>, ResourceHandleClient {
+class XMLHttpRequest : public Shared<XMLHttpRequest>, private SubresourceLoaderClient {
public:
XMLHttpRequest(Document*);
~XMLHttpRequest();
private:
bool urlMatchesDocumentDomain(const KURL&) const;
- virtual void willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse);
- virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
- virtual void didReceiveData(ResourceHandle*, const char* data, int size);
- virtual void didFailWithError(ResourceHandle*, const ResourceError&);
- virtual void didFinishLoading(ResourceHandle*);
+ virtual void willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse);
+ virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&);
+ virtual void didReceiveData(SubresourceLoader*, const char* data, int size);
+ virtual void didFailWithError(SubresourceLoader*, const ResourceError&);
+ virtual void didFinishLoading(SubresourceLoader*);
void processSyncLoadResults(const Vector<char>& data, const ResourceResponse&);
String m_mimeTypeOverride;
bool m_async;
- RefPtr<ResourceHandle> m_loader;
+ RefPtr<SubresourceLoader> m_loader;
XMLHttpRequestState m_state;
ResourceResponse m_response;
git://git.webkit.org / WebKit-https.git / commitdiff