Changeset 18184 in webkit


Ignore:
Timestamp:
Dec 12, 2006, 1:14:50 PM (18 years ago)
Author:
andersca
Message:

WebCore:

Reviewed by Darin.

Turn ResourceLoader into a ResourceHandleClient and stop using NSURLConnection in the loader.

  • WebCore.exp: Add new methods needed by WebKit.


  • WebCore.xcodeproj/project.pbxproj: Make ResourceHandle.h a private header.


  • loader/FrameLoaderClient.h: Change the download method to take a ResourceHandle instead of an NSURLConnection.


  • loader/MainResourceLoader.h: Get rid of the proxy instance variable, that's handled by ResourceHandlw now.


  • loader/ResourceLoader.h: (WebCore::ResourceLoader::didReceiveAuthenticationChallenge): (WebCore::ResourceLoader::didCancelAuthenticationChallenge): (WebCore::ResourceLoader::willStopBufferingData): (WebCore::ResourceLoader::willCacheResponse): (WebCore::ResourceLoader::receivedCredential): (WebCore::ResourceLoader::receivedRequestToContinueWithoutCredential): (WebCore::ResourceLoader::receivedCancellation): (WebCore::ResourceLoader::handle):
  • loader/SubresourceLoader.h: Make ResourceLoader a ResourceHandleClient, moving the methods from SubresourceLoader.


  • loader/mac/MainResourceLoaderMac.mm: (WebCore::MainResourceLoader::MainResourceLoader): (WebCore::MainResourceLoader::continueAfterContentPolicy): (WebCore::MainResourceLoader::loadNow): (WebCore::MainResourceLoader::load): Use a ResourceHandle instead of an NSURLConnection.


  • loader/mac/ResourceLoaderMac.mm: (WebCore::ResourceLoader::~ResourceLoader): (WebCore::ResourceLoader::releaseResources): (WebCore::ResourceLoader::load): (WebCore::ResourceLoader::setDefersLoading): (WebCore::ResourceLoader::resourceData): (WebCore::ResourceLoader::didReceiveAuthenticationChallenge): (WebCore::ResourceLoader::didCancel): (WebCore::ResourceLoader::willSendRequest): (WebCore::ResourceLoader::didReceiveResponse): (WebCore::ResourceLoader::didReceiveData): (WebCore::ResourceLoader::didFinishLoading): (WebCore::ResourceLoader::didFail): Remove the WebCoreResourceLoaderAsDelegate class, use a ResourceHandle instead of an NSURLConnection.


  • loader/mac/SubresourceLoaderMac.mm: Remove ResourceHandleClient methods.


  • platform/network/ResourceHandle.cpp: (WebCore::ResourceHandle::ResourceHandle): (WebCore::ResourceHandle::create):
  • platform/network/ResourceHandle.h:
  • platform/network/ResourceHandleInternal.h: (WebCore::ResourceHandleInternal::ResourceHandleInternal): Add an extra argument denoting whether this ResourceHandle can possibly be "converted" into one used for downloads.


  • platform/network/mac/ResourceHandleMac.mm: (WebCore::ResourceHandle::~ResourceHandle): (WebCore::ResourceHandle::start): (WebCore::ResourceHandle::releaseProxy): (WebCore::ResourceHandle::connection): New methods for creating a NSURLConnectionDelegateProxy which is used when creating a NSURLDownload from an existing connection.

WebKit:

