Rubber-stamped by Maciej.

        
        Move most of ResourceLoader and MainResourceLoader into the platform-independent files.
        
        * WebCore.xcodeproj/project.pbxproj:
        * loader/FrameLoader.cpp:
        (WebCore::FrameLoader::didFinishLoad):
        * loader/MainResourceLoader.cpp:
        (WebCore::MainResourceLoader::MainResourceLoader):
        (WebCore::MainResourceLoader::~MainResourceLoader):
        (WebCore::MainResourceLoader::create):
        (WebCore::MainResourceLoader::receivedError):
        (WebCore::MainResourceLoader::didCancel):
        (WebCore::MainResourceLoader::interruptionForPolicyChangeError):
        (WebCore::MainResourceLoader::stopLoadingForPolicyChange):
        (WebCore::MainResourceLoader::callContinueAfterNavigationPolicy):
        (WebCore::MainResourceLoader::continueAfterNavigationPolicy):
        (WebCore::MainResourceLoader::isPostOrRedirectAfterPost):
        (WebCore::MainResourceLoader::addData):
        (WebCore::MainResourceLoader::willSendRequest):
        (WebCore::shouldLoadAsEmptyDocument):
        (WebCore::MainResourceLoader::continueAfterContentPolicy):
        (WebCore::MainResourceLoader::callContinueAfterContentPolicy):
        (WebCore::MainResourceLoader::didReceiveResponse):
        (WebCore::MainResourceLoader::didReceiveData):
        (WebCore::MainResourceLoader::didFinishLoading):
        (WebCore::MainResourceLoader::didFail):
        (WebCore::MainResourceLoader::loadNow):
        (WebCore::MainResourceLoader::load):
        (WebCore::MainResourceLoader::setDefersLoading):
        * loader/MainResourceLoader.h:
        * loader/ResourceLoader.cpp:
        (WebCore::ResourceLoader::ResourceLoader):
        (WebCore::ResourceLoader::~ResourceLoader):
        (WebCore::ResourceLoader::releaseResources):
        (WebCore::ResourceLoader::load):
        (WebCore::ResourceLoader::setDefersLoading):
        (WebCore::ResourceLoader::frameLoader):
        (WebCore::ResourceLoader::addData):
        (WebCore::ResourceLoader::clearResourceData):
        (WebCore::ResourceLoader::willSendRequest):
        (WebCore::ResourceLoader::didReceiveResponse):
        (WebCore::ResourceLoader::didReceiveData):
        (WebCore::ResourceLoader::willStopBufferingData):
        (WebCore::ResourceLoader::didFinishLoading):
        (WebCore::ResourceLoader::didFinishLoadingOnePart):
        (WebCore::ResourceLoader::didFail):
        (WebCore::ResourceLoader::didCancel):
        (WebCore::ResourceLoader::cancel):
        (WebCore::ResourceLoader::response):
        (WebCore::ResourceLoader::cancelledError):
        * loader/ResourceLoader.h:
        (WebCore::ResourceLoader::willStopBufferingData):
        (WebCore::ResourceLoader::setRequest):
        * loader/mac/FrameLoaderMac.mm:
        * loader/mac/MainResourceLoaderMac.mm: Removed.
        * loader/mac/ResourceLoaderMac.mm:



git-svn-id: svn://svn.chromium.org/blink/trunk@18743 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/WebCore/ChangeLog

+2007-01-10  Anders Carlsson  <acarlsson@apple.com>
+
+        Rubber-stamped by Maciej.
+        
+        Move most of ResourceLoader and MainResourceLoader into the platform-independent files.
+        
+        * WebCore.xcodeproj/project.pbxproj:
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::didFinishLoad):
+        * loader/MainResourceLoader.cpp:
+        (WebCore::MainResourceLoader::MainResourceLoader):
+        (WebCore::MainResourceLoader::~MainResourceLoader):
+        (WebCore::MainResourceLoader::create):
+        (WebCore::MainResourceLoader::receivedError):
+        (WebCore::MainResourceLoader::didCancel):
+        (WebCore::MainResourceLoader::interruptionForPolicyChangeError):
+        (WebCore::MainResourceLoader::stopLoadingForPolicyChange):
+        (WebCore::MainResourceLoader::callContinueAfterNavigationPolicy):
+        (WebCore::MainResourceLoader::continueAfterNavigationPolicy):
+        (WebCore::MainResourceLoader::isPostOrRedirectAfterPost):
+        (WebCore::MainResourceLoader::addData):
+        (WebCore::MainResourceLoader::willSendRequest):
+        (WebCore::shouldLoadAsEmptyDocument):
+        (WebCore::MainResourceLoader::continueAfterContentPolicy):
+        (WebCore::MainResourceLoader::callContinueAfterContentPolicy):
+        (WebCore::MainResourceLoader::didReceiveResponse):
+        (WebCore::MainResourceLoader::didReceiveData):
+        (WebCore::MainResourceLoader::didFinishLoading):
+        (WebCore::MainResourceLoader::didFail):
+        (WebCore::MainResourceLoader::loadNow):
+        (WebCore::MainResourceLoader::load):
+        (WebCore::MainResourceLoader::setDefersLoading):
+        * loader/MainResourceLoader.h:
+        * loader/ResourceLoader.cpp:
+        (WebCore::ResourceLoader::ResourceLoader):
+        (WebCore::ResourceLoader::~ResourceLoader):
+        (WebCore::ResourceLoader::releaseResources):
+        (WebCore::ResourceLoader::load):
+        (WebCore::ResourceLoader::setDefersLoading):
+        (WebCore::ResourceLoader::frameLoader):
+        (WebCore::ResourceLoader::addData):
+        (WebCore::ResourceLoader::clearResourceData):
+        (WebCore::ResourceLoader::willSendRequest):
+        (WebCore::ResourceLoader::didReceiveResponse):
+        (WebCore::ResourceLoader::didReceiveData):
+        (WebCore::ResourceLoader::willStopBufferingData):
+        (WebCore::ResourceLoader::didFinishLoading):
+        (WebCore::ResourceLoader::didFinishLoadingOnePart):
+        (WebCore::ResourceLoader::didFail):
+        (WebCore::ResourceLoader::didCancel):
+        (WebCore::ResourceLoader::cancel):
+        (WebCore::ResourceLoader::response):
+        (WebCore::ResourceLoader::cancelledError):
+        * loader/ResourceLoader.h:
+        (WebCore::ResourceLoader::willStopBufferingData):
+        (WebCore::ResourceLoader::setRequest):
+        * loader/mac/FrameLoaderMac.mm:
+        * loader/mac/MainResourceLoaderMac.mm: Removed.
+        * loader/mac/ResourceLoaderMac.mm:
+
 2007-01-10  Lars Knoll <lars@trolltech.com>
 
         Move files to the correct location,

third_party/WebKit/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -379,7 +379,6 @@
 		656D373F0ADBA5DE00A4554D /* ResourceLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 656D37270ADBA5DE00A4554D /* ResourceLoader.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		656D37400ADBA5DE00A4554D /* ResourceLoaderMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 656D37280ADBA5DE00A4554D /* ResourceLoaderMac.mm */; };
 		656D37410ADBA5DE00A4554D /* MainResourceLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 656D37290ADBA5DE00A4554D /* MainResourceLoader.h */; };