Reviewed by Darin.

  • WebCoreSupport/WebFrameLoaderClient.h:
  • WebCoreSupport/WebFrameLoaderClient.mm: (WebFrameLoaderClient::download): Get the handle and proxy from the ResourceHandle now that they aren't passed to us.
Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r18181 r18184  
     12006-12-12  Anders Carlsson  <acarlsson@apple.com>
     2
     3        Reviewed by Darin.
     4
     5        Turn ResourceLoader into a ResourceHandleClient and stop using NSURLConnection in the loader.
     6
     7        * WebCore.exp:
     8        Add new methods needed by WebKit.
     9       
     10        * WebCore.xcodeproj/project.pbxproj:
     11        Make ResourceHandle.h a private header.
     12       
     13        * loader/FrameLoaderClient.h:
     14        Change the download method to take a ResourceHandle instead of an NSURLConnection.
     15       
     16        * loader/MainResourceLoader.h:
     17        Get rid of the proxy instance variable, that's handled by ResourceHandlw now.
     18       
     19        * loader/ResourceLoader.h:
     20        (WebCore::ResourceLoader::didReceiveAuthenticationChallenge):
     21        (WebCore::ResourceLoader::didCancelAuthenticationChallenge):
     22        (WebCore::ResourceLoader::willStopBufferingData):
     23        (WebCore::ResourceLoader::willCacheResponse):
     24        (WebCore::ResourceLoader::receivedCredential):
     25        (WebCore::ResourceLoader::receivedRequestToContinueWithoutCredential):
     26        (WebCore::ResourceLoader::receivedCancellation):
     27        (WebCore::ResourceLoader::handle):
     28        * loader/SubresourceLoader.h:
     29        Make ResourceLoader a ResourceHandleClient, moving the methods from SubresourceLoader.
     30       
     31        * loader/mac/MainResourceLoaderMac.mm:
     32        (WebCore::MainResourceLoader::MainResourceLoader):
     33        (WebCore::MainResourceLoader::continueAfterContentPolicy):
     34        (WebCore::MainResourceLoader::loadNow):
     35        (WebCore::MainResourceLoader::load):
     36        Use a ResourceHandle instead of an NSURLConnection.
     37       
     38        * loader/mac/ResourceLoaderMac.mm:
     39        (WebCore::ResourceLoader::~ResourceLoader):
     40        (WebCore::ResourceLoader::releaseResources):
     41        (WebCore::ResourceLoader::load):
     42        (WebCore::ResourceLoader::setDefersLoading):
     43        (WebCore::ResourceLoader::resourceData):
     44        (WebCore::ResourceLoader::didReceiveAuthenticationChallenge):
     45        (WebCore::ResourceLoader::didCancel):
     46        (WebCore::ResourceLoader::willSendRequest):
     47        (WebCore::ResourceLoader::didReceiveResponse):
     48        (WebCore::ResourceLoader::didReceiveData):
     49        (WebCore::ResourceLoader::didFinishLoading):
     50        (WebCore::ResourceLoader::didFail):
     51        Remove the WebCoreResourceLoaderAsDelegate class, use a ResourceHandle instead of an NSURLConnection.
     52       
     53        * loader/mac/SubresourceLoaderMac.mm:
     54        Remove ResourceHandleClient methods.
     55       
     56        * platform/network/ResourceHandle.cpp:
     57        (WebCore::ResourceHandle::ResourceHandle):
     58        (WebCore::ResourceHandle::create):
     59        * platform/network/ResourceHandle.h:
     60        * platform/network/ResourceHandleInternal.h:
     61        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
     62        Add an extra argument denoting whether this ResourceHandle can possibly be "converted" into one used for downloads.
     63       
     64        * platform/network/mac/ResourceHandleMac.mm:
     65        (WebCore::ResourceHandle::~ResourceHandle):
     66        (WebCore::ResourceHandle::start):
     67        (WebCore::ResourceHandle::releaseProxy):
     68        (WebCore::ResourceHandle::connection):
     69        New methods for creating a NSURLConnectionDelegateProxy which is used when creating a NSURLDownload from an existing
     70        connection.
     71
    1722006-12-12  Anders Carlsson  <acarlsson@apple.com>
    273

  • trunk/WebCore/WebCore.exp

    r18165 r18184  
    204204__ZN7WebCore14DocumentLoaderD2Ev
    205205__ZN7WebCore14RenderListItem17markerStringValueEv
     206__ZN7WebCore14ResourceHandle12releaseProxyEv
    206207__ZN7WebCore14ResourceLoader14cancelledErrorEv
    207208__ZN7WebCore16DeprecatedString6appendENS_14DeprecatedCharE
    … …  
    363364__ZNK7WebCore14DocumentLoader8responseEv
    364365__ZNK7WebCore14DocumentLoader9isLoadingEv
     366__ZNK7WebCore14ResourceHandle10connectionEv
    365367__ZNK7WebCore14ResourceLoader11frameLoaderEv
    366368__ZNK7WebCore15ContextMenuItem19platformDescriptionEv

  • trunk/WebCore/WebCore.xcodeproj/project.pbxproj

    r18177 r18184  
    346346                656B84E30AEA1D3100A095B4 /* ResourceHandleInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 656B84DF0AEA1D3100A095B4 /* ResourceHandleInternal.h */; };
    347347                656B84EB0AEA1DDA00A095B4 /* ResourceHandleMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 656B84EA0AEA1DDA00A095B4 /* ResourceHandleMac.mm */; };
    348                 656B85380AEA1F9A00A095B4 /* ResourceHandle.h in Headers */ = {isa = PBXBuildFile; fileRef = 656B85370AEA1F9A00A095B4 /* ResourceHandle.h */; };
     348                656B85380AEA1F9A00A095B4 /* ResourceHandle.h in Headers */ = {isa = PBXBuildFile; fileRef = 656B85370AEA1F9A00A095B4 /* ResourceHandle.h */; settings = {ATTRIBUTES = (Private, ); }; };
    349349                656D37320ADBA5DE00A4554D /* LoaderNSURLExtras.h in Headers */ = {isa = PBXBuildFile; fileRef = 656D371A0ADBA5DE00A4554D /* LoaderNSURLExtras.h */; settings = {ATTRIBUTES = (Private, ); }; };
    350350                656D37330ADBA5DE00A4554D /* LoaderNSURLExtras.m in Sources */ = {isa = PBXBuildFile; fileRef = 656D371B0ADBA5DE00A4554D /* LoaderNSURLExtras.m */; };

  • trunk/WebCore/loader/FrameLoaderClient.h

    r17906 r18184  
    5151    class NavigationAction;
    5252    class String;
     53    class ResourceHandle;
    5354    class ResourceLoader;
    5455    class ResourceRequest;
    … …  
    108109
    109110#if PLATFORM(MAC)
    110         virtual void download(NSURLConnection *, NSURLRequest *, NSURLResponse *, id proxy) = 0;
     111        virtual void download(ResourceHandle*, NSURLRequest *, NSURLResponse *) = 0;
    111112
    112113        virtual id dispatchIdentifierForInitialRequest(DocumentLoader*, NSURLRequest *) = 0;

  • trunk/WebCore/loader/MainResourceLoader.h

    r17442 r18184  
    6161        virtual void didCancel(NSError *);
    6262
    63         virtual void releaseDelegate();
    64 
    6563        NSURLRequest *loadNow(NSURLRequest *);
    6664
    … …  
    7876
    7977        RetainPtr<NSURLResponse> m_response;
    80         RetainPtr<id> m_proxy;
    8178        RetainPtr<NSURLRequest> m_initialRequest;
    8279#endif

  • trunk/WebCore/loader/ResourceLoader.h

    r18047 r18184  
    3232#include "Shared.h"
    3333#include <wtf/RefPtr.h>
     34#include "ResourceHandleClient.h"
    3435
    3536#if PLATFORM(MAC)
    … …  
    4546@class NSURLRequest;
    4647@class NSURLResponse;
    47 @class WebCoreResourceLoaderAsDelegate;
    4848#else
    4949class NSCachedURLResponse;
    … …  
    5858class NSURLRequest;
    5959class NSURLResponse;
    60 class WebCoreResourceLoaderAsDelegate;
    6160#endif
    6261
    … …  
    6766    class Frame;
    6867    class FrameLoader;
    69 
    70     class ResourceLoader : public Shared<ResourceLoader> {
     68    class ResourceHandle;
     69   
     70    class ResourceLoader : public Shared<ResourceLoader>, protected ResourceHandleClient {
    7171    public:
    7272        virtual ~ResourceLoader();
    … …  
    112112#endif
    113113
    114         // Used to work around the fact that you don't get any more NSURLConnection callbacks until you return from the one you're in.
    115         static bool loadsBlocked();
     114        // ResourceHandleClient
     115        virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);
     116       
     117        virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
     118        virtual void didReceiveData(ResourceHandle*, const char*, int, int lengthReceived);
     119        virtual void didFinishLoading(ResourceHandle*);
     120        virtual void didFail(ResourceHandle*, const ResourceError&);
     121       
     122#if PLATFORM(MAC)
     123        virtual void didReceiveAuthenticationChallenge(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { didReceiveAuthenticationChallenge(challenge); }
     124        virtual void didCancelAuthenticationChallenge(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { didCancelAuthenticationChallenge(challenge); }
     125       
     126        virtual void willStopBufferingData(ResourceHandle*, NSData *data) { willStopBufferingData(data); }
     127       
     128        virtual NSCachedURLResponse *willCacheResponse(ResourceHandle*, NSCachedURLResponse *cachedResponse) { return willCacheResponse(cachedResponse); }
     129       
     130        virtual void receivedCredential(ResourceHandle*, NSURLAuthenticationChallenge *challenge, NSURLCredential *credential) { receivedCredential(challenge, credential); }
     131        virtual void receivedRequestToContinueWithoutCredential(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { receivedRequestToContinueWithoutCredential(challenge); }
     132        virtual void receivedCancellation(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { receivedCancellation(challenge); }
     133#endif
     134       
     135        ResourceHandle* handle() const { return m_handle.get(); }
    116136
    117137    protected:
    … …  
    119139
    120140#if PLATFORM(MAC)
    121         WebCoreResourceLoaderAsDelegate *delegate();
    122         virtual void releaseDelegate();
    123 
    124141        virtual void didCancel(NSError *);
    125142        void didFinishLoadingOnePart();
    126143
    127         NSURLConnection *connection() const { return m_connection.get(); }
    128144        NSURLRequest *request() const { return m_request.get(); }
    129145#endif
    … …  
    132148        bool defersLoading() const { return m_defersLoading; }
    133149
    134 #if PLATFORM(MAC)
    135         RetainPtr<NSURLConnection> m_connection;
    136 #endif
    137 
     150        RefPtr<ResourceHandle> m_handle;
     151       
    138152    private:
    139153#if PLATFORM(MAC)
    … …  
    155169        RetainPtr<NSURL> m_originalURL;
    156170        RetainPtr<NSMutableData> m_resourceData;
    157         RetainPtr<WebCoreResourceLoaderAsDelegate> m_delegate;
    158171#endif
    159172        bool m_defersLoading;

  • trunk/WebCore/loader/SubresourceLoader.h

    r18069 r18184  
    4848    class SubresourceLoaderClient;
    4949   
    50     class SubresourceLoader : public ResourceLoader, ResourceHandleClient {
     50    class SubresourceLoader : public ResourceLoader {
    5151    public:
    5252        static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&);
    … …  
    5757       
    5858#if PLATFORM(MAC)
    59         // FIXME: These should go away once ResourceLoader uses ResourceHandle.
    6059        virtual bool load(NSURLRequest *);
    61         virtual NSData *resourceData();
    62         virtual void setDefersLoading(bool);             
    6360       
    6461        virtual NSURLRequest *willSendRequest(NSURLRequest *, NSURLResponse *redirectResponse);
    … …  
    7370#endif
    7471
    75         // ResourceHandleClient
    76         virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);
    77        
    78         virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
    79         virtual void didReceiveData(ResourceHandle*, const char*, int, int lengthReceived);
    80         virtual void didFinishLoading(ResourceHandle*);
    81         virtual void didFail(ResourceHandle*, const ResourceError&);
    82 
    83 #if PLATFORM(MAC)
    84         virtual void didReceiveAuthenticationChallenge(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { ResourceLoader::didReceiveAuthenticationChallenge(challenge); }
    85         virtual void didCancelAuthenticationChallenge(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { ResourceLoader::didCancelAuthenticationChallenge(challenge); }
    86        
    87         virtual void willStopBufferingData(ResourceHandle*, NSData *data) { ResourceLoader::willStopBufferingData(data); }
    88        
    89         virtual NSCachedURLResponse *willCacheResponse(ResourceHandle*, NSCachedURLResponse *cachedResponse) { return ResourceLoader::willCacheResponse(cachedResponse); }
    90        
    91         virtual void receivedCredential(ResourceHandle*, NSURLAuthenticationChallenge *challenge, NSURLCredential *credential) { ResourceLoader::receivedCredential(challenge, credential); }
    92         virtual void receivedRequestToContinueWithoutCredential(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { ResourceLoader::receivedRequestToContinueWithoutCredential(challenge); }
    93         virtual void receivedCancellation(ResourceHandle*, NSURLAuthenticationChallenge *challenge) { ResourceLoader::receivedCancellation(challenge); }
    94 #endif
    95        
    96         ResourceHandle* handle() const { return m_handle.get(); }
    9772    private:
    9873        SubresourceLoader(Frame*, SubresourceLoaderClient*);
    … …  
    10277#endif
    10378        SubresourceLoaderClient* m_client;
    104         RefPtr<ResourceHandle> m_handle;
    10579        bool m_loadingMultipartContent;
    10680    };

  • trunk/WebCore/loader/mac/MainResourceLoaderMac.mm

    r17622 r18184  
    3434#import "KURL.h"
    3535#import "PlatformString.h"
     36#import "ResourceHandle.h"
     37#import "ResourceRequest.h"
    3638#import "WebCoreSystemInterface.h"
    3739#import "WebDataProtocol.h"
    … …  
    5456MainResourceLoader::MainResourceLoader(Frame* frame)
    5557    : ResourceLoader(frame)
    56     , m_proxy(wkCreateNSURLConnectionDelegateProxy())
    5758    , m_loadingMultipartContent(false)
    5859    , m_waitingForContentPolicy(false)
    5960{
    60     [m_proxy.get() setDelegate:delegate()];
    61     [m_proxy.get() release];
    6261}
    6362
    6463MainResourceLoader::~MainResourceLoader()
    6564{
    66 }
    67 
    68 void MainResourceLoader::releaseDelegate()
    69 {
    70     [m_proxy.get() setDelegate:nil];
    71     ResourceLoader::releaseDelegate();
    7265}
    7366
    … …  
    227220
    228221    case PolicyDownload:
    229         [m_proxy.get() setDelegate:nil];
    230         frameLoader()->client()->download(connection(), request(), r, m_proxy.get());
    231         m_proxy = nil;
     222        frameLoader()->client()->download(m_handle.get(), request(), r);
    232223        receivedError(interruptionForPolicyChangeError());
    233224        return;
    … …  
    343334    bool shouldLoadEmptyBeforeRedirect = shouldLoadAsEmptyDocument([r URL]);
    344335
    345     ASSERT(!connection());
     336    ASSERT(!m_handle);
    346337    ASSERT(shouldLoadEmptyBeforeRedirect || !defersLoading());
    347338
    … …  
    374365        [resp release];
    375366    } else {
    376         NSURLConnection *conn = [[NSURLConnection alloc] initWithRequest:r delegate:m_proxy.get()];
    377         m_connection = conn;
    378         [conn release];
     367        m_handle = ResourceHandle::create(r, this, m_frame.get(), false, true);
    379368    }
    380369
    … …  
    384373bool MainResourceLoader::load(NSURLRequest *r)
    385374{
    386     ASSERT(!connection());
     375    ASSERT(!m_handle);
    387376
    388377    bool defer = defersLoading();

  • trunk/WebCore/loader/mac/ResourceLoaderMac.mm

    r18047 r18184  
    3333#import "FrameMac.h"
    3434#import "Page.h"
     35#import "ResourceError.h"
    3536#import "ResourceHandle.h"
     37#import "ResourceRequest.h"
     38#import "ResourceResponse.h"
    3639#import "WebCoreSystemInterface.h"
    3740#import "WebDataProtocol.h"
    … …  
    4548using namespace WebCore;
    4649
    47 @interface WebCoreResourceLoaderAsDelegate : NSObject <NSURLAuthenticationChallengeSender>
    48 {
    49     ResourceLoader* m_loader;
    50 }
    51 - (id)initWithLoader:(ResourceLoader*)loader;
    52 - (void)detachLoader;
    53 @end
    54 
    55 @interface NSURLConnection (NSURLConnectionTigerPrivate)
    56 - (NSData *)_bufferedData;
    57 @end
    58 
    5950@interface NSURLProtocol (WebFoundationSecret)
    6051+ (void)_removePropertyForKey:(NSString *)key inRequest:(NSMutableURLRequest *)request;
    … …  
    6253
    6354namespace WebCore {
    64 
    65 static unsigned inNSURLConnectionCallback;
    66 
    67 #ifndef NDEBUG
    68 static bool isInitializingConnection;
    69 #endif
    7055
    7156ResourceLoader::ResourceLoader(Frame* frame)
    … …  
    8267{
    8368    ASSERT(m_reachedTerminalState);
    84     releaseDelegate();
    8569}
    8670
    … …  
    10286
    10387    m_identifier = nil;
    104     m_connection = nil;
     88    m_handle = 0;
    10589    m_resourceData = nil;
    106 
    107     releaseDelegate();
    10890}
    10991
    11092bool ResourceLoader::load(NSURLRequest *r)
    11193{
    112     ASSERT(m_connection == nil);
     94    ASSERT(!m_handle);
    11395    ASSERT(!frameLoader()->isArchiveLoadPending(this));
    11496   
    … …  
    125107        return true;
    126108   
    127 #ifndef NDEBUG
    128     isInitializingConnection = YES;
    129 #endif
    130     NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:r delegate:delegate()];
    131 #ifndef NDEBUG
    132     isInitializingConnection = NO;
    133 #endif
    134     m_connection = connection;
    135     [connection release];
    136     if (m_defersLoading)
    137         wkSetNSURLConnectionDefersCallbacks(m_connection.get(), YES);
     109    m_handle = ResourceHandle::create(r, this, m_frame.get(), m_defersLoading);
    138110
    139111    return true;
    … …  
    143115{
    144116    m_defersLoading = defers;
    145     wkSetNSURLConnectionDefersCallbacks(m_connection.get(), defers);
     117    if (m_handle)
     118        m_handle->setDefersLoading(defers);
    146119}
    147120
    … …  
    183156        return [[m_resourceData.get() retain] autorelease];
    184157
    185     if (ResourceHandle::supportsBufferedData())
    186         return [m_connection.get() _bufferedData];
    187 
     158    if (ResourceHandle::supportsBufferedData() && m_handle)
     159        return m_handle->bufferedData();
     160   
    188161    return nil;
    189162}
    … …  
    260233
    261234    m_currentConnectionChallenge = challenge;
    262     NSURLAuthenticationChallenge *webChallenge = [[NSURLAuthenticationChallenge alloc] initWithAuthenticationChallenge:challenge sender:delegate()];
     235    NSURLAuthenticationChallenge *webChallenge = [[NSURLAuthenticationChallenge alloc] initWithAuthenticationChallenge:challenge sender:(id<NSURLAuthenticationChallengeSender>)m_handle->delegate()];
    263236    m_currentWebChallenge = webChallenge;
    264237
    … …  
    392365
    393366    frameLoader()->cancelPendingArchiveLoad(this);
    394     [m_connection.get() cancel];
     367    if (m_handle)
     368        m_handle->cancel();
    395369
    396370    frameLoader()->didFailToLoad(this, error);
    … …  
    424398}
    425399
    426 // FIXME: We should move this to ResourceHandle, once it implements all the connection callbacks
    427 bool ResourceLoader::loadsBlocked()
    428 {
    429     return inNSURLConnectionCallback != 0;
    430 }
    431 
    432400NSError *ResourceLoader::cancelledError()
    433401{
    … …  
    467435}
    468436
    469 WebCoreResourceLoaderAsDelegate *ResourceLoader::delegate()
    470 {
    471     if (!m_delegate) {
    472         WebCoreResourceLoaderAsDelegate *d = [[WebCoreResourceLoaderAsDelegate alloc] initWithLoader:this];
    473         m_delegate = d;
    474         [d release];
    475     }
    476     return m_delegate.get();
    477 }
    478 
    479 void ResourceLoader::releaseDelegate()
    480 {
    481     if (!m_delegate)
    482         return;
    483     [m_delegate.get() detachLoader];
    484     m_delegate = nil;
    485 }
    486 
    487 }
    488 
    489 @implementation WebCoreResourceLoaderAsDelegate
    490 
    491 - (id)initWithLoader:(ResourceLoader*)loader
    492 {
    493     self = [self init];
    494     if (!self)
    495         return nil;
    496     m_loader = loader;
    497     return self;
    498 }
    499 
    500 - (void)detachLoader
    501 {
    502     m_loader = nil;
    503 }
    504 
    505 - (NSURLRequest *)connection:(NSURLConnection *)con willSendRequest:(NSURLRequest *)newRequest redirectResponse:(NSURLResponse *)redirectResponse
    506 {
    507     if (!m_loader)
    508         return nil;
    509     ++inNSURLConnectionCallback;
    510     NSURLRequest *result = m_loader->willSendRequest(newRequest, redirectResponse);
    511     --inNSURLConnectionCallback;
    512     return result;
    513 }
    514 
    515 - (void)connection:(NSURLConnection *)con didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
    516 {
    517     if (!m_loader)
    518         return;
    519     ++inNSURLConnectionCallback;
    520     m_loader->didReceiveAuthenticationChallenge(challenge);
    521     --inNSURLConnectionCallback;
    522 }
    523 
    524 - (void)connection:(NSURLConnection *)con didCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
    525 {
    526     if (!m_loader)
    527         return;
    528     ++inNSURLConnectionCallback;
    529     m_loader->didCancelAuthenticationChallenge(challenge);
    530     --inNSURLConnectionCallback;
    531 }
    532 
    533 - (void)connection:(NSURLConnection *)con didReceiveResponse:(NSURLResponse *)r
    534 {
    535     if (!m_loader)
    536         return;
    537     ++inNSURLConnectionCallback;
    538     m_loader->didReceiveResponse(r);
    539     --inNSURLConnectionCallback;
    540 }
    541 
    542 - (void)connection:(NSURLConnection *)con didReceiveData:(NSData *)data lengthReceived:(long long)lengthReceived
    543 {
    544     if (!m_loader)
    545         return;
    546     ++inNSURLConnectionCallback;
    547     m_loader->didReceiveData(data, lengthReceived, false);
    548     --inNSURLConnectionCallback;
    549 }
    550 
    551 - (void)connection:(NSURLConnection *)con willStopBufferingData:(NSData *)data
    552 {
    553     if (!m_loader)
    554         return;
    555     ++inNSURLConnectionCallback;
    556     m_loader->willStopBufferingData(data);
    557     --inNSURLConnectionCallback;
    558 }
    559 
    560 - (void)connectionDidFinishLoading:(NSURLConnection *)con
    561 {
    562     if (!m_loader)
    563         return;
    564     ++inNSURLConnectionCallback;
    565     m_loader->didFinishLoading();
    566     --inNSURLConnectionCallback;
    567 }
    568 
    569 - (void)connection:(NSURLConnection *)con didFailWithError:(NSError *)error
    570 {
    571     if (!m_loader)
    572         return;
    573     ++inNSURLConnectionCallback;
    574     m_loader->didFail(error);
    575     --inNSURLConnectionCallback;
    576 }
    577 
    578 - (NSCachedURLResponse *)connection:(NSURLConnection *)connection willCacheResponse:(NSCachedURLResponse *)cachedResponse
    579 {
    580 #ifndef NDEBUG
    581     if (isInitializingConnection)
    582         LOG_ERROR("connection:willCacheResponse: was called inside of [NSURLConnection initWithRequest:delegate:] (40676250)");
    583 #endif
    584     if (!m_loader)
    585         return nil;
    586     ++inNSURLConnectionCallback;
    587     NSCachedURLResponse *result = m_loader->willCacheResponse(cachedResponse);
    588     --inNSURLConnectionCallback;
    589     return result;
    590 }
    591 
    592 - (void)useCredential:(NSURLCredential *)credential forAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
    593 {
    594     if (!m_loader)
    595         return;
    596     m_loader->receivedCredential(challenge, credential);
    597 }
    598 
    599 - (void)continueWithoutCredentialForAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
    600 {
    601     if (!m_loader)
    602         return;
    603     m_loader->receivedRequestToContinueWithoutCredential(challenge);
    604 }
    605 
    606 - (void)cancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
    607 {
    608     if (!m_loader)
    609         return;
    610     m_loader->receivedCancellation(challenge);
    611 }
    612 
    613 @end
     437void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
     438{
     439    request = willSendRequest(request.nsURLRequest(), redirectResponse.nsURLResponse());
     440}
     441
     442void ResourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
     443{
     444    didReceiveResponse(response.nsURLResponse());
     445}
     446
     447void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int length, int lengthReceived)
     448{
     449    NSData *nsData = [[NSData alloc] initWithBytesNoCopy:(void*)data length:length freeWhenDone:NO];
     450    didReceiveData(nsData, lengthReceived, false);
     451    [nsData release];
     452}
     453
     454void ResourceLoader::didFinishLoading(ResourceHandle*)
     455{
     456    didFinishLoading();
     457}
     458
     459void ResourceLoader::didFail(ResourceHandle*, const ResourceError& error)
     460{
     461    didFail(error);
     462}
     463
     464}
     465

  • trunk/WebCore/loader/mac/SubresourceLoaderMac.mm

    r18181 r18184  
    6060}
    6161
    62 void SubresourceLoader::setDefersLoading(bool defers)
    63 {
    64     m_defersLoading = defers;
    65     m_handle->setDefersLoading(defers);
    66 }
    67 
    68 NSData *SubresourceLoader::resourceData()
    69 {
    70     if (ResourceHandle::supportsBufferedData())
    71         return m_handle->bufferedData();
    72    
    73     return ResourceLoader::resourceData();
    74 }
    75 
    7662bool SubresourceLoader::load(NSURLRequest *r)
    7763{
    78     ASSERT(m_handle == nil);
    79     ASSERT(!frameLoader()->isArchiveLoadPending(this));
    80    
    81     m_originalURL = [r URL];
    82    
    83     NSURLRequest *clientRequest = willSendRequest(r, nil);
    84     if (clientRequest == nil) {
    85         didFail(frameLoader()->cancelledError(r));
    86         return false;
    87     }
    88     r = clientRequest;
    89    
    90     if (frameLoader()->willUseArchive(this, r, m_originalURL.get()))
    91         return true;
    92  
    93     m_frame->loader()->didTellBridgeAboutLoad(KURL([r URL]).url());
    94     m_handle = ResourceHandle::create(r, this, m_frame->document()->docLoader(), m_defersLoading);
    95 
    96     return true;
     64    m_frame->loader()->didTellBridgeAboutLoad(KURL([r URL]).url());
     65   
     66    return ResourceLoader::load(r);
    9767}
    9868
    … …  
    275245}
    276246
    277 void SubresourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
    278 {
    279     NSURLRequest* newRequest = willSendRequest(request.nsURLRequest(), redirectResponse.nsURLResponse());
    280    
    281     request = newRequest;
    282 }
    283 
    284 void SubresourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
    285 {
    286     didReceiveResponse(response.nsURLResponse());
    287 }
    288 
    289 void SubresourceLoader::didReceiveData(ResourceHandle*, const char* data, int length, int lengthReceived)
    290 {
    291     NSData *nsData = [[NSData alloc] initWithBytesNoCopy:(void*)data length:length freeWhenDone:NO];
    292     didReceiveData(nsData, lengthReceived, false);
    293     [nsData release];
    294 }
    295 
    296 void SubresourceLoader::didFinishLoading(ResourceHandle*)
    297 {
    298     didFinishLoading();
    299 }
    300 
    301 void SubresourceLoader::didFail(ResourceHandle*, const ResourceError& error)
    302 {
    303     didFail(error);
    304 }
    305 
    306 }
     247}

  • trunk/WebCore/page/Chrome.cpp

    r17931 r18184  
    2525#include "FloatRect.h"
    2626#include "Page.h"
    27 #include "ResourceLoader.h"
     27#include "ResourceHandle.h"
    2828#include <wtf/PassRefPtr.h>
    2929#include <wtf/RefPtr.h>
    … …  
    9898    // If loads are blocked, we can't run modal because the contents
    9999    // of the modal dialog will never show up!
    100     return canRunModal() && !ResourceLoader::loadsBlocked();
     100    return canRunModal() && !ResourceHandle::loadsBlocked();
    101101}
    102102

  • trunk/WebCore/platform/network/ResourceHandle.cpp

    r18124 r18184  
    3333namespace WebCore {
    3434
    35 ResourceHandle::ResourceHandle(const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading)
    36     : d(new ResourceHandleInternal(this, request, client, defersLoading))
     35ResourceHandle::ResourceHandle(const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool mightDownloadFromHandle)
     36    : d(new ResourceHandleInternal(this, request, client, defersLoading, mightDownloadFromHandle))
    3737{
    3838}
    3939
    40 PassRefPtr<ResourceHandle> ResourceHandle::create(const ResourceRequest& request, ResourceHandleClient* client, DocLoader* dl, bool defersLoading)
     40PassRefPtr<ResourceHandle> ResourceHandle::create(const ResourceRequest& request, ResourceHandleClient* client, Frame* frame, bool defersLoading, bool mightDownloadFromHandle)
    4141{
    42     RefPtr<ResourceHandle> newLoader(new ResourceHandle(request, client, defersLoading));
     42    RefPtr<ResourceHandle> newLoader(new ResourceHandle(request, client, defersLoading, mightDownloadFromHandle));
    4343   
    44     if (newLoader->start(dl))
     44    if (newLoader->start(frame))
    4545        return newLoader.release();
    4646

  • trunk/WebCore/platform/network/ResourceHandle.h

    r18124 r18184  
    4747@class NSData;
    4848@class NSError;
     49@class NSURLConnection;
    4950@class NSURLRequest;
    5051@class NSURLResponse;
    … …  
    5354class NSData;
    5455class NSError;
     56class NSURLConnection;
    5557class NSURLRequest;
    5658class NSURLResponse;
    5759class WebCoreResourceHandleAsDelegate;
     60typedef struct objc_object *id;
    5861#endif
    5962#endif
    … …  
    6164namespace WebCore {
    6265
    63 class DocLoader;
    6466class FormData;
     67class Frame;
    6568class KURL;
    6669class ResourceHandleClient;
    … …  
    7578class ResourceHandle : public Shared<ResourceHandle> {
    7679private:
    77     ResourceHandle(const ResourceRequest&, ResourceHandleClient*, bool defersLoading);
     80    ResourceHandle(const ResourceRequest&, ResourceHandleClient*, bool defersLoading, bool mightDownloadFromHandle);
    7881
    7982public:
    80     // FIXME: should not need the DocLoader
    81     static PassRefPtr<ResourceHandle> create(const ResourceRequest&, ResourceHandleClient*, DocLoader*, bool defersLoading);
     83    // FIXME: should not need the Frame
     84    static PassRefPtr<ResourceHandle> create(const ResourceRequest&, ResourceHandleClient*, Frame*, bool defersLoading, bool mightDownloadFromHandle = false);
    8285
    8386    ~ResourceHandle();
    8487
    8588#if PLATFORM(MAC)
     89    NSURLConnection *connection() const;
    8690    WebCoreResourceHandleAsDelegate *delegate();
    8791    void releaseDelegate();
    8892    NSData* bufferedData();
    89        
     93   
    9094    static bool supportsBufferedData();
     95   
     96    id releaseProxy();
    9197#endif
    9298
    … …  
    106112#endif
    107113
     114    // Used to work around the fact that you don't get any more NSURLConnection callbacks until you return from the one you're in.
     115    static bool loadsBlocked();   
     116   
    108117    void cancel();
    109118   
    … …  
    118127
    119128private:
    120     bool start(DocLoader*);
     129    bool start(Frame*);
    121130
    122131    OwnPtr<ResourceHandleInternal> d;

  • trunk/WebCore/platform/network/ResourceHandleInternal.h

    r18163 r18184  
    6464    class ResourceHandleInternal : Noncopyable {
    6565    public:
    66         ResourceHandleInternal(ResourceHandle* loader, const ResourceRequest& request, ResourceHandleClient* c, bool defersLoading)
     66        ResourceHandleInternal(ResourceHandle* loader, const ResourceRequest& request, ResourceHandleClient* c, bool defersLoading, bool mightDownloadFromHandle)
    6767            : m_client(c)
    6868            , m_request(request)
    6969            , status(0)
    7070            , m_defersLoading(defersLoading)
     71            , m_mightDownloadFromHandle(mightDownloadFromHandle)
    7172#if USE(CFNETWORK)
    7273            , m_connection(0)
    … …  
    101102
    102103        bool m_defersLoading;
     104        bool m_mightDownloadFromHandle;
    103105#if USE(CFNETWORK)
    104106        CFURLConnectionRef m_connection;
    … …  
    106108        RetainPtr<NSURLConnection> m_connection;
    107109        RetainPtr<WebCoreResourceHandleAsDelegate> m_delegate;
     110        RetainPtr<id> m_proxy;
    108111#endif
    109112#if USE(WININET)

  • trunk/WebCore/platform/network/mac/ResourceHandleMac.mm

    r18181 r18184  
    7373}
    7474
    75 bool ResourceHandle::start(DocLoader* docLoader)
    76 {
    77     ASSERT(docLoader);
    78    
    79     FrameMac* frame = Mac(docLoader->frame());
     75bool ResourceHandle::start(Frame* frame)
     76{
    8077    if (!frame)
    8178        return false;
    … …  
    9188    isInitializingConnection = YES;
    9289#endif
    93     NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:d->m_request.nsURLRequest() delegate:delegate()];
     90    id delegate;
     91   
     92    if (d->m_mightDownloadFromHandle) {
     93        ASSERT(!d->m_proxy);
     94        d->m_proxy = wkCreateNSURLConnectionDelegateProxy();
     95        [d->m_proxy.get() setDelegate:ResourceHandle::delegate()];
     96        [d->m_proxy.get() release];
     97       
     98        delegate = d->m_proxy.get();
     99    } else
     100        delegate = ResourceHandle::delegate();
     101   
     102    NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:d->m_request.nsURLRequest() delegate:delegate];
    94103#ifndef NDEBUG
    95104    isInitializingConnection = NO;
    … …  
    156165}
    157166
     167id ResourceHandle::releaseProxy()
     168{
     169    id proxy = [[d->m_proxy.get() retain] autorelease];
     170    d->m_proxy = nil;
     171    [proxy setDelegate:nil];
     172    return proxy;
     173}
     174
     175NSURLConnection *ResourceHandle::connection() const
     176{
     177    return d->m_connection.get();
     178}
     179
     180bool ResourceHandle::loadsBlocked()
     181{
     182    return inNSURLConnectionCallback != 0;
     183}
     184
    158185} // namespace WebCore
    159186

  • trunk/WebKit/ChangeLog

    r18169 r18184  
     12006-12-12  Anders Carlsson  <acarlsson@apple.com>
     2
     3        Reviewed by Darin.
     4
     5        * WebCoreSupport/WebFrameLoaderClient.h:
     6        * WebCoreSupport/WebFrameLoaderClient.mm:
     7        (WebFrameLoaderClient::download):
     8        Get the handle and proxy from the ResourceHandle now that they aren't passed to us.
     9       
    1102006-12-11  Darin Adler  <darin@apple.com>
    211

  • trunk/WebKit/WebCoreSupport/WebFrameLoaderClient.h

    r17906 r18184  
    9898    virtual void loadedFromPageCache();
    9999
    100     virtual void download(NSURLConnection *, NSURLRequest *, NSURLResponse *, id proxy);
     100    virtual void download(WebCore::ResourceHandle*, NSURLRequest *, NSURLResponse *);
    101101
    102102    virtual id dispatchIdentifierForInitialRequest(WebCore::DocumentLoader*, NSURLRequest *);

  • trunk/WebKit/WebCoreSupport/WebFrameLoaderClient.mm

    r18163 r18184  
    8080#import <WebCore/PageState.h>
    8181#import <WebCore/PlatformString.h>
     82#import <WebCore/ResourceHandle.h>
    8283#import <WebCore/ResourceLoader.h>
    8384#import <WebCore/ResourceRequest.h>
    … …  
    415416}
    416417
    417 void WebFrameLoaderClient::download(NSURLConnection *connection, NSURLRequest *request,
    418     NSURLResponse *response, id proxy)
    419 {
    420     [WebDownload _downloadWithLoadingConnection:connection
     418void WebFrameLoaderClient::download(ResourceHandle* handle, NSURLRequest *request, NSURLResponse *response)
     419{
     420    id proxy = handle->releaseProxy();
     421    ASSERT(proxy);
     422    [WebDownload _downloadWithLoadingConnection:handle->connection()
    421423                                        request:request
    422424                                       response:response
Note: See TracChangeset for help on using the changeset viewer.