-		656D37420ADBA5DE00A4554D /* MainResourceLoaderMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 656D372A0ADBA5DE00A4554D /* MainResourceLoaderMac.mm */; };
 		656D37430ADBA5DE00A4554D /* NetscapePlugInStreamLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 656D372B0ADBA5DE00A4554D /* NetscapePlugInStreamLoader.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		656D37440ADBA5DE00A4554D /* NetscapePlugInStreamLoaderMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 656D372C0ADBA5DE00A4554D /* NetscapePlugInStreamLoaderMac.mm */; };
 		656D37450ADBA5DE00A4554D /* WebPlugInStreamLoaderDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 656D372D0ADBA5DE00A4554D /* WebPlugInStreamLoaderDelegate.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -3445,7 +3444,6 @@
 		656D37270ADBA5DE00A4554D /* ResourceLoader.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ResourceLoader.h; sourceTree = "<group>"; };
 		656D37280ADBA5DE00A4554D /* ResourceLoaderMac.mm */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 30; path = ResourceLoaderMac.mm; sourceTree = "<group>"; };
 		656D37290ADBA5DE00A4554D /* MainResourceLoader.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = MainResourceLoader.h; sourceTree = "<group>"; };
-		656D372A0ADBA5DE00A4554D /* MainResourceLoaderMac.mm */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 30; path = MainResourceLoaderMac.mm; sourceTree = "<group>"; };
 		656D372B0ADBA5DE00A4554D /* NetscapePlugInStreamLoader.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NetscapePlugInStreamLoader.h; sourceTree = "<group>"; };
 		656D372C0ADBA5DE00A4554D /* NetscapePlugInStreamLoaderMac.mm */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 30; path = NetscapePlugInStreamLoaderMac.mm; sourceTree = "<group>"; };
 		656D372D0ADBA5DE00A4554D /* WebPlugInStreamLoaderDelegate.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = WebPlugInStreamLoaderDelegate.h; sourceTree = "<group>"; };
@@ -4563,7 +4561,7 @@
 		93CD4FDD0995F9EA007ECC97 /* StringImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringImpl.h; sourceTree = "<group>"; };
 		93CD4FEB0995FD2A007ECC97 /* PlatformString.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformString.h; sourceTree = "<group>"; };
 		93E227DB0AF589AD00D48324 /* DocumentLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; path = DocumentLoader.cpp; sourceTree = "<group>"; };
-		93E227DC0AF589AD00D48324 /* MainResourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MainResourceLoader.cpp; sourceTree = "<group>"; };
+		93E227DC0AF589AD00D48324 /* MainResourceLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; path = MainResourceLoader.cpp; sourceTree = "<group>"; };
 		93E227DD0AF589AD00D48324 /* NetscapePlugInStreamLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetscapePlugInStreamLoader.cpp; sourceTree = "<group>"; };
 		93E227DE0AF589AD00D48324 /* ResourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResourceLoader.cpp; sourceTree = "<group>"; };
 		93E227DF0AF589AD00D48324 /* SubresourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SubresourceLoader.cpp; sourceTree = "<group>"; };
@@ -7800,7 +7798,6 @@
 				656D371B0ADBA5DE00A4554D /* LoaderNSURLExtras.m */,
 				6563A9A50ADF4094000ED2CD /* LoaderNSURLRequestExtras.h */,
 				6563A9A60ADF4094000ED2CD /* LoaderNSURLRequestExtras.m */,
-				656D372A0ADBA5DE00A4554D /* MainResourceLoaderMac.mm */,
 				656D372C0ADBA5DE00A4554D /* NetscapePlugInStreamLoaderMac.mm */,
 				656D37280ADBA5DE00A4554D /* ResourceLoaderMac.mm */,
 				656D37310ADBA5DE00A4554D /* SubresourceLoaderMac.mm */,
@@ -12107,7 +12104,6 @@
 				656D373B0ADBA5DE00A4554D /* FormState.cpp in Sources */,
 				656D373D0ADBA5DE00A4554D /* FrameLoaderMac.mm in Sources */,
 				656D37400ADBA5DE00A4554D /* ResourceLoaderMac.mm in Sources */,
-				656D37420ADBA5DE00A4554D /* MainResourceLoaderMac.mm in Sources */,
 				656D37440ADBA5DE00A4554D /* NetscapePlugInStreamLoaderMac.mm in Sources */,
 				656D37490ADBA5DE00A4554D /* SubresourceLoaderMac.mm in Sources */,
 				0668E1900ADD9640004128E0 /* PopupMenuMac.mm in Sources */,

third_party/WebKit/WebCore/loader/FrameLoader.cpp

@@ -4055,6 +4055,12 @@ ResourceError FrameLoader::fileDoesNotExistError(const ResourceResponse& respons
     return m_client->fileDoesNotExistError(response);    
 }
 
+void FrameLoader::didFinishLoad(ResourceLoader* loader)
+{    
+    m_client->completeProgress(loader->identifier());
+    m_client->dispatchDidFinishLoading(activeDocumentLoader(), loader->identifier());
+}
+
 PassRefPtr<SharedBuffer> FrameLoader::mainResourceData() const
 {
     if (!m_mainResourceLoader)

third_party/WebKit/WebCore/loader/MainResourceLoader.h

@@ -45,27 +45,22 @@ namespace WebCore {
 
         virtual void setDefersLoading(bool);
 
-#if PLATFORM(MAC)
         virtual void willSendRequest(ResourceRequest&, const ResourceResponse& redirectResponse);
         virtual void didReceiveResponse(const ResourceResponse&);
         virtual void didReceiveData(const char*, int, long long lengthReceived, bool allAtOnce);
         virtual void didFinishLoading();
         virtual void didFail(const ResourceError&);
-#endif
 
     private:
         MainResourceLoader(Frame*);
 
         virtual void didCancel(const ResourceError&);
 
-#if PLATFORM(MAC)
         bool loadNow(ResourceRequest&);
-#endif
 
         void receivedError(const ResourceError&);
         ResourceError interruptionForPolicyChangeError() const;
         void stopLoadingForPolicyChange();
-#if PLATFORM(MAC)
         bool isPostOrRedirectAfterPost(const ResourceRequest& newRequest, const ResourceResponse& redirectResponse);
 
         static void callContinueAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
@@ -76,7 +71,6 @@ namespace WebCore {
         void continueAfterContentPolicy(PolicyAction, const ResourceResponse&);
 
         ResourceRequest m_initialRequest;
-#endif
 
         bool m_loadingMultipartContent;
         bool m_waitingForContentPolicy;

third_party/WebKit/WebCore/loader/ResourceLoader.cpp

@@ -30,8 +30,10 @@
 #include "ResourceLoader.h"
 
 #include "Frame.h"
+#include "FrameLoader.h"
 #include "Page.h"
 #include "ResourceHandle.h"
+#include "ResourceError.h"
 #include "SharedBuffer.h"
 
 namespace WebCore {
@@ -47,46 +49,274 @@ PassRefPtr<SharedBuffer> ResourceLoader::resourceData()
     return 0;
 }
 
-#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)
+#if PLATFORM(MAC)
+    , m_currentConnectionChallenge(nil)
+#endif
     , m_defersLoading(frame->page()->defersLoading())
 {
 }
 
-void ResourceLoader::setDefersLoading(bool)
+ResourceLoader::~ResourceLoader()
+{
+    // FIXME: Once everything uses the loader, enable this assert again
+    ASSERT(m_reachedTerminalState);
+}
+
+void ResourceLoader::releaseResources()
+{
+    ASSERT(!m_reachedTerminalState);
+    
+    // It's possible that when we release the handle, it will be
+    // deallocated and release the last reference to this object.
+    // We need to retain to avoid accessing the object after it
+    // has been deallocated and also to avoid reentering this method.
+    RefPtr<ResourceLoader> protector(this);
+
+    m_frame = 0;
+
+    // We need to set reachedTerminalState to true before we release
+    // the resources to prevent a double dealloc of WebView <rdar://problem/4372628>
+    m_reachedTerminalState = true;
+
+#if PLATFORM(MAC)
+    m_identifier = nil;
+#endif
+    m_handle = 0;
+    m_resourceData = 0;
+}
+
+bool ResourceLoader::load(const ResourceRequest& r)
+{
+    ASSERT(!m_handle);
+    ASSERT(!frameLoader()->isArchiveLoadPending(this));
+    
+    m_originalURL = r.url();
+    
+    ResourceRequest clientRequest(r);
+    willSendRequest(clientRequest, ResourceResponse());
+    if (clientRequest.isNull()) {
+        didFail(frameLoader()->cancelledError(r));
+        return false;
+    }
+    
+    if (frameLoader()->willUseArchive(this, clientRequest, m_originalURL))
+        return true;
+    
+    m_handle = ResourceHandle::create(clientRequest, this, m_frame.get(), m_defersLoading);
+
+    return true;
+}
+
+void ResourceLoader::setDefersLoading(bool defers)
+{
+    m_defersLoading = defers;
+    if (m_handle)
+        m_handle->setDefersLoading(defers);
+}
+
+FrameLoader* ResourceLoader::frameLoader() const
+{
+    if (!m_frame)
+        return 0;
+    return m_frame->loader();
+}
+
+void ResourceLoader::addData(const char* data, int length, bool allAtOnce)
+{
+    if (allAtOnce) {
+        m_resourceData = new SharedBuffer(data, length);
+        return;
+    }
+        
+    if (ResourceHandle::supportsBufferedData()) {
+        // Buffer data only if the connection has handed us the data because is has stopped buffering it.
+        if (m_resourceData)
+            m_resourceData->append(data, length);
+    } else {
+        if (!m_resourceData)
+            m_resourceData = new SharedBuffer(data, length);
+        else
+            m_resourceData->append(data, length);
+    }
+}
+
+void ResourceLoader::clearResourceData()
 {
+    m_resourceData->clear();
+}
+
+void ResourceLoader::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
+{
+    // Protect this in this delegate method since the additional processing can do
+    // anything including possibly derefing this; one example of this is Radar 3266216.
+    RefPtr<ResourceLoader> protector(this);
+        
+    ASSERT(!m_reachedTerminalState);
+
+#if PLATFORM(MAC)
+    if (!m_identifier)
+        m_identifier = frameLoader()->identifierForInitialRequest(request);
+#endif
+
+    frameLoader()->willSendRequest(this, request, redirectResponse);
+    m_request = request;
+}
+
+void ResourceLoader::didReceiveResponse(const ResourceResponse& r)
+{
+    ASSERT(!m_reachedTerminalState);
+
+    // Protect this in this delegate method since the additional processing can do
+    // anything including possibly derefing this; one example of this is Radar 3266216.
+    RefPtr<ResourceLoader> protector(this);
+
+    m_response = r;
+
+    frameLoader()->didReceiveResponse(this, m_response);
+}
+
+void ResourceLoader::didReceiveData(const char* data, int length, long long lengthReceived, bool allAtOnce)
+{
+    // The following assertions are not quite valid here, since a subclass
+    // might override didReceiveData in a way that invalidates them. This
+    // happens with the steps listed in 3266216
+    // ASSERT(con == connection);
+    // ASSERT(!m_reachedTerminalState);
+
+    // Protect this in this delegate method since the additional processing can do
+    // anything including possibly derefing this; one example of this is Radar 3266216.
+    RefPtr<ResourceLoader> protector(this);
+
+    addData(data, length, allAtOnce);
+    if (m_frame)
+        frameLoader()->didReceiveData(this, data, length, lengthReceived);
+}
+
+void ResourceLoader::willStopBufferingData(const char* data, int length)
+{
+    ASSERT(!m_resourceData);
+    m_resourceData = new SharedBuffer(data, length);
+}
+
+void ResourceLoader::didFinishLoading()
+{
+    // If load has been cancelled after finishing (which could happen with a 
+    // JavaScript that changes the window location), do nothing.
+    if (m_cancelled)
+        return;
+    ASSERT(!m_reachedTerminalState);
+
+    didFinishLoadingOnePart();
+    releaseResources();
+}
+
+void ResourceLoader::didFinishLoadingOnePart()
+{
+    if (m_cancelled)
+        return;
+    ASSERT(!m_reachedTerminalState);
+
+    if (m_calledDidFinishLoad)
+        return;
+    m_calledDidFinishLoad = true;
+    frameLoader()->didFinishLoad(this);
+}
+
+void ResourceLoader::didFail(const ResourceError& error)
+{
+    if (m_cancelled)
+        return;
+    ASSERT(!m_reachedTerminalState);
+
+    // Protect this in this delegate method since the additional processing can do
+    // anything including possibly derefing this; one example of this is Radar 3266216.
+    RefPtr<ResourceLoader> protector(this);
+
+    frameLoader()->didFailToLoad(this, error);
+
+    releaseResources();
+}
+
+void ResourceLoader::didCancel(const ResourceError& error)
+{
+    ASSERT(!m_cancelled);
+    ASSERT(!m_reachedTerminalState);
+
+    // This flag prevents bad behavior when loads that finish cause the
+    // load itself to be cancelled (which could happen with a javascript that 
+    // changes the window location). This is used to prevent both the body
+    // of this method and the body of connectionDidFinishLoading: running
+    // for a single delegate. Cancelling wins.
+    m_cancelled = true;
+    
+#if PLATFORM(MAC)
+    m_currentConnectionChallenge = nil;
+    m_currentWebChallenge = nil;
+#endif
+
+    frameLoader()->cancelPendingArchiveLoad(this);
+    if (m_handle) {
+        m_handle->cancel();
+        m_handle = 0;
+    }
+    frameLoader()->didFailToLoad(this, error);
+
+    releaseResources();
+}
+
+void ResourceLoader::cancel()
+{
+    cancel(ResourceError());
+}
+
+void ResourceLoader::cancel(const ResourceError& error)
+{
+    if (m_reachedTerminalState)
+        return;
+    if (!error.isNull())
+        didCancel(error);
+    else
+        didCancel(cancelledError());
+}
+
+const ResourceResponse& ResourceLoader::response() const
+{
+    return m_response;
+}
+
+ResourceError ResourceLoader::cancelledError()
+{
+    return frameLoader()->cancelledError(m_request);
 }
 
 void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
 {
+    willSendRequest(request, redirectResponse);
 }
 
 void ResourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
 {
+    didReceiveResponse(response);
 }
 
 void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int length, int lengthReceived)
 {
+    didReceiveData(data, length, lengthReceived, false);
 }
 
 void ResourceLoader::didFinishLoading(ResourceHandle*)
 {
+    didFinishLoading();
 }
 
 void ResourceLoader::didFail(ResourceHandle*, const ResourceError& error)
 {
+    didFail(error);
 }
 
-#endif
-
 }

third_party/WebKit/WebCore/loader/ResourceLoader.h

@@ -94,36 +94,35 @@ namespace WebCore {
         virtual PassRefPtr<SharedBuffer> resourceData();
         void clearResourceData();
 
-#if PLATFORM(MAC)
         virtual void willSendRequest(ResourceRequest&, const ResourceResponse& redirectResponse);
-        void didReceiveAuthenticationChallenge(NSURLAuthenticationChallenge *);
-        void didCancelAuthenticationChallenge(NSURLAuthenticationChallenge *);
         virtual void didReceiveResponse(const ResourceResponse&);
         virtual void didReceiveData(const char*, int, long long lengthReceived, bool allAtOnce);
         void willStopBufferingData(const char*, int);
         virtual void didFinishLoading();
         virtual void didFail(const ResourceError&);
+#if PLATFORM(MAC)
+        void didReceiveAuthenticationChallenge(NSURLAuthenticationChallenge *);
+        void didCancelAuthenticationChallenge(NSURLAuthenticationChallenge *);
         NSCachedURLResponse *willCacheResponse(NSCachedURLResponse *);
 
         void receivedCredential(NSURLAuthenticationChallenge *, NSURLCredential *);
         void receivedRequestToContinueWithoutCredential(NSURLAuthenticationChallenge *);
         void receivedCancellation(NSURLAuthenticationChallenge *);
-
 #endif
 
         // ResourceHandleClient
-        virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);
-        
+        virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);        
         virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
         virtual void didReceiveData(ResourceHandle*, const char*, int, int lengthReceived);
         virtual void didFinishLoading(ResourceHandle*);
         virtual void didFail(ResourceHandle*, const ResourceError&);
-        
+
+        virtual void willStopBufferingData(ResourceHandle*, const char* data, int length) { willStopBufferingData(data, length); } 
+
 #if PLATFORM(MAC)
         virtual void didReceiveAuthenticationChallenge(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { didReceiveAuthenticationChallenge(challenge); } 
         virtual void didCancelAuthenticationChallenge(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { didCancelAuthenticationChallenge(challenge); } 
         
-        virtual void willStopBufferingData(ResourceHandle*, const char* data, int length) { willStopBufferingData(data, length); } 
         
         virtual NSCachedURLResponse *willCacheResponse(ResourceHandle*, NSCachedURLResponse *cachedResponse) { return willCacheResponse(cachedResponse); }
         
@@ -137,13 +136,11 @@ namespace WebCore {
     protected:
         ResourceLoader(Frame*);
 
-#if PLATFORM(MAC)
         virtual void didCancel(const ResourceError&);
         void didFinishLoadingOnePart();
 
         const ResourceRequest& request() const { return m_request; }
         void setRequest(const ResourceRequest& request) { m_request = request; }
-#endif
         bool reachedTerminalState() const { return m_reachedTerminalState; }
         bool cancelled() const { return m_cancelled; }
         bool defersLoading() const { return m_defersLoading; }
@@ -160,13 +157,13 @@ namespace WebCore {
 protected:
         // FIXME: Once everything is made cross platform, these can be private instead of protected
         RefPtr<Frame> m_frame;
+        ResourceResponse m_response;
 #if PLATFORM(MAC)
         RetainPtr<id> m_identifier;
-        ResourceResponse m_response;
         NSURLAuthenticationChallenge *m_currentConnectionChallenge;
         RetainPtr<NSURLAuthenticationChallenge> m_currentWebChallenge;
-        KURL m_originalURL;
 #endif
+        KURL m_originalURL;
         RefPtr<SharedBuffer> m_resourceData;
         bool m_defersLoading;
     };

third_party/WebKit/WebCore/loader/mac/FrameLoaderMac.mm

@@ -316,12 +316,6 @@ KURL FrameLoader::originalRequestURL() const
     return activeDocumentLoader()->initialRequest().url();
 }
 
-void FrameLoader::didFinishLoad(ResourceLoader* loader)
-{    
-    m_client->completeProgress(loader->identifier());
-    m_client->dispatchDidFinishLoading(activeDocumentLoader(), loader->identifier());
-}
-
 void FrameLoader::setTitle(const String& title)
 {
     documentLoader()->setTitle(title);

third_party/WebKit/WebCore/loader/mac/ResourceLoaderMac.mm

@@ -53,117 +53,6 @@ using namespace WebCore;
 
 namespace WebCore {
 
-ResourceLoader::ResourceLoader(Frame* frame)
-    : m_reachedTerminalState(false)
-    , m_cancelled(false)
-    , m_calledDidFinishLoad(false)
-    , m_frame(frame)
-    , m_currentConnectionChallenge(nil)
-    , m_defersLoading(frame->page()->defersLoading())
-{
-}
-
-ResourceLoader::~ResourceLoader()
-{
-    ASSERT(m_reachedTerminalState);
-}
-
-void ResourceLoader::releaseResources()
-{
-    ASSERT(!m_reachedTerminalState);
-    
-    // It's possible that when we release the handle, it will be
-    // deallocated and release the last reference to this object.
-    // We need to retain to avoid accessing the object after it
-    // has been deallocated and also to avoid reentering this method.
-    RefPtr<ResourceLoader> protector(this);
-
-    m_frame = 0;
-
-    // We need to set reachedTerminalState to true before we release
-    // the resources to prevent a double dealloc of WebView <rdar://problem/4372628>
-    m_reachedTerminalState = true;
-
-    m_identifier = nil;
-    m_handle = 0;
-    m_resourceData = nil;
-}
-
-bool ResourceLoader::load(const ResourceRequest& r)
-{
-    ASSERT(!m_handle);
-    ASSERT(!frameLoader()->isArchiveLoadPending(this));
-    
-    m_originalURL = r.url();
-    
-    ResourceRequest clientRequest(r);
-    willSendRequest(clientRequest, ResourceResponse());
-    if (clientRequest.isNull()) {
-        didFail(frameLoader()->cancelledError(r));
-        return false;
-    }
-    
-    if (frameLoader()->willUseArchive(this, clientRequest, m_originalURL))
-        return true;
-    
-    m_handle = ResourceHandle::create(clientRequest, this, m_frame.get(), m_defersLoading);
-
-    return true;
-}
-
-void ResourceLoader::setDefersLoading(bool defers)
-{
-    m_defersLoading = defers;
-    if (m_handle)
-        m_handle->setDefersLoading(defers);
-}
-
-FrameLoader* ResourceLoader::frameLoader() const
-{
-    if (!m_frame)
-        return 0;
-    return m_frame->loader();
-}
-
-void ResourceLoader::addData(const char* data, int length, bool allAtOnce)
-{
-    if (allAtOnce) {
-        m_resourceData = new SharedBuffer(data, length);
-        return;
-    }
-        
-    if (ResourceHandle::supportsBufferedData()) {
-        // Buffer data only if the connection has handed us the data because is has stopped buffering it.
-        if (m_resourceData)
-            m_resourceData->append(data, length);
-    } else {
-        if (!m_resourceData)
-            m_resourceData = new SharedBuffer(data, length);
-        else
-            m_resourceData->append(data, length);
-    }
-}
-
-void ResourceLoader::clearResourceData()
-{
-    m_resourceData->clear();
-}
-
-void ResourceLoader::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
-{
-    // Protect this in this delegate method since the additional processing can do
-    // anything including possibly derefing this; one example of this is Radar 3266216.
-    RefPtr<ResourceLoader> protector(this);
-        
-    ASSERT(!m_reachedTerminalState);
-    
-    if (!m_identifier)
-        m_identifier = frameLoader()->identifierForInitialRequest(request);
-    
-    frameLoader()->willSendRequest(this, request, redirectResponse);
-    m_request = request;
-}
-
 void ResourceLoader::didReceiveAuthenticationChallenge(NSURLAuthenticationChallenge *challenge)
 {
     ASSERT(!m_reachedTerminalState);
@@ -197,81 +86,6 @@ void ResourceLoader::didCancelAuthenticationChallenge(NSURLAuthenticationChallen
     frameLoader()->didCancelAuthenticationChallenge(this, m_currentWebChallenge.get());
 }
 
-void ResourceLoader::didReceiveResponse(const ResourceResponse& r)
-{
-    ASSERT(!m_reachedTerminalState);
-
-    // Protect this in this delegate method since the additional processing can do
-    // anything including possibly derefing this; one example of this is Radar 3266216.
-    RefPtr<ResourceLoader> protector(this);
-
-    m_response = r;
-
-    frameLoader()->didReceiveResponse(this, m_response);
-}
-
-void ResourceLoader::didReceiveData(const char* data, int length, long long lengthReceived, bool allAtOnce)
-{
-    // The following assertions are not quite valid here, since a subclass
-    // might override didReceiveData in a way that invalidates them. This
-    // happens with the steps listed in 3266216
-    // ASSERT(con == connection);
-    // ASSERT(!m_reachedTerminalState);
-
-    // Protect this in this delegate method since the additional processing can do
-    // anything including possibly derefing this; one example of this is Radar 3266216.
-    RefPtr<ResourceLoader> protector(this);
-
-    addData(data, length, allAtOnce);
-    if (m_frame)
-        frameLoader()->didReceiveData(this, data, length, lengthReceived);
-}
-
-void ResourceLoader::willStopBufferingData(const char* data, int length)
-{
-    ASSERT(!m_resourceData);
-    m_resourceData = new SharedBuffer(data, length);
-}
-
-void ResourceLoader::didFinishLoading()
-{
-    // If load has been cancelled after finishing (which could happen with a 
-    // JavaScript that changes the window location), do nothing.
-    if (m_cancelled)
-        return;
-    ASSERT(!m_reachedTerminalState);
-
-    didFinishLoadingOnePart();
-    releaseResources();
-}
-
-void ResourceLoader::didFinishLoadingOnePart()
-{
-    if (m_cancelled)
-        return;
-    ASSERT(!m_reachedTerminalState);
-
-    if (m_calledDidFinishLoad)
-        return;
-    m_calledDidFinishLoad = true;
-    frameLoader()->didFinishLoad(this);
-}
-
-void ResourceLoader::didFail(const ResourceError& error)
-{
-    if (m_cancelled)
-        return;
-    ASSERT(!m_reachedTerminalState);
-
-    // Protect this in this delegate method since the additional processing can do
-    // anything including possibly derefing this; one example of this is Radar 3266216.
-    RefPtr<ResourceLoader> protector(this);
-
-    frameLoader()->didFailToLoad(this, error);
-
-    releaseResources();
-}
-
 NSCachedURLResponse *ResourceLoader::willCacheResponse(NSCachedURLResponse *cachedResponse)
 {
     // When in private browsing mode, prevent caching to disk
@@ -283,60 +97,11 @@ NSCachedURLResponse *ResourceLoader::willCacheResponse(NSCachedURLResponse *cach
     return cachedResponse;
 }
 
-void ResourceLoader::didCancel(const ResourceError& error)
-{
-    ASSERT(!m_cancelled);
-    ASSERT(!m_reachedTerminalState);
-
-    // This flag prevents bad behavior when loads that finish cause the
-    // load itself to be cancelled (which could happen with a javascript that 
-    // changes the window location). This is used to prevent both the body
-    // of this method and the body of connectionDidFinishLoading: running
-    // for a single delegate. Cancelling wins.
-    m_cancelled = true;
-    
-    m_currentConnectionChallenge = nil;
-    m_currentWebChallenge = nil;
-
-    frameLoader()->cancelPendingArchiveLoad(this);
-    if (m_handle) {
-        m_handle->cancel();
-        m_handle = 0;
-    }
-    frameLoader()->didFailToLoad(this, error);
-
-    releaseResources();
-}
-
-void ResourceLoader::cancel()
-{
-    cancel(ResourceError());
-}
-
-void ResourceLoader::cancel(const ResourceError& error)
-{
-    if (m_reachedTerminalState)
-        return;
-    if (!error.isNull())
-        didCancel(error);
-    else
-        didCancel(cancelledError());
-}
-
 void ResourceLoader::setIdentifier(id identifier)
 {
     m_identifier = identifier;
 }
 
-const ResourceResponse& ResourceLoader::response() const
-{
-    return m_response;
-}
-
-ResourceError ResourceLoader::cancelledError()
-{
-    return frameLoader()->cancelledError(m_request);
-}
 
 void ResourceLoader::receivedCredential(NSURLAuthenticationChallenge *challenge, NSURLCredential *credential)
 {
@@ -370,30 +135,5 @@ void ResourceLoader::receivedCancellation(NSURLAuthenticationChallenge *challeng
     cancel();
 }
 
-void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
-{
-    willSendRequest(request, redirectResponse);
-}
-
-void ResourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
-{
-    didReceiveResponse(response);
-}
-
-void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int length, int lengthReceived)
-{
-    didReceiveData(data, length, lengthReceived, false);
-}
-
-void ResourceLoader::didFinishLoading(ResourceHandle*)
-{
-    didFinishLoading();
-}
-
-void ResourceLoader::didFail(ResourceHandle*, const ResourceError& error)
-{
-    didFail(error);
-}
-
 }