WebCore:
authordarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 24 Oct 2006 06:19:43 +0000 (06:19 +0000)
committerdarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 24 Oct 2006 06:19:43 +0000 (06:19 +0000)
        Reviewed by Geoff.

        - converted WebDocumentLoader to C++

        * WebCore.exp:
        * bridge/mac/WebCoreFrameBridge.mm:
        (-[WebCoreFrameBridge setTitle:]):
        (-[WebCoreFrameBridge originalRequestURL]):
        (-[WebCoreFrameBridge receivedData:textEncodingName:]):
        (-[WebCoreFrameBridge syncLoadResourceWithMethod:URL:customHeaders:postData:finalURL:responseHeaders:statusCode:]):
        (-[WebCoreFrameBridge incomingReferrer]):
        (-[WebCoreFrameBridge isReloading]):
        (-[WebCoreFrameBridge mainResourceURLResponse]):
        * loader/mac/WebDocumentLoader.h:
        * loader/mac/WebDocumentLoader.mm:
        (WebCore::DocumentLoader::DocumentLoader):
        (WebCore::DocumentLoader::frameLoader):
        (WebCore::DocumentLoader::~DocumentLoader):
        (WebCore::DocumentLoader::setMainResourceData):
        (WebCore::DocumentLoader::mainResourceData):
        (WebCore::DocumentLoader::originalRequest):
        (WebCore::DocumentLoader::originalRequestCopy):
        (WebCore::DocumentLoader::request):
        (WebCore::DocumentLoader::initialRequest):
        (WebCore::DocumentLoader::actualRequest):
        (WebCore::DocumentLoader::URL):
        (WebCore::DocumentLoader::unreachableURL):
        (WebCore::DocumentLoader::replaceRequestURLForAnchorScroll):
        (WebCore::DocumentLoader::setRequest):
        (WebCore::DocumentLoader::setResponse):
        (WebCore::DocumentLoader::isStopping):
        (WebCore::DocumentLoader::bridge):
        (WebCore::DocumentLoader::setMainDocumentError):
        (WebCore::DocumentLoader::mainDocumentError):
        (WebCore::DocumentLoader::clearErrors):
        (WebCore::DocumentLoader::mainReceivedError):
        (WebCore::DocumentLoader::stopLoading):
        (WebCore::DocumentLoader::setupForReplace):
        (WebCore::DocumentLoader::commitIfReady):
        (WebCore::DocumentLoader::finishedLoading):
        (WebCore::DocumentLoader::setCommitted):
        (WebCore::DocumentLoader::isCommitted):
        (WebCore::DocumentLoader::setLoading):
        (WebCore::DocumentLoader::isLoading):
        (WebCore::DocumentLoader::commitLoad):
        (WebCore::DocumentLoader::doesProgressiveLoad):
        (WebCore::DocumentLoader::receivedData):
        (WebCore::DocumentLoader::setupForReplaceByMIMEType):
        (WebCore::DocumentLoader::updateLoading):
        (WebCore::DocumentLoader::response):
        (WebCore::DocumentLoader::setFrame):
        (WebCore::DocumentLoader::attachToFrame):
        (WebCore::DocumentLoader::detachFromFrame):
        (WebCore::DocumentLoader::prepareForLoadStart):
        (WebCore::DocumentLoader::loadingStartedTime):
        (WebCore::DocumentLoader::setIsClientRedirect):
        (WebCore::DocumentLoader::isClientRedirect):
        (WebCore::DocumentLoader::setPrimaryLoadComplete):
        (WebCore::DocumentLoader::isLoadingInAPISense):
        (WebCore::DocumentLoader::addResponse):
        (WebCore::DocumentLoader::stopRecordingResponses):
        (WebCore::DocumentLoader::title):
        (WebCore::DocumentLoader::setLastCheckedRequest):
        (WebCore::DocumentLoader::lastCheckedRequest):
        (WebCore::DocumentLoader::triggeringAction):
        (WebCore::DocumentLoader::setTriggeringAction):
        (WebCore::DocumentLoader::responses):
        (WebCore::DocumentLoader::setOverrideEncoding):
        (WebCore::DocumentLoader::overrideEncoding):
        (WebCore::DocumentLoader::setTitle):
        (WebCore::DocumentLoader::URLForHistory):
        * loader/mac/WebFrameLoader.h:
        * loader/mac/WebFrameLoader.mm:
        (WebCore::FrameLoader::setupForReplaceByMIMEType):
        (WebCore::FrameLoader::finalSetupForReplace):
        (WebCore::FrameLoader::safeLoad):
        (WebCore::FrameLoader::load):
        (WebCore::FrameLoader::startLoading):
        (WebCore::FrameLoader::stopLoading):
        (WebCore::FrameLoader::activeDocumentLoader):
        (WebCore::FrameLoader::addPlugInStreamLoader):
        (WebCore::FrameLoader::removePlugInStreamLoader):
        (WebCore::FrameLoader::addSubresourceLoader):
        (WebCore::FrameLoader::removeSubresourceLoader):
        (WebCore::FrameLoader::setDocumentLoader):
        (WebCore::FrameLoader::documentLoader):
        (WebCore::FrameLoader::setPolicyDocumentLoader):
        (WebCore::FrameLoader::provisionalDocumentLoader):
        (WebCore::FrameLoader::setProvisionalDocumentLoader):
        (WebCore::FrameLoader::setState):
        (WebCore::FrameLoader::clearProvisionalLoad):
        (WebCore::FrameLoader::commitProvisionalLoad):
        (WebCore::FrameLoader::didReceiveResponse):
        (WebCore::FrameLoader::originalRequest):
        (WebCore::FrameLoader::receivedMainResourceError):
        (WebCore::FrameLoader::continueFragmentScrollAfterNavigationPolicy):
        (WebCore::FrameLoader::opened):
        (WebCore::FrameLoader::initialRequest):
        (WebCore::FrameLoader::receivedData):
        (WebCore::FrameLoader::setRequest):
        (WebCore::FrameLoader::isStopping):
        (WebCore::FrameLoader::setResponse):
        (WebCore::FrameLoader::mainReceivedError):
        (WebCore::FrameLoader::finishedLoading):
        (WebCore::FrameLoader::notifyIconChanged):
        (WebCore::FrameLoader::URL):
        (WebCore::FrameLoader::checkContentPolicy):
        (WebCore::FrameLoader::shouldReloadToHandleUnreachableURL):
        (WebCore::FrameLoader::reloadAllowingStaleData):
        (WebCore::FrameLoader::reload):
        (WebCore::FrameLoader::finishedLoadingDocument):
        (WebCore::FrameLoader::committedLoad):
        (WebCore::FrameLoader::revertToProvisional):
        (WebCore::FrameLoader::setMainDocumentError):
        (WebCore::FrameLoader::mainReceivedCompleteError):
        (WebCore::FrameLoader::subframeIsLoading):
        (WebCore::FrameLoader::willChangeTitle):
        (WebCore::FrameLoader::didChangeTitle):
        (WebCore::FrameLoader::checkNavigationPolicy):
        (WebCore::FrameLoader::continueLoadRequestAfterNavigationPolicy):
        (WebCore::FrameLoader::transitionToCommitted):
        (WebCore::FrameLoader::checkLoadCompleteForThisFrame):
        (WebCore::FrameLoader::detachFromParent):
        * loader/mac/WebFrameLoaderClient.h:

WebKit:

        Reviewed by Geoff.

        - converted WebDocumentLoader to C++

        * Plugins/WebPluginController.mm:
        (-[WebPluginController pluginView:receivedResponse:]):
        * WebKit.xcodeproj/project.pbxproj:
        * WebView/WebDataSource.mm:
        (-[WebDataSourcePrivate dealloc]):
        (-[WebDataSource _mainDocumentError]):
        (-[WebDataSource _URL]):
        (-[WebDataSource _loadFromPageCache:]):
        (-[WebDataSource _bridge]):
        (-[WebDataSource _URLForHistory]):
        (-[WebDataSource _documentLoader]):
        (-[WebDataSource _initWithDocumentLoader:]):
        (-[WebDataSource initWithRequest:]):
        (-[WebDataSource data]):
        (-[WebDataSource webFrame]):
        (-[WebDataSource initialRequest]):
        (-[WebDataSource request]):
        (-[WebDataSource response]):
        (-[WebDataSource textEncodingName]):
        (-[WebDataSource isLoading]):
        (-[WebDataSource unreachableURL]):
        (-[WebDataSource webArchive]):
        * WebView/WebDataSourceInternal.h:
        * WebView/WebDocumentLoaderMac.h:
        * WebView/WebDocumentLoaderMac.mm:
        (WebDocumentLoaderMac::WebDocumentLoaderMac):
        (WebDocumentLoaderMac::setDataSource):
        (WebDocumentLoaderMac::dataSource):
        (WebDocumentLoaderMac::attachToFrame):
        (WebDocumentLoaderMac::detachFromFrame):
        * WebView/WebFrame.mm:
        (-[WebFrame _createItem:]):
        (-[WebFrame _loadItem:withLoadType:]):
        (-[WebFrame _addChild:]):
        (dataSource):
        (-[WebFrame _dataSourceForDocumentLoader:]):
        (-[WebFrame _addDocumentLoader:toUnarchiveState:]):
        (-[WebFrame loadArchive:]):
        (-[WebFrame _updateHistoryForReload]):
        (-[WebFrame _updateHistoryForStandardLoad]):
        (-[WebFrame _updateHistoryForInternalLoad]):
        (-[WebFrame _dispatchIdentifierForInitialRequest:fromDocumentLoader:]):
        (-[WebFrame _dispatchResource:willSendRequest:redirectResponse:fromDocumentLoader:]):
        (-[WebFrame _dispatchDidReceiveAuthenticationChallenge:forResource:fromDocumentLoader:]):
        (-[WebFrame _dispatchDidCancelAuthenticationChallenge:forResource:fromDocumentLoader:]):
        (-[WebFrame _dispatchResource:didReceiveResponse:fromDocumentLoader:]):
        (-[WebFrame _dispatchResource:didReceiveContentLength:fromDocumentLoader:]):
        (-[WebFrame _dispatchResource:didFinishLoadingFromDocumentLoader:]):
        (-[WebFrame _dispatchResource:didFailLoadingWithError:fromDocumentLoader:]):
        (-[WebFrame _dispatchDidLoadMainResourceForDocumentLoader:]):
        (-[WebFrame _clearLoadingFromPageCacheForDocumentLoader:]):
        (-[WebFrame _isDocumentLoaderLoadingFromPageCache:]):
        (-[WebFrame _makeRepresentationForDocumentLoader:]):
        (-[WebFrame _revertToProvisionalStateForDocumentLoader:]):
        (-[WebFrame _setMainDocumentError:forDocumentLoader:]):
        (-[WebFrame _clearUnarchivingStateForLoader:]):
        (-[WebFrame _willChangeTitleForDocument:]):
        (-[WebFrame _didChangeTitleForDocument:]):
        (-[WebFrame _finishedLoadingDocument:]):
        (-[WebFrame _committedLoadWithDocumentLoader:data:]):
        (-[WebFrame _documentLoader:setMainDocumentError:]):
        (-[WebFrame _finalSetupForReplaceWithDocumentLoader:]):
        (-[WebFrame _createDocumentLoaderWithRequest:]):
        (-[WebFrame _provisionalLoadStarted]):
        * WebView/WebFrameInternal.h:
        * WebView/WebHTMLRepresentation.m:
        (-[WebHTMLRepresentation title]):
        * WebView/WebView.mm:
        (-[WebView _mainFrameOverrideEncoding]):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@17245 268f45cc-cd09-0410-ab3c-d52691b4dbfc

19 files changed:
WebCore/ChangeLog
WebCore/WebCore.exp
WebCore/bridge/mac/WebCoreFrameBridge.mm
WebCore/loader/mac/WebDocumentLoader.h
WebCore/loader/mac/WebDocumentLoader.mm
WebCore/loader/mac/WebFrameLoader.h
WebCore/loader/mac/WebFrameLoader.mm
WebCore/loader/mac/WebFrameLoaderClient.h
WebKit/ChangeLog
WebKit/Plugins/WebPluginController.mm
WebKit/WebKit.xcodeproj/project.pbxproj
WebKit/WebView/WebDataSource.mm
WebKit/WebView/WebDataSourceInternal.h
WebKit/WebView/WebDocumentLoaderMac.h
WebKit/WebView/WebDocumentLoaderMac.mm
WebKit/WebView/WebFrame.mm
WebKit/WebView/WebFrameInternal.h
WebKit/WebView/WebHTMLRepresentation.m
WebKit/WebView/WebView.mm

index 467afabbf93869d80155b232eb7b2676b639db86..ec53e4bb0858df3f32ea9b10b0d907db9aaeb605 100644 (file)
@@ -1,3 +1,130 @@
+2006-10-23  Darin Adler  <darin@apple.com>
+
+        Reviewed by Geoff.
+
+        - converted WebDocumentLoader to C++
+
+        * WebCore.exp:
+        * bridge/mac/WebCoreFrameBridge.mm:
+        (-[WebCoreFrameBridge setTitle:]):
+        (-[WebCoreFrameBridge originalRequestURL]):
+        (-[WebCoreFrameBridge receivedData:textEncodingName:]):
+        (-[WebCoreFrameBridge syncLoadResourceWithMethod:URL:customHeaders:postData:finalURL:responseHeaders:statusCode:]):
+        (-[WebCoreFrameBridge incomingReferrer]):
+        (-[WebCoreFrameBridge isReloading]):
+        (-[WebCoreFrameBridge mainResourceURLResponse]):
+        * loader/mac/WebDocumentLoader.h:
+        * loader/mac/WebDocumentLoader.mm:
+        (WebCore::DocumentLoader::DocumentLoader):
+        (WebCore::DocumentLoader::frameLoader):
+        (WebCore::DocumentLoader::~DocumentLoader):
+        (WebCore::DocumentLoader::setMainResourceData):
+        (WebCore::DocumentLoader::mainResourceData):
+        (WebCore::DocumentLoader::originalRequest):
+        (WebCore::DocumentLoader::originalRequestCopy):
+        (WebCore::DocumentLoader::request):
+        (WebCore::DocumentLoader::initialRequest):
+        (WebCore::DocumentLoader::actualRequest):
+        (WebCore::DocumentLoader::URL):
+        (WebCore::DocumentLoader::unreachableURL):
+        (WebCore::DocumentLoader::replaceRequestURLForAnchorScroll):
+        (WebCore::DocumentLoader::setRequest):
+        (WebCore::DocumentLoader::setResponse):
+        (WebCore::DocumentLoader::isStopping):
+        (WebCore::DocumentLoader::bridge):
+        (WebCore::DocumentLoader::setMainDocumentError):
+        (WebCore::DocumentLoader::mainDocumentError):
+        (WebCore::DocumentLoader::clearErrors):
+        (WebCore::DocumentLoader::mainReceivedError):
+        (WebCore::DocumentLoader::stopLoading):
+        (WebCore::DocumentLoader::setupForReplace):
+        (WebCore::DocumentLoader::commitIfReady):
+        (WebCore::DocumentLoader::finishedLoading):
+        (WebCore::DocumentLoader::setCommitted):
+        (WebCore::DocumentLoader::isCommitted):
+        (WebCore::DocumentLoader::setLoading):
+        (WebCore::DocumentLoader::isLoading):
+        (WebCore::DocumentLoader::commitLoad):
+        (WebCore::DocumentLoader::doesProgressiveLoad):
+        (WebCore::DocumentLoader::receivedData):
+        (WebCore::DocumentLoader::setupForReplaceByMIMEType):
+        (WebCore::DocumentLoader::updateLoading):
+        (WebCore::DocumentLoader::response):
+        (WebCore::DocumentLoader::setFrame):
+        (WebCore::DocumentLoader::attachToFrame):
+        (WebCore::DocumentLoader::detachFromFrame):
+        (WebCore::DocumentLoader::prepareForLoadStart):
+        (WebCore::DocumentLoader::loadingStartedTime):
+        (WebCore::DocumentLoader::setIsClientRedirect):
+        (WebCore::DocumentLoader::isClientRedirect):
+        (WebCore::DocumentLoader::setPrimaryLoadComplete):
+        (WebCore::DocumentLoader::isLoadingInAPISense):
+        (WebCore::DocumentLoader::addResponse):
+        (WebCore::DocumentLoader::stopRecordingResponses):
+        (WebCore::DocumentLoader::title):
+        (WebCore::DocumentLoader::setLastCheckedRequest):
+        (WebCore::DocumentLoader::lastCheckedRequest):
+        (WebCore::DocumentLoader::triggeringAction):
+        (WebCore::DocumentLoader::setTriggeringAction):
+        (WebCore::DocumentLoader::responses):
+        (WebCore::DocumentLoader::setOverrideEncoding):
+        (WebCore::DocumentLoader::overrideEncoding):
+        (WebCore::DocumentLoader::setTitle):
+        (WebCore::DocumentLoader::URLForHistory):
+        * loader/mac/WebFrameLoader.h:
+        * loader/mac/WebFrameLoader.mm:
+        (WebCore::FrameLoader::setupForReplaceByMIMEType):
+        (WebCore::FrameLoader::finalSetupForReplace):
+        (WebCore::FrameLoader::safeLoad):
+        (WebCore::FrameLoader::load):
+        (WebCore::FrameLoader::startLoading):
+        (WebCore::FrameLoader::stopLoading):
+        (WebCore::FrameLoader::activeDocumentLoader):
+        (WebCore::FrameLoader::addPlugInStreamLoader):
+        (WebCore::FrameLoader::removePlugInStreamLoader):
+        (WebCore::FrameLoader::addSubresourceLoader):
+        (WebCore::FrameLoader::removeSubresourceLoader):
+        (WebCore::FrameLoader::setDocumentLoader):
+        (WebCore::FrameLoader::documentLoader):
+        (WebCore::FrameLoader::setPolicyDocumentLoader):
+        (WebCore::FrameLoader::provisionalDocumentLoader):
+        (WebCore::FrameLoader::setProvisionalDocumentLoader):
+        (WebCore::FrameLoader::setState):
+        (WebCore::FrameLoader::clearProvisionalLoad):
+        (WebCore::FrameLoader::commitProvisionalLoad):
+        (WebCore::FrameLoader::didReceiveResponse):
+        (WebCore::FrameLoader::originalRequest):
+        (WebCore::FrameLoader::receivedMainResourceError):
+        (WebCore::FrameLoader::continueFragmentScrollAfterNavigationPolicy):
+        (WebCore::FrameLoader::opened):
+        (WebCore::FrameLoader::initialRequest):
+        (WebCore::FrameLoader::receivedData):
+        (WebCore::FrameLoader::setRequest):
+        (WebCore::FrameLoader::isStopping):
+        (WebCore::FrameLoader::setResponse):
+        (WebCore::FrameLoader::mainReceivedError):
+        (WebCore::FrameLoader::finishedLoading):
+        (WebCore::FrameLoader::notifyIconChanged):
+        (WebCore::FrameLoader::URL):
+        (WebCore::FrameLoader::checkContentPolicy):
+        (WebCore::FrameLoader::shouldReloadToHandleUnreachableURL):
+        (WebCore::FrameLoader::reloadAllowingStaleData):
+        (WebCore::FrameLoader::reload):
+        (WebCore::FrameLoader::finishedLoadingDocument):
+        (WebCore::FrameLoader::committedLoad):
+        (WebCore::FrameLoader::revertToProvisional):
+        (WebCore::FrameLoader::setMainDocumentError):
+        (WebCore::FrameLoader::mainReceivedCompleteError):
+        (WebCore::FrameLoader::subframeIsLoading):
+        (WebCore::FrameLoader::willChangeTitle):
+        (WebCore::FrameLoader::didChangeTitle):
+        (WebCore::FrameLoader::checkNavigationPolicy):
+        (WebCore::FrameLoader::continueLoadRequestAfterNavigationPolicy):
+        (WebCore::FrameLoader::transitionToCommitted):
+        (WebCore::FrameLoader::checkLoadCompleteForThisFrame):
+        (WebCore::FrameLoader::detachFromParent):
+        * loader/mac/WebFrameLoaderClient.h:
+
 2006-10-23  Brady Eidson  <beidson@apple.com>
 
         Lovingly reviewed by Maciej
index 26e6e07cf12764c9ce2519c78eea438b26d43a26..c1972eb37c7c58c3097bb50bd88eef98a900b208 100644 (file)
 .objc_class_name_WebCoreStringTruncator
 .objc_class_name_WebCoreViewFactory
 .objc_class_name_WebDashboardRegion
-.objc_class_name_WebDocumentLoader
 .objc_class_name_WebPolicyDecider
 .objc_class_name_WebScriptObject
 .objc_class_name_WebScriptObjectPrivate
@@ -149,11 +148,20 @@ __ZN7WebCore11FrameLoader25provisionalDocumentLoaderEv
 __ZN7WebCore11FrameLoader4loadEP12NSURLRequest
 __ZN7WebCore11FrameLoader4loadEP12NSURLRequestP12NSDictionary13FrameLoadTypeN3WTF10PassRefPtrINS_9FormStateEEE
 __ZN7WebCore11FrameLoader4loadEP12NSURLRequestP8NSString
-__ZN7WebCore11FrameLoader4loadEP17WebDocumentLoader
-__ZN7WebCore11FrameLoader4loadEP17WebDocumentLoader13FrameLoadTypeN3WTF10PassRefPtrINS_9FormStateEEE
 __ZN7WebCore11FrameLoader4loadEP5NSURLP8NSString13FrameLoadTypeS4_P7NSEventP10DOMElementP12NSDictionary
+__ZN7WebCore11FrameLoader4loadEPNS_14DocumentLoaderE
+__ZN7WebCore11FrameLoader4loadEPNS_14DocumentLoaderE13FrameLoadTypeN3WTF10PassRefPtrINS_9FormStateEEE
 __ZN7WebCore11FrameLoader6reloadEv
 __ZN7WebCore11FrameLoader8safeLoadEP5NSURL
+__ZN7WebCore14DocumentLoader12setCommittedEb
+__ZN7WebCore14DocumentLoader13attachToFrameEv
+__ZN7WebCore14DocumentLoader15detachFromFrameEv
+__ZN7WebCore14DocumentLoader19prepareForLoadStartEv
+__ZN7WebCore14DocumentLoader19setOverrideEncodingEP8NSString
+__ZN7WebCore14DocumentLoader32replaceRequestURLForAnchorScrollEP5NSURL
+__ZN7WebCore14DocumentLoader7requestEv
+__ZN7WebCore14DocumentLoaderC2EP12NSURLRequest
+__ZN7WebCore14DocumentLoaderD2Ev
 __ZN7WebCore17WebResourceLoader14cancelledErrorEv
 __ZN7WebCore17WebResourceLoader20inConnectionCallbackEv
 __ZN7WebCore21isBackForwardLoadTypeE13FrameLoadType
@@ -165,6 +173,22 @@ __ZNK7WebCore11FrameLoader20activeDocumentLoaderEv
 __ZNK7WebCore11FrameLoader21isQuickRedirectComingEv
 __ZNK7WebCore11FrameLoader6clientEv
 __ZNK7WebCore11FrameLoader8loadTypeEv
+__ZNK7WebCore14DocumentLoader10isStoppingEv
+__ZNK7WebCore14DocumentLoader11frameLoaderEv
+__ZNK7WebCore14DocumentLoader11isCommittedEv
+__ZNK7WebCore14DocumentLoader13URLForHistoryEv
+__ZNK7WebCore14DocumentLoader14initialRequestEv
+__ZNK7WebCore14DocumentLoader14unreachableURLEv
+__ZNK7WebCore14DocumentLoader16isClientRedirectEv
+__ZNK7WebCore14DocumentLoader16mainResourceDataEv
+__ZNK7WebCore14DocumentLoader16overrideEncodingEv
+__ZNK7WebCore14DocumentLoader17mainDocumentErrorEv
+__ZNK7WebCore14DocumentLoader19isLoadingInAPISenseEv
+__ZNK7WebCore14DocumentLoader19originalRequestCopyEv
+__ZNK7WebCore14DocumentLoader3URLEv
+__ZNK7WebCore14DocumentLoader5titleEv
+__ZNK7WebCore14DocumentLoader8responseEv
+__ZNK7WebCore14DocumentLoader9isLoadingEv
 __ZNK7WebCore17WebResourceLoader11frameLoaderEv
 __ZNK7WebCore26NetscapePlugInStreamLoader6isDoneEv
 _canonicalURL
index 796d0f4e2f70cafc0abde1cb4faa352e756ce707..a2317a460832f1985aebf413a2ef50def5f89433 100644 (file)
@@ -2669,7 +2669,7 @@ static NSString *stringByCollapsingNonPrintingCharacters(NSString *string)
 {
     if (!m_frame)
         return;
-    [m_frameLoader->documentLoader() setTitle:stringByCollapsingNonPrintingCharacters(title)];
+    m_frameLoader->documentLoader()->setTitle(stringByCollapsingNonPrintingCharacters(title));
 }
 
 - (void)didFirstLayout
@@ -2688,7 +2688,7 @@ static NSString *stringByCollapsingNonPrintingCharacters(NSString *string)
 
 - (NSURL*)originalRequestURL
 {
-    return [[m_frameLoader->activeDocumentLoader() initialRequest] URL];
+    return [m_frameLoader->activeDocumentLoader()->initialRequest() URL];
 }
 
 - (BOOL)isLoadTypeReload
@@ -2710,13 +2710,11 @@ static NSString *stringByCollapsingNonPrintingCharacters(NSString *string)
 - (void)receivedData:(NSData *)data textEncodingName:(NSString *)textEncodingName
 {
     // Set the encoding. This only needs to be done once, but it's harmless to do it again later.
-    NSString *encoding = [m_frameLoader->documentLoader() overrideEncoding];
-    BOOL userChosen = encoding != nil;
-    if (encoding == nil) {
+    NSString *encoding = m_frameLoader->documentLoader()->overrideEncoding();
+    bool userChosen = encoding != nil;
+    if (!encoding)
         encoding = textEncodingName;
-    }
     [self setEncoding:encoding userChosen:userChosen];
-    
     [self addData:data];
 }
 
@@ -2800,12 +2798,12 @@ static NSString *stringByCollapsingNonPrintingCharacters(NSString *string)
     if (isConditionalRequest(request))
         [request setCachePolicy:NSURLRequestReloadIgnoringCacheData];
     else
-        [request setCachePolicy:[[m_frameLoader->documentLoader() request] cachePolicy]];
+        [request setCachePolicy:[m_frameLoader->documentLoader()->request() cachePolicy]];
     if (!hideReferrer)
         setHTTPReferrer(request, [self referrer]);
     
     WebCorePageBridge *page = [self page];
-    [request setMainDocumentURL:[[[[page mainFrame] frameLoader]->documentLoader() request] URL]];
+    [request setMainDocumentURL:[[[page mainFrame] frameLoader]->documentLoader()->request() URL]];
     [request setValue:[self userAgentForURL:[request URL]] forHTTPHeaderField:@"User-Agent"];
     
     NSError *error = nil;
@@ -2848,12 +2846,12 @@ static NSString *stringByCollapsingNonPrintingCharacters(NSString *string)
 
 - (NSString *)incomingReferrer
 {
-    return [[m_frameLoader->documentLoader() request] valueForHTTPHeaderField:@"Referer"];
+    return [m_frameLoader->documentLoader()->request() valueForHTTPHeaderField:@"Referer"];
 }
 
 - (BOOL)isReloading
 {
-    return [[m_frameLoader->documentLoader() request] cachePolicy] == NSURLRequestReloadIgnoringCacheData;
+    return [m_frameLoader->documentLoader()->request() cachePolicy] == NSURLRequestReloadIgnoringCacheData;
 }
 
 - (void)handledOnloadEvents
@@ -2861,9 +2859,9 @@ static NSString *stringByCollapsingNonPrintingCharacters(NSString *string)
     [m_frameLoader->client() _dispatchDidHandleOnloadEventsForFrame];
 }
 
-- (NSURLResponse*)mainResourceURLResponse
+- (NSURLResponse *)mainResourceURLResponse
 {
-    return [m_frameLoader->documentLoader() response];
+    return m_frameLoader->documentLoader()->response();
 }
 
 - (void)loadEmptyDocumentSynchronously
index f472c75a1d0fa521f4e4da91c5e10fd7cee80c3e..3172b54a9e972a7df6eb461f4e60ef35865126ed 100644 (file)
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#import <Cocoa/Cocoa.h>
+#include "RetainPtr.h"
+#include "Shared.h"
+#include <wtf/Vector.h>
+
+@class WebCoreFrameBridge;
 
 namespace WebCore {
+
     class Frame;
     class FrameLoader;
-}
 
-@interface WebDocumentLoader : NSObject
-{
-@public
-    WebCore::Frame* m_frame;
-    
-    NSData *mainResourceData;
+    typedef Vector<RetainPtr<NSURLResponse> > ResponseVector;
 
-    // A reference to actual request used to create the data source.
-    // This should only be used by the resourceLoadDelegate's
-    // identifierForInitialRequest:fromDatasource: method.  It is
-    // not guaranteed to remain unchanged, as requests are mutable.
-    NSURLRequest *originalRequest;    
+    class DocumentLoader : public Shared<DocumentLoader> {
+    public:
+        DocumentLoader(NSURLRequest *);
+        virtual ~DocumentLoader();
 
-    // A copy of the original request used to create the data source.
-    // We have to copy the request because requests are mutable.
-    NSURLRequest *originalRequestCopy;
-    
-    // The 'working' request for this datasource.  It may be mutated
-    // several times from the original request to include additional
-    // headers, cookie information, canonicalization and redirects.
-    NSMutableURLRequest *request;
+        void setFrame(Frame*);
+        virtual void attachToFrame();
+        virtual void detachFromFrame();
 
-    NSURLResponse *response;
-    
-    NSError *mainDocumentError;    
-    
-    // The time when the data source was told to start loading.
-    double loadingStartedTime;
-
-    BOOL committed;
-    BOOL stopping;
-    BOOL loading;
-    BOOL gotFirstByte;
-    BOOL primaryLoadComplete;
-    BOOL isClientRedirect;
-    
-    NSString *pageTitle;
-    
-    NSString *encoding;
-    NSString *overrideEncoding;
-    
-    // The action that triggered loading of this data source -
-    // we keep this around for the benefit of the various policy
-    // handlers.
-    NSDictionary *triggeringAction;
+        FrameLoader* frameLoader() const;
+        NSData *mainResourceData() const;
+        NSURLRequest *originalRequest() const;
+        NSURLRequest *originalRequestCopy() const;
+        NSMutableURLRequest *request();
+        void setRequest(NSURLRequest *);
+        NSMutableURLRequest *actualRequest();
+        NSURLRequest *initialRequest() const;
+        NSURL *URL() const;
+        NSURL *unreachableURL() const;
+        void replaceRequestURLForAnchorScroll(NSURL *);
+        bool isStopping() const;
+        void stopLoading();
+        void setCommitted(bool);
+        bool isCommitted() const;
+        bool isLoading() const;
+        void setLoading(bool);
+        void updateLoading();
+        void receivedData(NSData *);
+        void setupForReplaceByMIMEType(NSString *newMIMEType);
+        void finishedLoading();
+        NSURLResponse *response() const;
+        NSError *mainDocumentError() const;
+        void mainReceivedError(NSError *, bool isComplete);
+        void setResponse(NSURLResponse *);
+        void prepareForLoadStart();
+        bool isClientRedirect() const;
+        void setIsClientRedirect(bool);
+        bool isLoadingInAPISense() const;
+        void setPrimaryLoadComplete(bool);
+        void setTitle(NSString *);
+        NSString *overrideEncoding() const;
+        void addResponse(NSURLResponse *);
+        const ResponseVector& responses() const;
+        NSDictionary *triggeringAction() const;
+        void setTriggeringAction(NSDictionary *);
+        void setOverrideEncoding(NSString *);
+        void setLastCheckedRequest(NSURLRequest *request);
+        NSURLRequest *lastCheckedRequest() const;
+        void stopRecordingResponses();
+        NSString *title() const;
+        NSURL *URLForHistory() const;
+
+    private:
+        void setMainResourceData(NSData *);
+        void setupForReplace();
+        void commitIfReady();
+        void clearErrors();
+        double loadingStartedTime() const;
+        WebCoreFrameBridge *bridge() const;
+        void setMainDocumentError(NSError *);
+        void commitLoad(NSData *);
+        bool doesProgressiveLoad(NSString *MIMEType) const;
+
+        Frame* m_frame;
+
+        RetainPtr<NSData> m_mainResourceData;
+
+        // A reference to actual request used to create the data source.
+        // This should only be used by the resourceLoadDelegate's
+        // identifierForInitialRequest:fromDatasource: method. It is
+        // not guaranteed to remain unchanged, as requests are mutable.
+        RetainPtr<NSURLRequest> m_originalRequest;    
+
+        // A copy of the original request used to create the data source.
+        // We have to copy the request because requests are mutable.
+        RetainPtr<NSURLRequest> m_originalRequestCopy;
+        
+        // The 'working' request. It may be mutated
+        // several times from the original request to include additional
+        // headers, cookie information, canonicalization and redirects.
+        RetainPtr<NSMutableURLRequest> m_request;
+
+        RetainPtr<NSURLResponse> m_response;
     
-    // The last request that we checked click policy for - kept around
-    // so we can avoid asking again needlessly.
-    NSURLRequest *lastCheckedRequest;
+        RetainPtr<NSError> m_mainDocumentError;    
     
-    // We retain all the received responses so we can play back the
-    // WebResourceLoadDelegate messages if the item is loaded from the
-    // page cache.
-    NSMutableArray *responses;
-    BOOL stopRecordingResponses;        
-}
+        // The time when the data source was told to start loading.
+        double m_loadingStartedTime;
+
+        bool m_committed;
+        bool m_stopping;
+        bool m_loading;
+        bool m_gotFirstByte;
+        bool m_primaryLoadComplete;
+        bool m_isClientRedirect;
 
-- (id)initWithRequest:(NSURLRequest *)request;
-- (void)setFrame:(WebCore::Frame*)frame;
-- (WebCore::FrameLoader*)frameLoader;
-- (void)setMainResourceData:(NSData *)data;
-- (NSData *)mainResourceData;
-- (NSURLRequest *)originalRequest;
-- (NSURLRequest *)originalRequestCopy;
-- (NSMutableURLRequest *)request;
-- (void)setRequest:(NSURLRequest *)request;
-- (NSMutableURLRequest *)actualRequest;
-- (NSURLRequest *)initialRequest;
-- (NSURL *)URL;
-- (NSURL *)unreachableURL;
-- (void)replaceRequestURLForAnchorScrollWithURL:(NSURL *)URL;
-- (BOOL)isStopping;
-- (void)stopLoading;
-- (void)setupForReplace;
-- (void)commitIfReady;
-- (void)setCommitted:(BOOL)f;
-- (BOOL)isCommitted;
-- (BOOL)isLoading;
-- (void)setLoading:(BOOL)f;
-- (void)updateLoading;
-- (void)receivedData:(NSData *)data;
-- (void)setupForReplaceByMIMEType:(NSString *)newMIMEType;
-- (void)finishedLoading;
-- (NSURLResponse *)response;
-- (void)clearErrors;
-- (NSError *)mainDocumentError;
-- (void)mainReceivedError:(NSError *)error complete:(BOOL)isComplete;
-- (void)setResponse:(NSURLResponse *)resp;
-- (void)attachToFrame;
-- (void)detachFromFrame;
-- (void)prepareForLoadStart;
-- (double)loadingStartedTime;
-- (BOOL)isClientRedirect;
-- (void)setIsClientRedirect:(BOOL)flag;
-- (BOOL)isLoadingInAPISense;
-- (void)setPrimaryLoadComplete:(BOOL)flag;
-- (void)setTitle:(NSString *)title;
-- (NSString *)overrideEncoding;
-- (void)addResponse:(NSURLResponse *)r;
-- (NSArray *)responses;
-- (NSDictionary *)triggeringAction;
-- (void)setTriggeringAction:(NSDictionary *)action;
-- (void)setOverrideEncoding:(NSString *)overrideEncoding;
-- (NSString *)overrideEncoding;
-- (NSDictionary *)triggeringAction;
-- (void)setTriggeringAction:(NSDictionary *)action;
-- (void)setLastCheckedRequest:(NSURLRequest *)request;
-- (NSURLRequest *)lastCheckedRequest;
-- (void)stopRecordingResponses;
-- (NSString *)title;
-- (NSURL *)URLForHistory;
-
-@end
+        RetainPtr<NSString> m_pageTitle;
+
+        RetainPtr<NSString> m_encoding;
+        RetainPtr<NSString> m_overrideEncoding;
+
+        // The action that triggered loading - we keep this around for the
+        // benefit of the various policy handlers.
+        RetainPtr<NSDictionary> m_triggeringAction;
+
+        // The last request that we checked click policy for - kept around
+        // so we can avoid asking again needlessly.
+        RetainPtr<NSURLRequest> m_lastCheckedRequest;
+
+        // We retain all the received responses so we can play back the
+        // WebResourceLoadDelegate messages if the item is loaded from the
+        // page cache.
+        ResponseVector m_responses;
+        bool m_stopRecordingResponses;
+    };
+
+}
index 0d313ff5b77af0e6b2b3b0cc32518cf28e4ddfb4..c2adeba862eed61c477efa4d561e40be88eae7b7 100644 (file)
 #import "WebFrameLoader.h"
 #import <wtf/Assertions.h>
 
-using namespace WebCore;
+namespace WebCore {
 
-@implementation WebDocumentLoader
-
-- (id)initWithRequest:(NSURLRequest *)req
+DocumentLoader::DocumentLoader(NSURLRequest *req)
+    : m_frame(0)
+    , m_originalRequest(req)
+    , m_originalRequestCopy([req copy])
+    , m_request([req mutableCopy])
+    , m_loadingStartedTime(0)
+    , m_committed(false)
+    , m_stopping(false)
+    , m_loading(false)
+    , m_gotFirstByte(false)
+    , m_primaryLoadComplete(false)
+    , m_isClientRedirect(false)
+    , m_stopRecordingResponses(false)
 {
-    self = [super init];
-    if (!self)
-        return nil;
-    
-    originalRequest = [req retain];
-    originalRequestCopy = [originalRequest copy];
-    request = [originalRequest mutableCopy];
-    wkSupportsMultipartXMixedReplace(request);
-
-    return self;
+    [m_originalRequestCopy.get() release];
+    [m_request.get() release];
+    wkSupportsMultipartXMixedReplace(m_request.get());
 }
 
-- (FrameLoader*)frameLoader
+FrameLoader* DocumentLoader::frameLoader() const
 {
     if (!m_frame)
         return 0;
     return [Mac(m_frame)->bridge() frameLoader];
 }
 
-- (void)dealloc
+DocumentLoader::~DocumentLoader()
 {
-    ASSERT(!m_frame || [self frameLoader]->activeDocumentLoader() != self || ![self frameLoader]->isLoading());
-
-    [mainResourceData release];
-    [originalRequest release];
-    [originalRequestCopy release];
-    [request release];
-    [response release];
-    [mainDocumentError release];
-    [pageTitle release];
-    [triggeringAction release];
-    [lastCheckedRequest release];
-    [responses release];    
-    
-    [super dealloc];
+    ASSERT(!m_frame || frameLoader()->activeDocumentLoader() != this || !frameLoader()->isLoading());
 }    
 
 
-- (void)setMainResourceData:(NSData *)data
+void DocumentLoader::setMainResourceData(NSData *data)
 {
-    [data retain];
-    [mainResourceData release];
-    mainResourceData = data;
+    m_mainResourceData = data;
 }
 
-- (NSData *)mainResourceData
+NSData *DocumentLoader::mainResourceData() const
 {
-    return mainResourceData != nil ? mainResourceData : [self frameLoader]->mainResourceData();
+    return m_mainResourceData ? m_mainResourceData.get() : frameLoader()->mainResourceData();
 }
 
-- (NSURLRequest *)originalRequest
+NSURLRequest *DocumentLoader::originalRequest() const
 {
-    return originalRequest;
+    return m_originalRequest.get();
 }
 
-- (NSURLRequest *)originalRequestCopy
+NSURLRequest *DocumentLoader::originalRequestCopy() const
 {
-    return originalRequestCopy;
+    return m_originalRequestCopy.get();
 }
 
-- (NSMutableURLRequest *)request
+NSMutableURLRequest *DocumentLoader::request()
 {
-    NSMutableURLRequest *clientRequest = [request _webDataRequestExternalRequest];
+    NSMutableURLRequest *clientRequest = [m_request.get() _webDataRequestExternalRequest];
     if (!clientRequest)
-        clientRequest = request;
+        clientRequest = m_request.get();
     return clientRequest;
 }
 
-- (NSURLRequest *)initialRequest
+NSURLRequest *DocumentLoader::initialRequest() const
 {
-    NSURLRequest *clientRequest = [[self originalRequest] _webDataRequestExternalRequest];
+    NSURLRequest *clientRequest = [m_originalRequest.get() _webDataRequestExternalRequest];
     if (!clientRequest)
-        clientRequest = [self originalRequest];
+        clientRequest = m_originalRequest.get();
     return clientRequest;
 }
 
-- (NSMutableURLRequest *)actualRequest
+NSMutableURLRequest *DocumentLoader::actualRequest()
 {
-    return request;
+    return m_request.get();
 }
 
-- (NSURL *)URL
+NSURL *DocumentLoader::URL() const
 {
-    return [[self request] URL];
+    return [const_cast<DocumentLoader*>(this)->request() URL];
 }
 
-- (NSURL *)unreachableURL
+NSURL *DocumentLoader::unreachableURL() const
 {
-    return [[self originalRequest] _webDataRequestUnreachableURL];
+    return [m_originalRequest.get() _webDataRequestUnreachableURL];
 }
 
-- (void)replaceRequestURLForAnchorScrollWithURL:(NSURL *)URL
+void DocumentLoader::replaceRequestURLForAnchorScroll(NSURL *URL)
 {
     // assert that URLs differ only by fragment ID
     
-    NSMutableURLRequest *newOriginalRequest = [originalRequestCopy mutableCopy];
-    [originalRequestCopy release];
+    NSMutableURLRequest *newOriginalRequest = [m_originalRequestCopy.get() mutableCopy];
     [newOriginalRequest setURL:URL];
-    originalRequestCopy = newOriginalRequest;
+    m_originalRequestCopy = newOriginalRequest;
+    [newOriginalRequest release];
     
-    NSMutableURLRequest *newRequest = [request mutableCopy];
-    [request release];
+    NSMutableURLRequest *newRequest = [m_request.get() mutableCopy];
     [newRequest setURL:URL];
-    request = newRequest;
+    m_request = newRequest;
+    [newRequest release];
 }
 
-- (void)setRequest:(NSURLRequest *)req
+void DocumentLoader::setRequest(NSURLRequest *req)
 {
-    ASSERT_ARG(req, req != request);
-    
+    ASSERT_ARG(req, req != m_request);
+
     // Replacing an unreachable URL with alternate content looks like a server-side
     // redirect at this point, but we can replace a committed dataSource.
-    BOOL handlingUnreachableURL = [req _webDataRequestUnreachableURL] != nil;
+    bool handlingUnreachableURL = [req _webDataRequestUnreachableURL] != nil;
     if (handlingUnreachableURL)
-        committed = NO;
-    
+        m_committed = false;
+
     // We should never be getting a redirect callback after the data
     // source is committed, except in the unreachable URL case. It 
     // would be a WebFoundation bug if it sent a redirect callback after commit.
-    ASSERT(!committed);
-    
-    NSURLRequest *oldRequest = request;
-    
-    request = [req mutableCopy];
-    
+    ASSERT(!m_committed);
+
+    NSURLRequest *oldRequest = [m_request.get() retain];
+    NSMutableURLRequest *copy = [req mutableCopy];
+    m_request = copy;
+    [copy release];
+
     // Only send webView:didReceiveServerRedirectForProvisionalLoadForFrame: if URL changed.
     // Also, don't send it when replacing unreachable URLs with alternate content.
     if (!handlingUnreachableURL && ![[oldRequest URL] isEqual:[req URL]])
-        [self frameLoader]->didReceiveServerRedirectForProvisionalLoadForFrame();
-    
+        frameLoader()->didReceiveServerRedirectForProvisionalLoadForFrame();
+
     [oldRequest release];
 }
 
-- (void)setResponse:(NSURLResponse *)resp
+void DocumentLoader::setResponse(NSURLResponse *resp)
 {
-    [resp retain];
-    [response release];
-    response = resp;
+    m_response = resp;
 }
 
-- (BOOL)isStopping
+bool DocumentLoader::isStopping() const
 {
-    return stopping;
+    return m_stopping;
 }
 
-- (WebCoreFrameBridge *)bridge
+WebCoreFrameBridge *DocumentLoader::bridge() const
 {
     if (!m_frame)
         return nil;
     return Mac(m_frame)->bridge();
 }
 
-- (void)setMainDocumentError:(NSError *)error
+void DocumentLoader::setMainDocumentError(NSError *error)
 {
-    [error retain];
-    [mainDocumentError release];
-    mainDocumentError = error;
-    
-    [self frameLoader]->setMainDocumentError(self, error);
+    m_mainDocumentError = error;    
+    frameLoader()->setMainDocumentError(this, error);
  }
 
-- (NSError *)mainDocumentError
+NSError *DocumentLoader::mainDocumentError() const
 {
-    return mainDocumentError;
+    return m_mainDocumentError.get();
 }
 
-- (void)clearErrors
+void DocumentLoader::clearErrors()
 {
-    [mainDocumentError release];
-    mainDocumentError = nil;
+    m_mainDocumentError = nil;
 }
 
-- (void)mainReceivedError:(NSError *)error complete:(BOOL)isComplete
+void DocumentLoader::mainReceivedError(NSError *error, bool isComplete)
 {
-    if (![self frameLoader])
+    if (!frameLoader())
         return;
-    
-    [self setMainDocumentError:error];
-    
+    setMainDocumentError(error);
     if (isComplete)
-        [self frameLoader]->mainReceivedCompleteError(self, error);
+        frameLoader()->mainReceivedCompleteError(this, error);
 }
 
 // Cancels the data source's pending loads.  Conceptually, a data source only loads
 // one document at a time, but one document may have many related resources. 
 // stopLoading will stop all loads initiated by the data source, 
 // but not loads initiated by child frames' data sources -- that's the WebFrame's job.
-- (void)stopLoading
+void DocumentLoader::stopLoading()
 {
     // Always attempt to stop the bridge/part because it may still be loading/parsing after the data source
     // is done loading and not stopping it can cause a world leak.
-    if (committed)
-        [[self bridge] stopLoading];
+    if (m_committed)
+        [bridge() stopLoading];
     
-    if (!loading)
+    if (!m_loading)
         return;
     
-    RefPtr<Frame> protect(m_frame);
-    [self retain];
+    RefPtr<Frame> protectFrame(m_frame);
+    RefPtr<DocumentLoader> protectLoader(this);
 
-    stopping = YES;
+    m_stopping = true;
 
-    FrameLoader* frameLoader = [self frameLoader];
+    FrameLoader* frameLoader = DocumentLoader::frameLoader();
     
     if (frameLoader->isLoadingMainResource())
         // Stop the main resource loader and let it send the cancelled message.
@@ -252,273 +233,259 @@ using namespace WebCore;
     else if (frameLoader->isLoadingSubresources())
         // The main resource loader already finished loading. Set the cancelled error on the 
         // document and let the subresourceLoaders send individual cancelled messages below.
-        [self setMainDocumentError:frameLoader->cancelledError(request)];
+        setMainDocumentError(frameLoader->cancelledError(m_request.get()));
     else
         // If there are no resource loaders, we need to manufacture a cancelled message.
         // (A back/forward navigation has no resource loaders because its resources are cached.)
-        [self mainReceivedError:frameLoader->cancelledError(request) complete:YES];
+        mainReceivedError(frameLoader->cancelledError(m_request.get()), true);
     
     frameLoader->stopLoadingSubresources();
     frameLoader->stopLoadingPlugIns();
     
-    stopping = NO;
-    
-    [self release];
+    m_stopping = false;
 }
 
-- (void)setupForReplace
+void DocumentLoader::setupForReplace()
 {
-    [self frameLoader]->setupForReplace();
-    committed = NO;
+    frameLoader()->setupForReplace();
+    m_committed = NO;
 }
 
-- (void)commitIfReady
+void DocumentLoader::commitIfReady()
 {
-    if (gotFirstByte && !committed) {
-        committed = YES;
-        [self frameLoader]->commitProvisionalLoad(nil);
+    if (m_gotFirstByte && !m_committed) {
+        m_committed = true;
+        frameLoader()->commitProvisionalLoad(nil);
     }
 }
 
-- (void)finishedLoading
+void DocumentLoader::finishedLoading()
 {
-    gotFirstByte = YES;   
-    [self commitIfReady];
-    [self frameLoader]->finishedLoadingDocument(self);
-    [[self bridge] end];
+    m_gotFirstByte = true;   
+    commitIfReady();
+    frameLoader()->finishedLoadingDocument(this);
+    [bridge() end];
 }
 
-- (void)setCommitted:(BOOL)f
+void DocumentLoader::setCommitted(bool f)
 {
-    committed = f;
+    m_committed = f;
 }
 
-- (BOOL)isCommitted
+bool DocumentLoader::isCommitted() const
 {
-    return committed;
+    return m_committed;
 }
 
-- (void)setLoading:(BOOL)f
+void DocumentLoader::setLoading(bool f)
 {
-    loading = f;
+    m_loading = f;
 }
 
-- (BOOL)isLoading
+bool DocumentLoader::isLoading() const
 {
-    return loading;
+    return m_loading;
 }
 
-- (void)commitLoadWithData:(NSData *)data
+void DocumentLoader::commitLoad(NSData *data)
 {
     // Both unloading the old page and parsing the new page may execute JavaScript which destroys the datasource
     // by starting a new load, so retain temporarily.
-    [self retain];
-    [self commitIfReady];
-    
-    if (FrameLoader* frameLoader = [self frameLoader])
-        frameLoader->committedLoad(self, data);
+    RefPtr<DocumentLoader> protect(this);
 
-    [self release];
+    commitIfReady();
+    if (FrameLoader* frameLoader = DocumentLoader::frameLoader())
+        frameLoader->committedLoad(this, data);
 }
 
-- (BOOL)doesProgressiveLoadWithMIMEType:(NSString *)MIMEType
+bool DocumentLoader::doesProgressiveLoad(NSString *MIMEType) const
 {
-    return ![self frameLoader]->isReplacing() || [MIMEType isEqualToString:@"text/html"];
+    return !frameLoader()->isReplacing() || [MIMEType isEqualToString:@"text/html"];
 }
 
-- (void)receivedData:(NSData *)data
+void DocumentLoader::receivedData(NSData *data)
 {    
-    gotFirstByte = YES;
-    
-    if ([self doesProgressiveLoadWithMIMEType:[response MIMEType]])
-        [self commitLoadWithData:data];
+    m_gotFirstByte = true;
+    if (doesProgressiveLoad([m_response.get() MIMEType]))
+        commitLoad(data);
 }
 
-- (void)setupForReplaceByMIMEType:(NSString *)newMIMEType
+void DocumentLoader::setupForReplaceByMIMEType(NSString *newMIMEType)
 {
-    if (!gotFirstByte)
+    if (!m_gotFirstByte)
         return;
     
-    NSString *oldMIMEType = [response MIMEType];
+    NSString *oldMIMEType = [m_response.get() MIMEType];
     
-    if (![self doesProgressiveLoadWithMIMEType:oldMIMEType]) {
-        [self frameLoader]->revertToProvisional(self);
-        [self setupForReplace];
-        [self commitLoadWithData:[self mainResourceData]];
+    if (!doesProgressiveLoad(oldMIMEType)) {
+        frameLoader()->revertToProvisional(this);
+        setupForReplace();
+        commitLoad(mainResourceData());
     }
     
-    [self frameLoader]->finishedLoadingDocument(self);
-    [[self bridge] end];
+    frameLoader()->finishedLoadingDocument(this);
+    [bridge() end];
     
-    [self frameLoader]->setReplacing();
-    gotFirstByte = NO;
+    frameLoader()->setReplacing();
+    m_gotFirstByte = false;
     
-    if ([self doesProgressiveLoadWithMIMEType:newMIMEType]) {
-        [self frameLoader]->revertToProvisional(self);
-        [self setupForReplace];
+    if (doesProgressiveLoad(newMIMEType)) {
+        frameLoader()->revertToProvisional(this);
+        setupForReplace();
     }
     
-    [self frameLoader]->stopLoadingSubresources();
-    [self frameLoader]->stopLoadingPlugIns();
+    frameLoader()->stopLoadingSubresources();
+    frameLoader()->stopLoadingPlugIns();
 
-    [self frameLoader]->finalSetupForReplace(self);
+    frameLoader()->finalSetupForReplace(this);
 }
 
-- (void)updateLoading
+void DocumentLoader::updateLoading()
 {
-    ASSERT(self == [self frameLoader]->activeDocumentLoader());
-    
-    [self setLoading:[self frameLoader]->isLoading()];
+    ASSERT(this == frameLoader()->activeDocumentLoader());
+    setLoading(frameLoader()->isLoading());
 }
 
-- (NSURLResponse *)response
+NSURLResponse *DocumentLoader::response() const
 {
-    return response;
+    return m_response.get();
 }
 
-- (void)setFrame:(Frame*)frame
+void DocumentLoader::setFrame(Frame* frame)
 {
     if (m_frame == frame)
         return;
     ASSERT(frame && !m_frame);
     m_frame = frame;
-    [self attachToFrame];
+    attachToFrame();
 }
 
-- (void)attachToFrame
+void DocumentLoader::attachToFrame()
 {
     ASSERT(m_frame);
 }
 
-- (void)detachFromFrame
+void DocumentLoader::detachFromFrame()
 {
     ASSERT(m_frame);
     m_frame = 0;
 }
 
-- (void)prepareForLoadStart
+void DocumentLoader::prepareForLoadStart()
 {
-    ASSERT(!stopping);
-    [self setPrimaryLoadComplete:NO];
-    ASSERT([self frameLoader]);
-    [self clearErrors];
+    ASSERT(!m_stopping);
+    setPrimaryLoadComplete(false);
+    ASSERT(frameLoader());
+    clearErrors();
     
     // Mark the start loading time.
-    loadingStartedTime = CFAbsoluteTimeGetCurrent();
+    m_loadingStartedTime = CFAbsoluteTimeGetCurrent();
     
-    [self setLoading:YES];
+    setLoading(true);
     
-    [self frameLoader]->prepareForLoadStart();
+    frameLoader()->prepareForLoadStart();
 }
 
-- (double)loadingStartedTime
+double DocumentLoader::loadingStartedTime() const
 {
-    return loadingStartedTime;
+    return m_loadingStartedTime;
 }
 
-- (void)setIsClientRedirect:(BOOL)flag
+void DocumentLoader::setIsClientRedirect(bool flag)
 {
-    isClientRedirect = flag;
+    m_isClientRedirect = flag;
 }
 
-- (BOOL)isClientRedirect
+bool DocumentLoader::isClientRedirect() const
 {
-    return isClientRedirect;
+    return m_isClientRedirect;
 }
 
-- (void)setPrimaryLoadComplete:(BOOL)flag
+void DocumentLoader::setPrimaryLoadComplete(bool flag)
 {
-    primaryLoadComplete = flag;
-    
+    m_primaryLoadComplete = flag;
     if (flag) {
-        if ([self frameLoader]->isLoadingMainResource()) {
-            [self setMainResourceData:[self frameLoader]->mainResourceData()];
-            [self frameLoader]->releaseMainResourceLoader();
+        if (frameLoader()->isLoadingMainResource()) {
+            setMainResourceData(frameLoader()->mainResourceData());
+            frameLoader()->releaseMainResourceLoader();
         }
-        
-        [self updateLoading];
+        updateLoading();
     }
 }
 
-- (BOOL)isLoadingInAPISense
+bool DocumentLoader::isLoadingInAPISense() const
 {
     // Once a frame has loaded, we no longer need to consider subresources,
     // but we still need to consider subframes.
-    if ([self frameLoader]->state() != WebFrameStateComplete) {
-        if (!primaryLoadComplete && [self isLoading])
-            return YES;
-        if ([self frameLoader]->isLoadingSubresources())
-            return YES;
-        if (![[self bridge] doneProcessingData])
-            return YES;
+    if (frameLoader()->state() != WebFrameStateComplete) {
+        if (!m_primaryLoadComplete && isLoading())
+            return true;
+        if (frameLoader()->isLoadingSubresources())
+            return true;
+        if (![bridge() doneProcessingData])
+            return true;
     }
-    
-    return [self frameLoader]->subframeIsLoading();
+    return frameLoader()->subframeIsLoading();
 }
 
-- (void)addResponse:(NSURLResponse *)r
+void DocumentLoader::addResponse(NSURLResponse *r)
 {
-    if (!stopRecordingResponses) {
-        if (!responses)
-            responses = [[NSMutableArray alloc] init];
-        [responses addObject: r];
-    }
+    if (!m_stopRecordingResponses)
+        m_responses.append(r);
 }
 
-- (void)stopRecordingResponses
+void DocumentLoader::stopRecordingResponses()
 {
-    stopRecordingResponses = YES;
+    m_stopRecordingResponses = true;
 }
 
-- (NSString *)title
+NSString *DocumentLoader::title() const
 {
-    return pageTitle;
+    return [[m_pageTitle.get() retain] autorelease];
 }
 
-- (void)setLastCheckedRequest:(NSURLRequest *)req
+void DocumentLoader::setLastCheckedRequest(NSURLRequest *req)
 {
-    NSURLRequest *oldRequest = lastCheckedRequest;
-    lastCheckedRequest = [req copy];
-    [oldRequest release];
+    NSURLRequest *copy = [req copy];
+    m_lastCheckedRequest = req;
+    [copy release];
 }
 
-- (NSURLRequest *)lastCheckedRequest
+NSURLRequest *DocumentLoader::lastCheckedRequest() const
 {
     // It's OK not to make a copy here because we know the caller
     // isn't going to modify this request
-    return [[lastCheckedRequest retain] autorelease];
+    return [[m_lastCheckedRequest.get() retain] autorelease];
 }
 
-- (NSDictionary *)triggeringAction
+NSDictionary *DocumentLoader::triggeringAction() const
 {
-    return [[triggeringAction retain] autorelease];
+    return [[m_triggeringAction.get() retain] autorelease];
 }
 
-- (void)setTriggeringAction:(NSDictionary *)action
+void DocumentLoader::setTriggeringAction(NSDictionary *action)
 {
-    [action retain];
-    [triggeringAction release];
-    triggeringAction = action;
+    m_triggeringAction = action;
 }
 
-- (NSArray *)responses
+const ResponseVector& DocumentLoader::responses() const
 {
-    return responses;
+    return m_responses;
 }
 
-- (void)setOverrideEncoding:(NSString *)enc
+void DocumentLoader::setOverrideEncoding(NSString *enc)
 {
     NSString *copy = [enc copy];
-    [overrideEncoding release];
-    overrideEncoding = copy;
+    m_overrideEncoding = copy;
+    [copy release];
 }
 
-- (NSString *)overrideEncoding
+NSString *DocumentLoader::overrideEncoding() const
 {
-    return [[overrideEncoding copy] autorelease];
+    return [[m_overrideEncoding.get() copy] autorelease];
 }
 
-- (void)setTitle:(NSString *)title
+void DocumentLoader::setTitle(NSString *title)
 {
     if (!title)
         return;
@@ -526,26 +493,26 @@ using namespace WebCore;
     NSString *trimmed = [title mutableCopy];
     CFStringTrimWhitespace((CFMutableStringRef)trimmed);
 
-    if ([trimmed length] != 0 && ![pageTitle isEqualToString:trimmed]) {
-        [self frameLoader]->willChangeTitle(self);
-        [pageTitle release];
-        pageTitle = [trimmed copy];
-        [self frameLoader]->didChangeTitle(self);
+    if ([trimmed length] != 0 && ![m_pageTitle.get() isEqualToString:trimmed]) {
+        NSString *copy = [trimmed copy];
+        frameLoader()->willChangeTitle(this);
+        m_pageTitle = copy;
+        frameLoader()->didChangeTitle(this);
+        [copy release];
     }
 
     [trimmed release];
 }
 
-- (NSURL *)URLForHistory
+NSURL *DocumentLoader::URLForHistory() const
 {
     // Return the URL to be used for history and B/F list.
     // Returns nil for WebDataProtocol URLs that aren't alternates 
     // for unreachable URLs, because these can't be stored in history.
-    NSURL *URL = [originalRequestCopy URL];
+    NSURL *URL = [m_originalRequestCopy.get() URL];
     if ([WebDataProtocol _webIsDataProtocolURL:URL])
-        URL = [originalRequestCopy _webDataRequestUnreachableURL];
-
+        URL = [m_originalRequestCopy.get() _webDataRequestUnreachableURL];
     return URL;
 }
 
-@end
+}
index 8016fef128465b9e49c501014b2385fbc756f69b..15bdd3ffa702829f1ee30113d685fa8e3ebae204 100644 (file)
 @class DOMElement;
 @class WebCoreFrameBridge;
 @class WebCoreFrameLoaderAsDelegate;
-@class WebDocumentLoader;
 @class WebPolicyDecider;
 @protocol WebFrameLoaderClient;
 
 namespace WebCore {
 
+    class DocumentLoader;
     class FormState;
     class Frame;
     class MainResourceLoader;
@@ -60,14 +60,14 @@ namespace WebCore {
         void prepareForLoadStart();
         void setupForReplace();
         void setupForReplaceByMIMEType(NSString *newMIMEType);
-        void finalSetupForReplace(WebDocumentLoader *);
+        void finalSetupForReplace(DocumentLoader*);
         void safeLoad(NSURL *);
         void load(NSURLRequest *);
         void load(NSURLRequest *, NSString *frameName);
         void load(NSURLRequest *, NSDictionary *triggeringAaction, FrameLoadType, PassRefPtr<FormState>);
-        void load(WebDocumentLoader *);
-        void load(WebDocumentLoader *, FrameLoadType, PassRefPtr<FormState>);
-        void load(NSURL *, NSString *referrer, FrameLoadType loadType, NSString *target, NSEvent *event, DOMElement *form, NSDictionary *formValues);
+        void load(DocumentLoader*);
+        void load(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);
+        void load(NSURL *, NSString *referrer, FrameLoadType, NSString *target, NSEvent *event, DOMElement *form, NSDictionary *formValues);
 
         // Also not cool.
         void stopLoadingPlugIns();
@@ -87,9 +87,9 @@ namespace WebCore {
         NSData *mainResourceData() const;
         void releaseMainResourceLoader();
 
-        WebDocumentLoader *activeDocumentLoader() const;
-        WebDocumentLoader *documentLoader() const;
-        WebDocumentLoader *provisionalDocumentLoader();
+        DocumentLoader* activeDocumentLoader() const;
+        DocumentLoader* documentLoader() const;
+        DocumentLoader* provisionalDocumentLoader();
         WebFrameState state() const;
         static double timeOfLastCompletedLoad();
 
@@ -136,16 +136,16 @@ namespace WebCore {
         void reloadAllowingStaleData(NSString *overrideEncoding);
 
         void didReceiveServerRedirectForProvisionalLoadForFrame();
-        void finishedLoadingDocument(WebDocumentLoader *);
-        void committedLoad(WebDocumentLoader *, NSData *data);
+        void finishedLoadingDocument(DocumentLoader*);
+        void committedLoad(DocumentLoader*, NSData *data);
         bool isReplacing() const;
         void setReplacing();
-        void revertToProvisional(WebDocumentLoader *);
-        void setMainDocumentError(WebDocumentLoader *, NSError *);
-        void mainReceivedCompleteError(WebDocumentLoader *, NSError *);
+        void revertToProvisional(DocumentLoader*);
+        void setMainDocumentError(DocumentLoader*, NSError *);
+        void mainReceivedCompleteError(DocumentLoader*, NSError *);
         bool subframeIsLoading() const;
-        void willChangeTitle(WebDocumentLoader *);
-        void didChangeTitle(WebDocumentLoader *);
+        void willChangeTitle(DocumentLoader*);
+        void didChangeTitle(DocumentLoader*);
 
         FrameLoadType loadType() const;
 
@@ -198,14 +198,14 @@ namespace WebCore {
 
         void invalidatePendingPolicyDecision(bool callDefaultAction);
         void checkNewWindowPolicy(NSURLRequest *, NSDictionary *, NSString *frameName, PassRefPtr<FormState>);
-        void checkNavigationPolicy(NSURLRequest *, WebDocumentLoader *, PassRefPtr<FormState>, id continuationObject, SEL continuationSelector);
+        void checkNavigationPolicy(NSURLRequest *, DocumentLoader*, PassRefPtr<FormState>, id continuationObject, SEL continuationSelector);
 
         void transitionToCommitted(NSDictionary *pageCache);
         void checkLoadCompleteForThisFrame();
 
-        void setDocumentLoader(WebDocumentLoader *);
-        void setPolicyDocumentLoader(WebDocumentLoader *);
-        void setProvisionalDocumentLoader(WebDocumentLoader *);
+        void setDocumentLoader(DocumentLoader*);
+        void setPolicyDocumentLoader(DocumentLoader*);
+        void setProvisionalDocumentLoader(DocumentLoader*);
 
         bool isLoadingPlugIns() const;
 
@@ -230,9 +230,9 @@ namespace WebCore {
     
         id <WebFrameLoaderClient> m_client;
 
-        RetainPtr<WebDocumentLoader> m_documentLoader;
-        RetainPtr<WebDocumentLoader> m_provisionalDocumentLoader;
-        RetainPtr<WebDocumentLoader> m_policyDocumentLoader;
+        RefPtr<DocumentLoader> m_documentLoader;
+        RefPtr<DocumentLoader> m_provisionalDocumentLoader;
+        RefPtr<DocumentLoader> m_policyDocumentLoader;
 
         WebFrameState m_state;
         FrameLoadType m_loadType;
index 42563aedda156260454bda71d24a7c1a81e058d8..205a64c991d7becc0cf0c03a1947f46b9be7edb4 100644 (file)
@@ -136,10 +136,10 @@ void FrameLoader::setupForReplace()
 
 void FrameLoader::setupForReplaceByMIMEType(NSString *newMIMEType)
 {
-    [activeDocumentLoader() setupForReplaceByMIMEType:newMIMEType];
+    activeDocumentLoader()->setupForReplaceByMIMEType(newMIMEType);
 }
 
-void FrameLoader::finalSetupForReplace(WebDocumentLoader *loader)
+void FrameLoader::finalSetupForReplace(DocumentLoader* loader)
 {
     [m_client _clearUnarchivingStateForLoader:loader];
 }
@@ -149,7 +149,7 @@ void FrameLoader::safeLoad(NSURL *URL)
     // Call to the Frame because this is where our security checks are made.
     FrameLoadRequest request;
     request.m_request.setURL(URL);
-    request.m_request.setHTTPReferrer(urlOriginalDataAsString([[m_documentLoader.get() request] URL]));
+    request.m_request.setHTTPReferrer(urlOriginalDataAsString([m_documentLoader->request() URL]));
     
     [bridge() impl]->loadRequest(request, true, [NSApp currentEvent], nil, nil);
 }
@@ -158,9 +158,7 @@ void FrameLoader::load(NSURLRequest *request)
 {
     // FIXME: is this the right place to reset loadType? Perhaps this should be done after loading is finished or aborted.
     m_loadType = FrameLoadTypeStandard;
-    WebDocumentLoader *dl = [m_client _createDocumentLoaderWithRequest:request];
-    load(dl);
-    [dl release];
+    load([m_client _createDocumentLoaderWithRequest:request].get());
 }
 
 void FrameLoader::load(NSURLRequest *request, NSString *frameName)
@@ -182,14 +180,14 @@ void FrameLoader::load(NSURLRequest *request, NSString *frameName)
 
 void FrameLoader::load(NSURLRequest *request, NSDictionary *action, FrameLoadType type, PassRefPtr<FormState> formState)
 {
-    WebDocumentLoader *loader = [m_client _createDocumentLoaderWithRequest:request];
-    setPolicyDocumentLoader(loader);
-    [loader release];
+    RefPtr<DocumentLoader> loader = [m_client _createDocumentLoaderWithRequest:request];
+    setPolicyDocumentLoader(loader.get());
 
-    [loader setTriggeringAction:action];
-    [loader setOverrideEncoding:[m_documentLoader.get() overrideEncoding]];
+    loader->setTriggeringAction(action);
+    if (m_documentLoader)
+        loader->setOverrideEncoding(m_documentLoader->overrideEncoding());
 
-    load(loader, type, formState);
+    load(loader.get(), type, formState);
 }
 
 void FrameLoader::load(NSURL *URL, NSString *referrer, FrameLoadType newLoadType, NSString *target, NSEvent *event, DOMElement *form, NSDictionary *values)
@@ -219,7 +217,7 @@ void FrameLoader::load(NSURL *URL, NSString *referrer, FrameLoadType newLoadType
         return;
     }
 
-    WebDocumentLoader *oldDocumentLoader = [m_documentLoader.get() retain];
+    RefPtr<DocumentLoader> oldDocumentLoader = m_documentLoader;
 
     bool sameURL = [m_client _shouldTreatURLAsSameAsCurrent:URL];
     
@@ -242,9 +240,9 @@ void FrameLoader::load(NSURL *URL, NSString *referrer, FrameLoadType newLoadType
         
         // FIXME: What about load types other than Standard and Reload?
         
-        [oldDocumentLoader setTriggeringAction:action];
+        oldDocumentLoader->setTriggeringAction(action);
         invalidatePendingPolicyDecision(true);
-        checkNavigationPolicy(request, oldDocumentLoader, formState.release(),
+        checkNavigationPolicy(request, oldDocumentLoader.get(), formState.release(),
             asDelegate(), @selector(continueFragmentScrollAfterNavigationPolicy:formState:));
     } else {
         // must grab this now, since this load may stop the previous load and clear this flag
@@ -252,7 +250,7 @@ void FrameLoader::load(NSURL *URL, NSString *referrer, FrameLoadType newLoadType
         load(request, action, newLoadType, formState.release());
         if (isRedirect) {
             m_quickRedirectComing = false;
-            [m_provisionalDocumentLoader.get() setIsClientRedirect:YES];
+            m_provisionalDocumentLoader->setIsClientRedirect(true);
         } else if (sameURL)
             // Example of this case are sites that reload the same URL with a different cookie
             // driving the generated content, or a master frame with links that drive a target
@@ -261,29 +259,29 @@ void FrameLoader::load(NSURL *URL, NSString *referrer, FrameLoadType newLoadType
     }
     
     [request release];
-    [oldDocumentLoader release];
 }
 
-void FrameLoader::load(WebDocumentLoader *newDocumentLoader)
+void FrameLoader::load(DocumentLoader* newDocumentLoader)
 {
     invalidatePendingPolicyDecision(true);
     setPolicyDocumentLoader(newDocumentLoader);
 
-    NSMutableURLRequest *r = [newDocumentLoader request];
+    NSMutableURLRequest *r = newDocumentLoader->request();
     addExtraFieldsToRequest(r, true, false);
     FrameLoadType type;
-    if ([m_client _shouldTreatURLAsSameAsCurrent:[[newDocumentLoader originalRequest] URL]]) {
+    if ([m_client _shouldTreatURLAsSameAsCurrent:[newDocumentLoader->originalRequest() URL]]) {
         [r setCachePolicy:NSURLRequestReloadIgnoringCacheData];
         type = FrameLoadTypeSame;
     } else
         type = FrameLoadTypeStandard;
-    
-    [newDocumentLoader setOverrideEncoding:[documentLoader() overrideEncoding]];
+
+    if (m_documentLoader)
+        newDocumentLoader->setOverrideEncoding(m_documentLoader->overrideEncoding());
     
     // When we loading alternate content for an unreachable URL that we're
     // visiting in the b/f list, we treat it as a reload so the b/f list 
     // is appropriately maintained.
-    if (shouldReloadToHandleUnreachableURL([newDocumentLoader originalRequest])) {
+    if (shouldReloadToHandleUnreachableURL(newDocumentLoader->originalRequest())) {
         ASSERT(type == FrameLoadTypeStandard);
         type = FrameLoadTypeReload;
     }
@@ -291,7 +289,7 @@ void FrameLoader::load(WebDocumentLoader *newDocumentLoader)
     load(newDocumentLoader, type, 0);
 }
 
-void FrameLoader::load(WebDocumentLoader *loader, FrameLoadType type, PassRefPtr<FormState> formState)
+void FrameLoader::load(DocumentLoader* loader, FrameLoadType type, PassRefPtr<FormState> formState)
 {
     ASSERT([m_client _hasWebView]);
 
@@ -303,12 +301,12 @@ void FrameLoader::load(WebDocumentLoader *loader, FrameLoadType type, PassRefPtr
     m_policyLoadType = type;
 
     if (Frame* parent = m_frame->tree()->parent())
-        [loader setOverrideEncoding:[[Mac(parent)->bridge() frameLoader]->documentLoader() overrideEncoding]];
+        loader->setOverrideEncoding([Mac(parent)->bridge() frameLoader]->documentLoader()->overrideEncoding());
 
     invalidatePendingPolicyDecision(true);
     setPolicyDocumentLoader(loader);
 
-    checkNavigationPolicy([loader request], loader, formState,
+    checkNavigationPolicy(loader->request(), loader, formState,
         asDelegate(), @selector(continueLoadRequestAfterNavigationPolicy:formState:));
 }
 
@@ -331,18 +329,18 @@ bool FrameLoader::startLoadingMainResource(NSMutableURLRequest *request, id iden
 // FIXME: Poor method name; also, why is this not part of startProvisionalLoad:?
 void FrameLoader::startLoading()
 {
-    [m_provisionalDocumentLoader.get() prepareForLoadStart];
+    m_provisionalDocumentLoader->prepareForLoadStart();
 
     if (isLoadingMainResource())
         return;
 
     [m_client _clearLoadingFromPageCacheForDocumentLoader:m_provisionalDocumentLoader.get()];
 
-    id identifier = [m_client _dispatchIdentifierForInitialRequest:[m_provisionalDocumentLoader.get() originalRequest]
+    id identifier = [m_client _dispatchIdentifierForInitialRequest:m_provisionalDocumentLoader->originalRequest()
         fromDocumentLoader:m_provisionalDocumentLoader.get()];
         
-    if (!startLoadingMainResource([m_provisionalDocumentLoader.get() actualRequest], identifier))
-        [m_provisionalDocumentLoader.get() updateLoading];
+    if (!startLoadingMainResource(m_provisionalDocumentLoader->actualRequest(), identifier))
+        m_provisionalDocumentLoader->updateLoading();
 }
 
 void FrameLoader::stopLoadingPlugIns()
@@ -371,17 +369,19 @@ void FrameLoader::stopLoading()
     // If this method is called from within this method, infinite recursion can occur (3442218). Avoid this.
     if (m_isStoppingLoad)
         return;
-    
+
     m_isStoppingLoad = true;
-    
+
     invalidatePendingPolicyDecision(true);
-    
+
     stopLoadingSubframes();
-    [m_provisionalDocumentLoader.get() stopLoading];
-    [m_documentLoader.get() stopLoading];
-    setProvisionalDocumentLoader(nil);
+    if (m_provisionalDocumentLoader)
+        m_provisionalDocumentLoader->stopLoading();
+    if (m_documentLoader)
+        m_documentLoader->stopLoading();
+    setProvisionalDocumentLoader(0);
     [m_client _clearArchivedResources];
-    
+
     m_isStoppingLoad = false;    
 }
 
@@ -396,7 +396,7 @@ void FrameLoader::cancelPendingArchiveLoad(WebResourceLoader* loader)
     [m_client _cancelPendingArchiveLoadForLoader:loader];
 }
 
-WebDocumentLoader *FrameLoader::activeDocumentLoader() const
+DocumentLoader* FrameLoader::activeDocumentLoader() const
 {
     if (m_state == WebFrameStateProvisional)
         return m_provisionalDocumentLoader.get();
@@ -406,13 +406,13 @@ WebDocumentLoader *FrameLoader::activeDocumentLoader() const
 void FrameLoader::addPlugInStreamLoader(WebResourceLoader* loader)
 {
     m_plugInStreamLoaders.add(loader);
-    [activeDocumentLoader() setLoading:YES];
+    activeDocumentLoader()->setLoading(true);
 }
 
 void FrameLoader::removePlugInStreamLoader(WebResourceLoader* loader)
 {
     m_plugInStreamLoaders.remove(loader);
-    [activeDocumentLoader() updateLoading];
+    activeDocumentLoader()->updateLoading();
 }
 
 void FrameLoader::defersCallbacksChanged()
@@ -468,13 +468,13 @@ void FrameLoader::addSubresourceLoader(WebResourceLoader* loader)
 {
     ASSERT(!m_provisionalDocumentLoader);
     m_subresourceLoaders.add(loader);
-    [activeDocumentLoader() setLoading:YES];
+    activeDocumentLoader()->setLoading(true);
 }
 
 void FrameLoader::removeSubresourceLoader(WebResourceLoader* loader)
 {
     m_subresourceLoaders.remove(loader);
-    [activeDocumentLoader() updateLoading];
+    activeDocumentLoader()->updateLoading();
     checkLoadComplete();
 }
 
@@ -490,50 +490,54 @@ void FrameLoader::releaseMainResourceLoader()
     m_mainResourceLoader = 0;
 }
 
-void FrameLoader::setDocumentLoader(WebDocumentLoader* loader)
+void FrameLoader::setDocumentLoader(DocumentLoader* loader)
 {
     if (!loader && !m_documentLoader)
         return;
     
     ASSERT(loader != m_documentLoader);
-    ASSERT(!loader || [loader frameLoader] == this);
+    ASSERT(!loader || loader->frameLoader() == this);
 
     [m_client _prepareForDataSourceReplacement];
-    [m_documentLoader.get() detachFromFrame];
+    if (m_documentLoader)
+        m_documentLoader->detachFromFrame();
 
     m_documentLoader = loader;
 }
 
-WebDocumentLoader *FrameLoader::documentLoader() const
+DocumentLoader* FrameLoader::documentLoader() const
 {
     return m_documentLoader.get();
 }
 
-void FrameLoader::setPolicyDocumentLoader(WebDocumentLoader *loader)
+void FrameLoader::setPolicyDocumentLoader(DocumentLoader* loader)
 {
     if (m_policyDocumentLoader == loader)
         return;
 
     ASSERT(m_frame);
-    [loader setFrame:m_frame];
-    if (m_policyDocumentLoader != m_provisionalDocumentLoader && m_policyDocumentLoader != m_documentLoader)
-        [m_policyDocumentLoader.get() detachFromFrame];
+    if (loader)
+        loader->setFrame(m_frame);
+    if (m_policyDocumentLoader
+            && m_policyDocumentLoader != m_provisionalDocumentLoader
+            && m_policyDocumentLoader != m_documentLoader)
+        m_policyDocumentLoader->detachFromFrame();
 
     m_policyDocumentLoader = loader;
 }
    
-WebDocumentLoader* FrameLoader::provisionalDocumentLoader()
+DocumentLoader* FrameLoader::provisionalDocumentLoader()
 {
     return m_provisionalDocumentLoader.get();
 }
 
-void FrameLoader::setProvisionalDocumentLoader(WebDocumentLoader *loader)
+void FrameLoader::setProvisionalDocumentLoader(DocumentLoader* loader)
 {
     ASSERT(!loader || !m_provisionalDocumentLoader);
-    ASSERT(!loader || [loader frameLoader] == this);
+    ASSERT(!loader || loader->frameLoader() == this);
 
-    if (m_provisionalDocumentLoader != m_documentLoader)
-        [m_provisionalDocumentLoader.get() detachFromFrame];
+    if (m_provisionalDocumentLoader && m_provisionalDocumentLoader != m_documentLoader)
+        m_provisionalDocumentLoader->detachFromFrame();
 
     m_provisionalDocumentLoader = loader;
 }
@@ -564,13 +568,13 @@ void FrameLoader::setState(WebFrameState newState)
     else if (newState == WebFrameStateComplete) {
         frameLoadCompleted();
         storedTimeOfLastCompletedLoad = CFAbsoluteTimeGetCurrent();
-        [documentLoader() stopRecordingResponses];
+        m_documentLoader->stopRecordingResponses();
     }
 }
 
 void FrameLoader::clearProvisionalLoad()
 {
-    setProvisionalDocumentLoader(nil);
+    setProvisionalDocumentLoader(0);
     [m_client _progressCompleted];
     setState(WebFrameStateComplete);
 }
@@ -586,7 +590,7 @@ void FrameLoader::commitProvisionalLoad()
     stopLoadingPlugIns();
 
     setDocumentLoader(m_provisionalDocumentLoader.get());
-    setProvisionalDocumentLoader(nil);
+    setProvisionalDocumentLoader(0);
     setState(WebFrameStateCommittedPage);
 }
 
@@ -616,7 +620,7 @@ void FrameLoader::didCancelAuthenticationChallenge(WebResourceLoader* loader, NS
 
 void FrameLoader::didReceiveResponse(WebResourceLoader* loader, NSURLResponse *r)
 {
-    [activeDocumentLoader() addResponse:r];
+    activeDocumentLoader()->addResponse(r);
     
     [m_client _incrementProgressForIdentifier:loader->identifier() response:r];
     [m_client _dispatchResource:loader->identifier() didReceiveResponse:r fromDocumentLoader:activeDocumentLoader()];
@@ -648,13 +652,12 @@ bool FrameLoader::privateBrowsingEnabled() const
 
 NSURLRequest *FrameLoader::originalRequest() const
 {
-    return [activeDocumentLoader() originalRequestCopy];
+    return activeDocumentLoader()->originalRequestCopy();
 }
 
 void FrameLoader::receivedMainResourceError(NSError *error, bool isComplete)
 {
-    WebDocumentLoader *loader = activeDocumentLoader();
-    [loader retain];
+    RefPtr<DocumentLoader> loader = activeDocumentLoader();
     
     WebCoreFrameBridge *bridge = FrameLoader::bridge();
     
@@ -673,7 +676,7 @@ void FrameLoader::receivedMainResourceError(NSError *error, bool isComplete)
     }
     
     if (m_state == WebFrameStateProvisional) {
-        NSURL *failedURL = [[m_provisionalDocumentLoader.get() originalRequestCopy] URL];
+        NSURL *failedURL = [m_provisionalDocumentLoader->originalRequestCopy() URL];
         [bridge didNotOpenURL:failedURL];
         [m_client _invalidateCurrentItemPageCache];
         
@@ -687,11 +690,10 @@ void FrameLoader::receivedMainResourceError(NSError *error, bool isComplete)
     }
     
     
-    [loader mainReceivedError:error complete:isComplete];
+    loader->mainReceivedError(error, isComplete);
 
     [bridge release];
     [cli release];
-    [loader release];
 }
 
 void FrameLoader::clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress)
@@ -737,7 +739,7 @@ void FrameLoader::continueFragmentScrollAfterNavigationPolicy(NSURLRequest *requ
     bool isRedirect = m_quickRedirectComing;
     m_quickRedirectComing = false;
     
-    [m_documentLoader.get() replaceRequestURLForAnchorScrollWithURL:URL];
+    m_documentLoader->replaceRequestURLForAnchorScroll(URL);
     if (!isRedirect && ![m_client _shouldTreatURLAsSameAsCurrent:URL]) {
         // NB: must happen after _setURL, since we add based on the current request.
         // Must also happen before we openURL and displace the scroll position, since
@@ -756,7 +758,7 @@ void FrameLoader::continueFragmentScrollAfterNavigationPolicy(NSURLRequest *requ
     [bridge() scrollToAnchorWithURL:URL];
     
     if (!isRedirect)
-        // This will clear previousItem from the rest of the frame tree tree that didn't
+        // This will clear previousItem from the rest of the frame tree that didn't
         // doing any loading. We need to make a pass on this now, since for anchor nav
         // we'll not go through a real load and reach Completed state.
         checkLoadComplete();
@@ -781,18 +783,17 @@ void FrameLoader::closeOldDataSources()
 
 void FrameLoader::opened()
 {
-    if (m_loadType == FrameLoadTypeStandard && [m_documentLoader.get() isClientRedirect])
+    if (m_loadType == FrameLoadTypeStandard && m_documentLoader->isClientRedirect())
         [m_client _updateHistoryAfterClientRedirect];
 
     if ([m_client _isDocumentLoaderLoadingFromPageCache:m_documentLoader.get()]) {
         // Force a layout to update view size and thereby update scrollbars.
         [m_client _forceLayout];
 
-        NSArray *responses = [m_documentLoader.get() responses];
-        NSURLResponse *response;
-        int i, count = [responses count];
-        for (i = 0; i < count; i++) {
-            response = [responses objectAtIndex: i];
+        const ResponseVector& responses = m_documentLoader->responses();
+        size_t count = responses.size();
+        for (size_t i = 0; i < count; i++) {
+            NSURLResponse *response = responses[i].get();
             // FIXME: If the WebKit client changes or cancels the request, this is not respected.
             NSError *error;
             id identifier;
@@ -804,7 +805,7 @@ void FrameLoader::opened()
         
         [m_client _loadedFromPageCache];
 
-        [m_documentLoader.get() setPrimaryLoadComplete:YES];
+        m_documentLoader->setPrimaryLoadComplete(true);
 
         // FIXME: Why only this frame and not parent frames?
         checkLoadCompleteForThisFrame();
@@ -815,9 +816,9 @@ void FrameLoader::commitProvisionalLoad(NSDictionary *pageCache)
 {
     bool reload = m_loadType == FrameLoadTypeReload || m_loadType == FrameLoadTypeReloadAllowingStaleData;
     
-    WebDocumentLoader *pdl = [m_provisionalDocumentLoader.get() retain];
+    RefPtr<DocumentLoader> pdl = m_provisionalDocumentLoader;
     
-    NSURLResponse *response = [pdl response];
+    NSURLResponse *response = pdl->response();
     
     NSDictionary *headers = [response isKindOfClass:[NSHTTPURLResponse class]]
         ? [(NSHTTPURLResponse *)response allHeaderFields] : nil;
@@ -826,7 +827,7 @@ void FrameLoader::commitProvisionalLoad(NSDictionary *pageCache)
         closeOldDataSources();
     
     if (!pageCache)
-        [m_client _makeRepresentationForDocumentLoader:pdl];
+        [m_client _makeRepresentationForDocumentLoader:pdl.get()];
     
     transitionToCommitted(pageCache);
     
@@ -837,7 +838,7 @@ void FrameLoader::commitProvisionalLoad(NSDictionary *pageCache)
     if (m_sentRedirectNotification)
         clientRedirectCancelledOrFinished(false);
     
-    NSURL *baseURL = [[pdl request] _webDataRequestBaseURL];        
+    NSURL *baseURL = [pdl->request() _webDataRequestBaseURL];        
     NSURL *URL = baseURL ? baseURL : [response URL];
     
     if (!URL || urlIsEmpty(URL))
@@ -851,23 +852,21 @@ void FrameLoader::commitProvisionalLoad(NSDictionary *pageCache)
             pageCache:pageCache];
     
     opened();
-    
-    [pdl release];
 }
 
 NSURLRequest *FrameLoader::initialRequest() const
 {
-    return [activeDocumentLoader() initialRequest];
+    return activeDocumentLoader()->initialRequest();
 }
 
 void FrameLoader::receivedData(NSData *data)
 {
-    [activeDocumentLoader() receivedData:data];
+    activeDocumentLoader()->receivedData(data);
 }
 
 void FrameLoader::setRequest(NSURLRequest *request)
 {
-    [activeDocumentLoader() setRequest:request];
+    activeDocumentLoader()->setRequest(request);
 }
 
 void FrameLoader::download(NSURLConnection *connection, NSURLRequest *request, NSURLResponse *response, id proxy)
@@ -887,35 +886,35 @@ void FrameLoader::handleFallbackContent()
 
 bool FrameLoader::isStopping() const
 {
-    return [activeDocumentLoader() isStopping];
+    return activeDocumentLoader()->isStopping();
 }
 
 void FrameLoader::setResponse(NSURLResponse *response)
 {
-    [activeDocumentLoader() setResponse:response];
+    activeDocumentLoader()->setResponse(response);
 }
 
 void FrameLoader::mainReceivedError(NSError *error, bool isComplete)
 {
-    [activeDocumentLoader() mainReceivedError:error complete:isComplete];
+    activeDocumentLoader()->mainReceivedError(error, isComplete);
 }
 
 void FrameLoader::finishedLoading()
 {
-    WebDocumentLoader *dl = activeDocumentLoader();
+    RefPtr<DocumentLoader> dl = activeDocumentLoader();
     
     WebCoreFrameBridge *bridge = FrameLoader::bridge();
 
     [bridge retain];
-    [dl finishedLoading];
+    dl->finishedLoading();
 
-    if ([dl mainDocumentError] || ![dl frameLoader]) {
+    if (dl->mainDocumentError() || !dl->frameLoader()) {
         [bridge release];
         return;
     }
 
-    [dl setPrimaryLoadComplete:YES];
-    [m_client _dispatchDidLoadMainResourceForDocumentLoader:dl];
+    dl->setPrimaryLoadComplete(true);
+    [m_client _dispatchDidLoadMainResourceForDocumentLoader:dl.get()];
     checkLoadComplete();
 
     [bridge release];
@@ -925,14 +924,14 @@ void FrameLoader::notifyIconChanged(NSURL *iconURL)
 {
     ASSERT([[WebCoreIconDatabaseBridge sharedInstance] _isEnabled]);
     NSImage *icon = [[WebCoreIconDatabaseBridge sharedInstance]
-        iconForPageURL:urlOriginalDataAsString([activeDocumentLoader() URL])
+        iconForPageURL:urlOriginalDataAsString(activeDocumentLoader()->URL())
         withSize:NSMakeSize(16, 16)];
     [m_client _dispatchDidReceiveIcon:icon];
 }
 
 NSURL *FrameLoader::URL() const
 {
-    return [activeDocumentLoader() URL];
+    return activeDocumentLoader()->URL();
 }
 
 NSError *FrameLoader::cancelledError(NSURLRequest *request) const
@@ -1007,7 +1006,7 @@ void FrameLoader::checkContentPolicy(NSString *MIMEType, id obj, SEL sel)
 {
     WebPolicyDecider *d = [m_client _createPolicyDeciderWithTarget:obj action:sel];
     m_policyDecider = d;
-    [m_client _dispatchDecidePolicyForMIMEType:MIMEType request:[activeDocumentLoader() request] decider:d];
+    [m_client _dispatchDecidePolicyForMIMEType:MIMEType request:activeDocumentLoader()->request() decider:d];
     [d release];
 }
 
@@ -1031,13 +1030,13 @@ bool FrameLoader::shouldReloadToHandleUnreachableURL(NSURLRequest *request)
     // case handles well-formed URLs that can't be loaded, and the latter
     // case handles malformed URLs and unknown schemes. Loading alternate content
     // at other times behaves like a standard load.
-    WebDocumentLoader *compareDocumentLoader = nil;
+    DocumentLoader* compareDocumentLoader = 0;
     if (m_delegateIsDecidingNavigationPolicy || m_delegateIsHandlingUnimplementablePolicy)
         compareDocumentLoader = m_policyDocumentLoader.get();
     else if (m_delegateIsHandlingProvisionalLoadError)
         compareDocumentLoader = m_provisionalDocumentLoader.get();
 
-    return compareDocumentLoader && [unreachableURL isEqual:[[compareDocumentLoader request] URL]];
+    return compareDocumentLoader && [unreachableURL isEqual:[compareDocumentLoader->request() URL]];
 }
 
 void FrameLoader::reloadAllowingStaleData(NSString *encoding)
@@ -1045,22 +1044,21 @@ void FrameLoader::reloadAllowingStaleData(NSString *encoding)
     if (!m_documentLoader)
         return;
 
-    NSMutableURLRequest *request = [[m_documentLoader.get() request] mutableCopy];
-    NSURL *unreachableURL = [m_documentLoader.get() unreachableURL];
+    NSMutableURLRequest *request = [m_documentLoader->request() mutableCopy];
+    NSURL *unreachableURL = m_documentLoader->unreachableURL();
     if (unreachableURL)
         [request setURL:unreachableURL];
 
     [request setCachePolicy:NSURLRequestReturnCacheDataElseLoad];
 
-    WebDocumentLoader *loader = [m_client _createDocumentLoaderWithRequest:request];
-    setPolicyDocumentLoader(loader);
-    [loader release];
+    RefPtr<DocumentLoader> loader = [m_client _createDocumentLoaderWithRequest:request];
+    setPolicyDocumentLoader(loader.get());
 
     [request release];
 
-    [loader setOverrideEncoding:encoding];
+    loader->setOverrideEncoding(encoding);
 
-    load(loader, FrameLoadTypeReloadAllowingStaleData, 0);
+    load(loader.get(), FrameLoadTypeReloadAllowingStaleData, 0);
 }
 
 void FrameLoader::reload()
@@ -1068,7 +1066,7 @@ void FrameLoader::reload()
     if (!m_documentLoader)
         return;
 
-    NSMutableURLRequest *initialRequest = [m_documentLoader.get() request];
+    NSMutableURLRequest *initialRequest = m_documentLoader->request();
     
     // If a window is created by javascript, its main frame can have an empty but non-nil URL.
     // Reloading in this case will lose the current contents (see 4151001).
@@ -1080,23 +1078,20 @@ void FrameLoader::reload()
     if (unreachableURL != nil)
         initialRequest = [NSURLRequest requestWithURL:unreachableURL];
     
-    WebDocumentLoader *loader = [m_client _createDocumentLoaderWithRequest:initialRequest];
-    setPolicyDocumentLoader(loader);
-    [loader release];
+    RefPtr<DocumentLoader> loader = [m_client _createDocumentLoaderWithRequest:initialRequest];
+    setPolicyDocumentLoader(loader.get());
 
-    NSMutableURLRequest *request = [loader request];
+    NSMutableURLRequest *request = loader->request();
 
     [request setCachePolicy:NSURLRequestReloadIgnoringCacheData];
 
     // If we're about to rePOST, set up action so the app can warn the user
-    if (isCaseInsensitiveEqual([request HTTPMethod], @"POST")) {
-        NSDictionary *action = actionInformation(NavigationTypeFormResubmitted, nil, [request URL]);
-        [loader setTriggeringAction:action];
-    }
+    if (isCaseInsensitiveEqual([request HTTPMethod], @"POST"))
+        loader->setTriggeringAction(actionInformation(NavigationTypeFormResubmitted, nil, [request URL]));
 
-    [loader setOverrideEncoding:[m_documentLoader.get() overrideEncoding]];
+    loader->setOverrideEncoding(m_documentLoader->overrideEncoding());
     
-    load(loader, FrameLoadTypeReload, 0);
+    load(loader.get(), FrameLoadTypeReload, 0);
 }
 
 void FrameLoader::didReceiveServerRedirectForProvisionalLoadForFrame()
@@ -1104,12 +1099,12 @@ void FrameLoader::didReceiveServerRedirectForProvisionalLoadForFrame()
     [m_client _dispatchDidReceiveServerRedirectForProvisionalLoadForFrame];
 }
 
-void FrameLoader::finishedLoadingDocument(WebDocumentLoader *loader)
+void FrameLoader::finishedLoadingDocument(DocumentLoader* loader)
 {
     [m_client _finishedLoadingDocument:loader];
 }
 
-void FrameLoader::committedLoad(WebDocumentLoader *loader, NSData *data)
+void FrameLoader::committedLoad(DocumentLoader* loader, NSData *data)
 {
     [m_client _committedLoadWithDocumentLoader:loader data:data];
 }
@@ -1124,19 +1119,19 @@ void FrameLoader::setReplacing()
     m_loadType = FrameLoadTypeReplace;
 }
 
-void FrameLoader::revertToProvisional(WebDocumentLoader *loader)
+void FrameLoader::revertToProvisional(DocumentLoader* loader)
 {
     [m_client _revertToProvisionalStateForDocumentLoader:loader];
 }
 
-void FrameLoader::setMainDocumentError(WebDocumentLoader *loader, NSError *error)
+void FrameLoader::setMainDocumentError(DocumentLoader* loader, NSError *error)
 {
     [m_client _setMainDocumentError:error forDocumentLoader:loader];
 }
 
-void FrameLoader::mainReceivedCompleteError(WebDocumentLoader *loader, NSError *error)
+void FrameLoader::mainReceivedCompleteError(DocumentLoader* loader, NSError *error)
 {
-    [loader setPrimaryLoadComplete:YES];
+    loader->setPrimaryLoadComplete(true);
     [m_client _dispatchDidLoadMainResourceForDocumentLoader:activeDocumentLoader()];
     checkLoadComplete();
 }
@@ -1146,32 +1141,34 @@ bool FrameLoader::subframeIsLoading() const
     // It's most likely that the last added frame is the last to load so we walk backwards.
     for (Frame* child = m_frame->tree()->lastChild(); child; child = child->tree()->previousSibling()) {
         FrameLoader* childLoader = [Mac(child)->bridge() frameLoader];
-        if ([childLoader->documentLoader() isLoadingInAPISense] || [childLoader->provisionalDocumentLoader() isLoadingInAPISense])
+        DocumentLoader* documentLoader = childLoader->documentLoader();
+        if (documentLoader && documentLoader->isLoadingInAPISense())
+            return true;
+        documentLoader = childLoader->provisionalDocumentLoader();
+        if (documentLoader && documentLoader->isLoadingInAPISense())
             return true;
     }
     return false;
 }
 
-void FrameLoader::willChangeTitle(WebDocumentLoader *loader)
+void FrameLoader::willChangeTitle(DocumentLoader* loader)
 {
     [m_client _willChangeTitleForDocument:loader];
 }
 
-void FrameLoader::didChangeTitle(WebDocumentLoader *loader)
+void FrameLoader::didChangeTitle(DocumentLoader* loader)
 {
     [m_client _didChangeTitleForDocument:loader];
 
     // The title doesn't get communicated to the WebView until we are committed.
-    if ([loader isCommitted]) {
-        NSURL *URLForHistory = canonicalURL([loader URLForHistory]);
-        if (URLForHistory != nil) {
+    if (loader->isCommitted())
+        if (NSURL *URLForHistory = canonicalURL(loader->URLForHistory())) {
             // Must update the entries in the back-forward list too.
             // This must go through the WebFrame because it has the right notion of the current b/f item.
-            [m_client _setTitle:[loader title] forURL:URLForHistory];
+            [m_client _setTitle:loader->title() forURL:URLForHistory];
             [m_client _setMainFrameDocumentReady:YES]; // update observers with new DOMDocument
-            [m_client _dispatchDidReceiveTitle:[loader title]];
+            [m_client _dispatchDidReceiveTitle:loader->title()];
         }
-    }
 }
 
 FrameLoadType FrameLoader::loadType() const
@@ -1245,18 +1242,18 @@ void FrameLoader::continueAfterNewWindowPolicy(WebPolicyAction policy)
     objc_msgSend(target.get(), selector, request.get(), frameName.get(), formState.get());
 }
 
-void FrameLoader::checkNavigationPolicy(NSURLRequest *request, WebDocumentLoader *loader,
+void FrameLoader::checkNavigationPolicy(NSURLRequest *request, DocumentLoader* loader,
     PassRefPtr<FormState> formState, id target, SEL selector)
 {
-    NSDictionary *action = [loader triggeringAction];
-    if (action == nil) {
+    NSDictionary *action = loader->triggeringAction();
+    if (!action) {
         action = actionInformation(NavigationTypeOther, nil, [request URL]);
-        [loader setTriggeringAction:action];
+        loader->setTriggeringAction(action);
     }
         
     // Don't ask more than once for the same request or if we are loading an empty URL.
     // This avoids confusion on the part of the client.
-    if ([request isEqual:[loader lastCheckedRequest]] || urlIsEmpty([request URL])) {
+    if ([request isEqual:loader->lastCheckedRequest()] || urlIsEmpty([request URL])) {
         objc_msgSend(target, selector, request, nil);
         return;
     }
@@ -1270,7 +1267,7 @@ void FrameLoader::checkNavigationPolicy(NSURLRequest *request, WebDocumentLoader
         return;
     }
     
-    [loader setLastCheckedRequest:request];
+    loader->setLastCheckedRequest(request);
 
     WebPolicyDecider *decider = [m_client _createPolicyDeciderWithTarget:asDelegate()
         action:@selector(continueAfterNavigationPolicy:)];
@@ -1330,7 +1327,7 @@ void FrameLoader::continueLoadRequestAfterNavigationPolicy(NSURLRequest *request
     // If we loaded an alternate page to replace an unreachableURL, we'll get in here with a
     // nil policyDataSource because loading the alternate page will have passed
     // through this method already, nested; otherwise, policyDataSource should still be set.
-    ASSERT(m_policyDocumentLoader || [m_provisionalDocumentLoader.get() unreachableURL] != nil);
+    ASSERT(m_policyDocumentLoader || m_provisionalDocumentLoader->unreachableURL());
 
     BOOL isTargetItem = [m_client _provisionalItemIsTarget];
 
@@ -1347,7 +1344,7 @@ void FrameLoader::continueLoadRequestAfterNavigationPolicy(NSURLRequest *request
         if (m_quickRedirectComing)
             clientRedirectCancelledOrFinished(false);
 
-        setPolicyDocumentLoader(nil);
+        setPolicyDocumentLoader(0);
 
         // If the navigation request came from the back/forward menu, and we punt on it, we have the 
         // problem that we have optimistically moved the b/f cursor already, so move it back.  For sanity, 
@@ -1364,7 +1361,7 @@ void FrameLoader::continueLoadRequestAfterNavigationPolicy(NSURLRequest *request
     m_loadType = type;
     setState(WebFrameStateProvisional);
 
-    setPolicyDocumentLoader(nil);
+    setPolicyDocumentLoader(0);
 
     if (isBackForwardLoadType(type) && [m_client _loadProvisionalItemFromPageCache])
         return;
@@ -1425,7 +1422,7 @@ void FrameLoader::transitionToCommitted(NSDictionary *pageCache)
     // The call to closeURL invokes the unload event handler, which can execute arbitrary
     // JavaScript. If the script initiates a new load, we need to abandon the current load,
     // or the two will stomp each other.
-    WebDocumentLoader *pdl = m_provisionalDocumentLoader.get();
+    DocumentLoader* pdl = m_provisionalDocumentLoader.get();
     [bridge() closeURL];
     if (pdl != m_provisionalDocumentLoader)
         return;
@@ -1433,8 +1430,8 @@ void FrameLoader::transitionToCommitted(NSDictionary *pageCache)
     commitProvisionalLoad();
 
     // Handle adding the URL to the back/forward list.
-    WebDocumentLoader *dl = m_documentLoader.get();
-    NSString *ptitle = [dl title];
+    DocumentLoader* dl = m_documentLoader.get();
+    NSString *ptitle = dl->title();
 
     switch (m_loadType) {
     case FrameLoadTypeForward:
@@ -1497,19 +1494,17 @@ void FrameLoader::checkLoadCompleteForThisFrame()
             if (m_delegateIsHandlingProvisionalLoadError)
                 return;
 
-            WebDocumentLoader *pdl = m_provisionalDocumentLoader.get();
+            RefPtr<DocumentLoader> pdl = m_provisionalDocumentLoader;
 
             // If we've received any errors we may be stuck in the provisional state and actually complete.
-            NSError *error = [pdl mainDocumentError];
+            NSError *error = pdl->mainDocumentError();
             if (!error)
                 return;
 
-            [pdl retain];
-
             // Check all children first.
             LoadErrorResetToken *resetToken = [m_client _tokenForLoadErrorReset];
             bool shouldReset = true;
-            if (![pdl isLoadingInAPISense]) {
+            if (!pdl->isLoadingInAPISense()) {
                 m_delegateIsHandlingProvisionalLoadError = true;
                 [m_client _dispatchDidFailProvisionalLoadWithError:error];
                 m_delegateIsHandlingProvisionalLoadError = false;
@@ -1518,15 +1513,15 @@ void FrameLoader::checkLoadCompleteForThisFrame()
                 // which it must be to be in this branch of the if? And is it OK to just do a full-on
                 // stopLoading instead of stopLoadingSubframes?
                 stopLoadingSubframes();
-                [pdl stopLoading];
+                pdl->stopLoading();
 
                 // Finish resetting the load state, but only if another load hasn't been started by the
                 // delegate callback.
                 if (pdl == m_provisionalDocumentLoader)
                     clearProvisionalLoad();
                 else {
-                    NSURL *unreachableURL = [m_provisionalDocumentLoader.get() unreachableURL];
-                    if (unreachableURL != nil && [unreachableURL isEqual:[[pdl request] URL]])
+                    NSURL *unreachableURL = m_provisionalDocumentLoader->unreachableURL();
+                    if (unreachableURL && [unreachableURL isEqual:[pdl->request() URL]])
                         shouldReset = false;
                 }
             }
@@ -1534,13 +1529,12 @@ void FrameLoader::checkLoadCompleteForThisFrame()
                 [m_client _resetAfterLoadError:resetToken];
             else
                 [m_client _doNotResetAfterLoadError:resetToken];
-            [pdl release];
             return;
         }
         
         case WebFrameStateCommittedPage: {
-            WebDocumentLoader *dl = m_documentLoader.get();            
-            if ([dl isLoadingInAPISense])
+            DocumentLoader* dl = m_documentLoader.get();            
+            if (dl->isLoadingInAPISense())
                 return;
 
             markLoadComplete();
@@ -1556,7 +1550,7 @@ void FrameLoader::checkLoadCompleteForThisFrame()
                     && [m_client _hasBackForwardList])
                 [m_client _restoreScrollPositionAndViewState];
 
-            NSError *error = [dl mainDocumentError];
+            NSError *error = dl->mainDocumentError();
             if (error)
                 [m_client _dispatchDidFailLoadWithError:error];
             else
@@ -1681,7 +1675,7 @@ void FrameLoader::detachFromParent()
     [client _detachedFromParent1];
     detachChildren();
     [client _detachedFromParent2];
-    setDocumentLoader(nil);
+    setDocumentLoader(0);
     [client _detachedFromParent3];
     if (Frame* parent = m_frame->tree()->parent())
         parent->tree()->removeChild(m_frame);
index c866c0956a6146e7224a1e8a59e97f2f9e55edae..c4a02cd9dd13ee4ab146e480bd37e81d64898541 100644 (file)
@@ -29,6 +29,7 @@
 #import <Cocoa/Cocoa.h>
 
 namespace WebCore {
+    class DocumentLoader;
     class WebResourceLoader;
 }
 
@@ -36,7 +37,6 @@ typedef struct LoadErrorResetToken LoadErrorResetToken;
 
 @class DOMElement;
 @class WebCoreFrameBridge;
-@class WebDocumentLoader;
 @class WebPolicyDecider;
 @class WebResource;
 
@@ -55,7 +55,7 @@ typedef struct LoadErrorResetToken LoadErrorResetToken;
 - (BOOL)_privateBrowsingEnabled;
 
 - (void)_makeDocumentView;
-- (void)_makeRepresentationForDocumentLoader:(WebDocumentLoader *)loader;
+- (void)_makeRepresentationForDocumentLoader:(WebCore::DocumentLoader*)loader;
 - (void)_setDocumentViewFromPageCache:(NSDictionary *)dictionary;
 - (void)_forceLayout;
 - (void)_forceLayoutForNonHTML;
@@ -84,14 +84,14 @@ typedef struct LoadErrorResetToken LoadErrorResetToken;
 
 - (void)_downloadWithLoadingConnection:(NSURLConnection *)connection request:(NSURLRequest *)request response:(NSURLResponse *)response proxy:(id)proxy;
 
-- (id)_dispatchIdentifierForInitialRequest:(NSURLRequest *)request fromDocumentLoader:(WebDocumentLoader *)loader;
-- (NSURLRequest *)_dispatchResource:(id)identifier willSendRequest:(NSURLRequest *)clientRequest redirectResponse:(NSURLResponse *)redirectResponse fromDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_dispatchDidReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_dispatchDidCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_dispatchResource:(id)identifier didReceiveResponse:(NSURLResponse *)r fromDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_dispatchResource:(id)identifier didReceiveContentLength:(int)lengthReceived fromDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_dispatchResource:(id)identifier didFinishLoadingFromDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_dispatchResource:(id)identifier didFailLoadingWithError:error fromDocumentLoader:(WebDocumentLoader *)loader;
+- (id)_dispatchIdentifierForInitialRequest:(NSURLRequest *)request fromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (NSURLRequest *)_dispatchResource:(id)identifier willSendRequest:(NSURLRequest *)clientRequest redirectResponse:(NSURLResponse *)redirectResponse fromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_dispatchDidReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_dispatchDidCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_dispatchResource:(id)identifier didReceiveResponse:(NSURLResponse *)r fromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_dispatchResource:(id)identifier didReceiveContentLength:(int)lengthReceived fromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_dispatchResource:(id)identifier didFinishLoadingFromDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_dispatchResource:(id)identifier didFailLoadingWithError:error fromDocumentLoader:(WebCore::DocumentLoader*)loader;
 
 - (void)_dispatchDidHandleOnloadEventsForFrame;
 - (void)_dispatchDidReceiveServerRedirectForProvisionalLoadForFrame;
@@ -118,12 +118,12 @@ typedef struct LoadErrorResetToken LoadErrorResetToken;
 
 - (void)_dispatchSourceFrame:(WebCoreFrameBridge *)sourceFrame willSubmitForm:(DOMElement *)form withValues:(NSDictionary *)values submissionDecider:(WebPolicyDecider *)decider;
 
-- (void)_dispatchDidLoadMainResourceForDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_clearLoadingFromPageCacheForDocumentLoader:(WebDocumentLoader *)loader;
-- (BOOL)_isDocumentLoaderLoadingFromPageCache:(WebDocumentLoader *)loader;
-- (void)_revertToProvisionalStateForDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_setMainDocumentError:(NSError *)error forDocumentLoader:(WebDocumentLoader *)loader;
-- (void)_clearUnarchivingStateForLoader:(WebDocumentLoader *)loader;
+- (void)_dispatchDidLoadMainResourceForDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_clearLoadingFromPageCacheForDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (BOOL)_isDocumentLoaderLoadingFromPageCache:(WebCore::DocumentLoader*)loader;
+- (void)_revertToProvisionalStateForDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_setMainDocumentError:(NSError *)error forDocumentLoader:(WebCore::DocumentLoader*)loader;
+- (void)_clearUnarchivingStateForLoader:(WebCore::DocumentLoader*)loader;
 
 - (void)_progressStarted;
 - (void)_progressCompleted;
@@ -136,13 +136,13 @@ typedef struct LoadErrorResetToken LoadErrorResetToken;
 
 - (void)_startDownloadWithRequest:(NSURLRequest *)request;
 
-- (void)_willChangeTitleForDocument:(WebDocumentLoader *)loader;
-- (void)_didChangeTitleForDocument:(WebDocumentLoader *)loader;
+- (void)_willChangeTitleForDocument:(WebCore::DocumentLoader*)loader;
+- (void)_didChangeTitleForDocument:(WebCore::DocumentLoader*)loader;
 
-- (void)_committedLoadWithDocumentLoader:(WebDocumentLoader *)loader data:(NSData *)data;
-- (void)_finishedLoadingDocument:(WebDocumentLoader *)loader;
-- (void)_documentLoader:(WebDocumentLoader *)loader setMainDocumentError:(NSError *)error;
-- (void)_finalSetupForReplaceWithDocumentLoader:(WebDocumentLoader *)loader;
+- (void)_committedLoadWithDocumentLoader:(WebCore::DocumentLoader*)loader data:(NSData *)data;
+- (void)_finishedLoadingDocument:(WebCore::DocumentLoader*)loader;
+- (void)_documentLoader:(WebCore::DocumentLoader*)loader setMainDocumentError:(NSError *)error;
+- (void)_finalSetupForReplaceWithDocumentLoader:(WebCore::DocumentLoader*)loader;
 
 - (NSError *)_cancelledErrorWithRequest:(NSURLRequest *)request;
 - (NSError *)_cannotShowURLErrorWithRequest:(NSURLRequest *)request;
@@ -179,7 +179,7 @@ typedef struct LoadErrorResetToken LoadErrorResetToken;
 - (void)_addHistoryItemForFragmentScroll;
 - (void)_didFinishLoad;
 - (void)_prepareForDataSourceReplacement;
-- (WebDocumentLoader *)_createDocumentLoaderWithRequest:(NSURLRequest *)request;
+- (PassRefPtr<WebCore::DocumentLoader>)_createDocumentLoaderWithRequest:(NSURLRequest *)request;
 - (void)_setTitle:(NSString *)title forURL:(NSURL *)URL;
 
 @end
index b4ffb003e30461ef5b49bb524aae41d7c7d01e08..098ce2d29b71f5e07df0f2edafd699c9d5df775f 100644 (file)
@@ -1,3 +1,79 @@
+2006-10-23  Darin Adler  <darin@apple.com>
+
+        Reviewed by Geoff.
+
+        - converted WebDocumentLoader to C++
+
+        * Plugins/WebPluginController.mm:
+        (-[WebPluginController pluginView:receivedResponse:]):
+        * WebKit.xcodeproj/project.pbxproj:
+        * WebView/WebDataSource.mm:
+        (-[WebDataSourcePrivate dealloc]):
+        (-[WebDataSource _mainDocumentError]):
+        (-[WebDataSource _URL]):
+        (-[WebDataSource _loadFromPageCache:]):
+        (-[WebDataSource _bridge]):
+        (-[WebDataSource _URLForHistory]):
+        (-[WebDataSource _documentLoader]):
+        (-[WebDataSource _initWithDocumentLoader:]):
+        (-[WebDataSource initWithRequest:]):
+        (-[WebDataSource data]):
+        (-[WebDataSource webFrame]):
+        (-[WebDataSource initialRequest]):
+        (-[WebDataSource request]):
+        (-[WebDataSource response]):
+        (-[WebDataSource textEncodingName]):
+        (-[WebDataSource isLoading]):
+        (-[WebDataSource unreachableURL]):
+        (-[WebDataSource webArchive]):
+        * WebView/WebDataSourceInternal.h:
+        * WebView/WebDocumentLoaderMac.h:
+        * WebView/WebDocumentLoaderMac.mm:
+        (WebDocumentLoaderMac::WebDocumentLoaderMac):
+        (WebDocumentLoaderMac::setDataSource):
+        (WebDocumentLoaderMac::dataSource):
+        (WebDocumentLoaderMac::attachToFrame):
+        (WebDocumentLoaderMac::detachFromFrame):
+        * WebView/WebFrame.mm:
+        (-[WebFrame _createItem:]):
+        (-[WebFrame _loadItem:withLoadType:]):
+        (-[WebFrame _addChild:]):
+        (dataSource):
+        (-[WebFrame _dataSourceForDocumentLoader:]):
+        (-[WebFrame _addDocumentLoader:toUnarchiveState:]):
+        (-[WebFrame loadArchive:]):
+        (-[WebFrame _updateHistoryForReload]):
+        (-[WebFrame _updateHistoryForStandardLoad]):
+        (-[WebFrame _updateHistoryForInternalLoad]):
+        (-[WebFrame _dispatchIdentifierForInitialRequest:fromDocumentLoader:]):
+        (-[WebFrame _dispatchResource:willSendRequest:redirectResponse:fromDocumentLoader:]):
+        (-[WebFrame _dispatchDidReceiveAuthenticationChallenge:forResource:fromDocumentLoader:]):
+        (-[WebFrame _dispatchDidCancelAuthenticationChallenge:forResource:fromDocumentLoader:]):
+        (-[WebFrame _dispatchResource:didReceiveResponse:fromDocumentLoader:]):
+        (-[WebFrame _dispatchResource:didReceiveContentLength:fromDocumentLoader:]):
+        (-[WebFrame _dispatchResource:didFinishLoadingFromDocumentLoader:]):
+        (-[WebFrame _dispatchResource:didFailLoadingWithError:fromDocumentLoader:]):
+        (-[WebFrame _dispatchDidLoadMainResourceForDocumentLoader:]):
+        (-[WebFrame _clearLoadingFromPageCacheForDocumentLoader:]):
+        (-[WebFrame _isDocumentLoaderLoadingFromPageCache:]):
+        (-[WebFrame _makeRepresentationForDocumentLoader:]):
+        (-[WebFrame _revertToProvisionalStateForDocumentLoader:]):
+        (-[WebFrame _setMainDocumentError:forDocumentLoader:]):
+        (-[WebFrame _clearUnarchivingStateForLoader:]):
+        (-[WebFrame _willChangeTitleForDocument:]):
+        (-[WebFrame _didChangeTitleForDocument:]):
+        (-[WebFrame _finishedLoadingDocument:]):
+        (-[WebFrame _committedLoadWithDocumentLoader:data:]):
+        (-[WebFrame _documentLoader:setMainDocumentError:]):
+        (-[WebFrame _finalSetupForReplaceWithDocumentLoader:]):
+        (-[WebFrame _createDocumentLoaderWithRequest:]):
+        (-[WebFrame _provisionalLoadStarted]):
+        * WebView/WebFrameInternal.h:
+        * WebView/WebHTMLRepresentation.m:
+        (-[WebHTMLRepresentation title]):
+        * WebView/WebView.mm:
+        (-[WebView _mainFrameOverrideEncoding]):
+
 2006-10-23  Geoffrey Garen  <ggaren@apple.com>
 
         RS by Maciej.
index 6d16c95c66a4ff7429ad2b933458b739abc8ea20..148978e9f8f196dfd6f1994a54c88c60601ab08c 100644 (file)
@@ -375,7 +375,7 @@ static void cancelOutstandingCheck(const void *item, void *context)
                                                      pluginPageURL:nil
                                                         pluginName:nil // FIXME: Get this from somewhere
                                                           MIMEType:[response MIMEType]];
-        [[_dataSource _documentLoader] frameLoader]->stopLoading(error);
+        [_dataSource _documentLoader]->frameLoader()->stopLoading(error);
         [error release];
     }        
 }
index b16f2a02b8d0ab75ecdfafd149fb1c6d5d894359..f2fb13cb3f73c0c1d119b41b8bd3c4665f6ca199 100644 (file)
                2D81DAB203EB0B2D00A80166 /* WebFormDelegate.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = WebFormDelegate.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
                2D81DAB303EB0B2D00A80166 /* WebFormDelegate.m */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.objc; path = WebFormDelegate.m; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
                35081D9202B6D4D80ACA2ACA /* WebHTMLRepresentation.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = WebHTMLRepresentation.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
-               35081D9302B6D4D80ACA2ACA /* WebHTMLRepresentation.m */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.objc; path = WebHTMLRepresentation.m; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
+               35081D9302B6D4D80ACA2ACA /* WebHTMLRepresentation.m */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; indentWidth = 4; path = WebHTMLRepresentation.m; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
                35081D9402B6D4D80ACA2ACA /* WebHTMLView.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = WebHTMLView.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
                35081D9502B6D4D80ACA2ACA /* WebHTMLView.m */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.objc; path = WebHTMLView.m; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
                35081D9602B6D4D80ACA2ACA /* WebHTMLViewPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = WebHTMLViewPrivate.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
index 51ca1ddc121eaddbb199fcd17a307cc0dde30fa3..9a2fbe8eaf6746ce2d1cdf127808f36785440714 100644 (file)
@@ -77,9 +77,9 @@ using namespace WebCore;
 
 - (void)dealloc
 {
-    ASSERT(![loader isLoading]);
+    ASSERT(!loader->isLoading());
 
-    [loader release];
+    loader->deref();
     
     [representation release];
     [unarchivingState release];
@@ -125,7 +125,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 - (NSError *)_mainDocumentError
 {
-    return [_private->loader mainDocumentError];
+    return _private->loader->mainDocumentError();
 }
 
 - (void)_addSubframeArchives:(NSArray *)subframeArchives
@@ -282,15 +282,15 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 // May return nil if not initialized with a URL.
 - (NSURL *)_URL
 {
-    return [_private->loader URL];
+    return _private->loader->URL();
 }
 
 - (void)_loadFromPageCache:(NSDictionary *)pageCache
 {
-    [_private->loader prepareForLoadStart];
+    _private->loader->prepareForLoadStart();
     _private->loadingFromPageCache = YES;
-    [_private->loader setCommitted:YES];
-    [_private->loader frameLoader]->commitProvisionalLoad(pageCache);
+    _private->loader->setCommitted(true);
+    _private->loader->frameLoader()->commitProvisionalLoad(pageCache);
 }
 
 - (WebArchive *)_popSubframeArchiveWithName:(NSString *)frameName
@@ -300,7 +300,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 - (WebFrameBridge *)_bridge
 {
-    ASSERT([_private->loader isCommitted]);
+    ASSERT(_private->loader->isCommitted());
     return [[self webFrame] _bridge];
 }
 
@@ -336,7 +336,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 - (NSURL *)_URLForHistory
 {
-    return [[_private->loader URLForHistory] _webkit_canonicalize];
+    return [_private->loader->URLForHistory() _webkit_canonicalize];
 }
 
 - (void)_addToUnarchiveState:(WebArchive *)archive
@@ -346,7 +346,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
     [_private->unarchivingState addArchive:archive];
 }
 
-- (WebDocumentLoader *)_documentLoader
+- (DocumentLoader*)_documentLoader
 {
     return _private->loader;
 }
@@ -354,15 +354,15 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 - (id)_initWithDocumentLoader:(WebDocumentLoaderMac *)loader
 {
     self = [super init];
-    if (!self) {
+    if (!self)
         return nil;
-    }
     
     _private = [[WebDataSourcePrivate alloc] init];
     
-    _private->loader = [loader retain];
+    _private->loader = loader;
+    loader->ref();
         
-    LOG(Loading, "creating datasource for %@", [[_private->loader request] URL]);
+    LOG(Loading, "creating datasource for %@", [_private->loader->request() URL]);
     
     ++WebDataSourceCount;
     
@@ -373,9 +373,9 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 @implementation WebDataSource
 
--(id)initWithRequest:(NSURLRequest *)request
+- (id)initWithRequest:(NSURLRequest *)request
 {
-    return [self _initWithDocumentLoader:[[WebDocumentLoader alloc] initWithRequest:request]];
+    return [self _initWithDocumentLoader:new WebDocumentLoaderMac(request)];
 }
 
 - (void)dealloc
@@ -396,7 +396,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 - (NSData *)data
 {
-    return [_private->loader mainResourceData];
+    return _private->loader->mainResourceData();
 }
 
 - (id <WebDocumentRepresentation>)representation
@@ -406,40 +406,38 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 - (WebFrame *)webFrame
 {
-    FrameLoader* frameLoader = [_private->loader frameLoader];
+    FrameLoader* frameLoader = _private->loader->frameLoader();
     if (!frameLoader)
         return nil;
     return (WebFrame *)frameLoader->client();
 }
 
--(NSURLRequest *)initialRequest
+- (NSURLRequest *)initialRequest
 {
-    return [_private->loader initialRequest];
+    return _private->loader->initialRequest();
 }
 
--(NSMutableURLRequest *)request
+- (NSMutableURLRequest *)request
 {
-    return [_private->loader request];
+    return _private->loader->request();
 }
 
 - (NSURLResponse *)response
 {
-    return [_private->loader response];
+    return _private->loader->response();
 }
 
 - (NSString *)textEncodingName
 {
-    NSString *textEncodingName = [_private->loader overrideEncoding];
-
+    NSString *textEncodingName = _private->loader->overrideEncoding();
     if (!textEncodingName)
         textEncodingName = [[self response] textEncodingName];
-
     return textEncodingName;
 }
 
 - (BOOL)isLoading
 {
-    return [_private->loader isLoadingInAPISense];
+    return _private->loader->isLoadingInAPISense();
 }
 
 // Returns nil or the page title.
@@ -450,15 +448,14 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCCl
 
 - (NSURL *)unreachableURL
 {
-    return [_private->loader unreachableURL];
+    return _private->loader->unreachableURL();
 }
 
 - (WebArchive *)webArchive
 {
     // it makes no sense to grab a WebArchive from an uncommitted document.
-    if (![_private->loader isCommitted])
+    if (!_private->loader->isCommitted())
         return nil;
-
     return [WebArchiver archiveFrame:[self webFrame]];
 }
 
index bdfa128b916c4b5ba718ea4e9074124b4c23288f..864a988bb8928d67c9a6dd5b1f31f60811957bdc 100644 (file)
 
 #import "WebDataSourcePrivate.h"
 
+#ifdef __cplusplus
+namespace WebCore {
+    class DocumentLoader;
+}
+typedef WebCore::DocumentLoader WebCoreDocumentLoader;
+class WebDocumentLoaderMac;
+#else
+@class WebCoreDocumentLoader;
+@class WebDocumentLoaderMac;
+#endif
+
 @class DOMDocumentFragment;
 @class DOMElement;
 @class NSError;
 @class NSURL;
 @class WebArchive;
-@class WebDocumentLoader;
-@class WebDocumentLoaderMac;
 @class WebFrameBridge;
 @class WebResource;
 @class WebView;
 + (NSMutableDictionary *)_repTypesAllowImageTypeOmission:(BOOL)allowImageTypeOmission;
 - (void)_replaceSelectionWithArchive:(WebArchive *)archive selectReplacement:(BOOL)selectReplacement;
 - (WebResource *)_archivedSubresourceForURL:(NSURL *)URL;
-- (id)_initWithDocumentLoader:(WebDocumentLoaderMac *)loader;
+- (id)_initWithDocumentLoader:(WebDocumentLoaderMac*)loader;
 - (void)_finishedLoading;
 - (void)_receivedData:(NSData *)data;
 - (void)_revertToProvisionalState;
 - (void)_setMainDocumentError:(NSError *)error;
 - (void)_clearUnarchivingState;
-- (WebDocumentLoader *)_documentLoader;
+- (WebCoreDocumentLoader*)_documentLoader;
 @end
index d28172ec9a732c66219e539851acb4aff98bb240..aea32053049038278599eb0d733fd7e6a1f7f62a 100644 (file)
 
 @class WebDataSource;
 
-@interface WebDocumentLoaderMac : WebDocumentLoader
+class WebDocumentLoaderMac : public WebCore::DocumentLoader
 {
-    WebDataSource *dataSource;
-    WebDataSource *detachedDataSource; // not retained
-}
-- (void)setDataSource:(WebDataSource *)dataSource;
-- (WebDataSource *)dataSource;
-@end
+public:
+    WebDocumentLoaderMac(NSURLRequest *);
+
+    void setDataSource(WebDataSource *);
+    WebDataSource *dataSource() const;
+
+    virtual void attachToFrame();
+    virtual void detachFromFrame();
+
+private:
+    WebCore::RetainPtr<WebDataSource> m_dataSource;
+    WebDataSource *m_detachedDataSource; // not retained
+};
index bc59354398dcc554f6477bde5452ea56d105d29f..4f20e5866a1c819abf3c68cf68b4886945e0fd8f 100644 (file)
 
 #import <JavaScriptCore/Assertions.h>
 
-@implementation WebDocumentLoaderMac
-
-- (void)dealloc
+WebDocumentLoaderMac::WebDocumentLoaderMac(NSURLRequest *request)
+    : DocumentLoader(request)
+    , m_detachedDataSource(nil)
 {
-    [dataSource release];
-    [super dealloc];
-}    
+}
 
-- (void)setDataSource:(WebDataSource *)ds
+void WebDocumentLoaderMac::setDataSource(WebDataSource *dataSource)
 {
-    [ds retain];
-    [dataSource release];
-    dataSource = ds;    
+    m_dataSource = dataSource;    
 }
 
-- (WebDataSource *)dataSource
+WebDataSource *WebDocumentLoaderMac::dataSource() const
 {
-    return dataSource;
+    return m_dataSource.get();
 }
 
-- (void)attachToFrame
+void WebDocumentLoaderMac::attachToFrame()
 {
-    [super attachToFrame];
-    if (detachedDataSource) {
-        ASSERT(!dataSource);
-        [self setDataSource:detachedDataSource];
-        detachedDataSource = nil;
+    DocumentLoader::attachToFrame();
+    if (m_detachedDataSource) {
+        ASSERT(!m_dataSource);
+        m_dataSource = m_detachedDataSource;
+        m_detachedDataSource = nil;
     }
 }
 
-- (void)detachFromFrame
+void WebDocumentLoaderMac::detachFromFrame()
 {
-    [super detachFromFrame];
-    detachedDataSource = dataSource;
-    [self setDataSource:nil];
+    DocumentLoader::detachFromFrame();
+    m_detachedDataSource = m_dataSource.get();
+    m_dataSource = nil;
 }
-
-@end
index 87ed8399e714d11357aa8b2b01b7cfdc58ec6c41..62f4d913d3b0f43789029fc4e3eaca6908ac809b 100644 (file)
@@ -290,7 +290,7 @@ static inline WebFrame *frame(WebCoreFrameBridge *bridge)
     WebHistoryItem *bfItem;
 
     if (useOriginal)
-        request = [[dataSrc _documentLoader] originalRequestCopy];
+        request = [dataSrc _documentLoader]->originalRequestCopy();
     else
         request = [dataSrc request];
 
@@ -299,7 +299,7 @@ static inline WebFrame *frame(WebCoreFrameBridge *bridge)
         originalURL = unreachableURL;
     } else {
         URL = [request URL];
-        originalURL = [[[dataSrc _documentLoader] originalRequestCopy] URL];
+        originalURL = [[dataSrc _documentLoader]->originalRequestCopy() URL];
     }
 
     LOG (History, "creating item for %@", request);
@@ -499,7 +499,7 @@ static inline WebFrame *frame(WebCoreFrameBridge *bridge)
 
         // Fake the URL change by updating the data source's request.  This will no longer
         // be necessary if we do the better fix described above.
-        [[self _frameLoader]->documentLoader() replaceRequestURLForAnchorScrollWithURL:itemURL];
+        [self _frameLoader]->documentLoader()->replaceRequestURLForAnchorScroll(itemURL);
         
         [[[self webView] _frameLoadDelegateForwarder] webView:[self webView]
                                didChangeLocationWithinPageForFrame:self];
@@ -740,7 +740,8 @@ static inline WebFrame *frame(WebCoreFrameBridge *bridge)
 - (void)_addChild:(WebFrame *)child
 {
     [[self _bridge] appendChild:[child _bridge]];
-    [[[child dataSource] _documentLoader] setOverrideEncoding:[[[self dataSource] _documentLoader] overrideEncoding]];  
+    if ([child dataSource])
+        [[child dataSource] _documentLoader]->setOverrideEncoding([[self dataSource] _documentLoader]->overrideEncoding());  
 }
 
 // If we bailed out of a b/f navigation, we might need to set the b/f cursor back to the current
@@ -1051,17 +1052,17 @@ static inline WebFrame *frame(WebCoreFrameBridge *bridge)
     return [_private->bridge frameLoader];
 }
 
-static inline WebDataSource *dataSource(WebDocumentLoader *loader)
+static inline WebDataSource *dataSource(DocumentLoader* loader)
 {
-    return [(WebDocumentLoaderMac *)loader dataSource];
+    return loader ? static_cast<WebDocumentLoaderMac*>(loader)->dataSource() : nil;
 }
 
-- (WebDataSource *)_dataSourceForDocumentLoader:(WebDocumentLoader *)loader
+- (WebDataSource *)_dataSourceForDocumentLoader:(DocumentLoader*)loader
 {
     return dataSource(loader);
 }
 
-- (void)_addDocumentLoader:(WebDocumentLoader *)loader toUnarchiveState:(WebArchive *)archive
+- (void)_addDocumentLoader:(DocumentLoader*)loader toUnarchiveState:(WebArchive *)archive
 {
     [dataSource(loader) _addToUnarchiveState:archive];
 }
@@ -1221,9 +1222,9 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
                                             textEncodingName:[mainResource textEncodingName]
                                                      baseURL:[mainResource URL]
                                               unreachableURL:nil];
-        WebDocumentLoader *documentLoader = [self _createDocumentLoaderWithRequest:request];
-        [dataSource(documentLoader) _addToUnarchiveState:archive];
-        [self _frameLoader]->load(documentLoader);
+        RefPtr<DocumentLoader> documentLoader = [self _createDocumentLoaderWithRequest:request];
+        [dataSource(documentLoader.get()) _addToUnarchiveState:archive];
+        [self _frameLoader]->load(documentLoader.get());
     }
 }
 
@@ -1364,7 +1365,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
     if ([request _webDataRequestUnreachableURL] == nil)
         [currItem setURL:[request URL]];
     // Update the last visited time. Mostly interesting for URL autocompletion statistics.
-    NSURL *URL = [[[[dataSource _documentLoader] originalRequestCopy] URL] _webkit_canonicalize];
+    NSURL *URL = [[[dataSource _documentLoader]->originalRequestCopy() URL] _webkit_canonicalize];
     WebHistory *sharedHistory = [WebHistory optionalSharedHistory];
     WebHistoryItem *oldItem = [sharedHistory itemForURL:URL];
     if (oldItem)
@@ -1374,7 +1375,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
 - (void)_updateHistoryForStandardLoad
 {
     WebDataSource *dataSource = [self dataSource];
-    if (![[dataSource _documentLoader] isClientRedirect]) {
+    if (![dataSource _documentLoader]->isClientRedirect()) {
         NSURL *URL = [dataSource _URLForHistory];
         if (URL && ![URL _web_isEmpty]) {
             ASSERT([self webView]);
@@ -1413,7 +1414,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
 - (void)_updateHistoryForInternalLoad
 {
     // Add an item to the item tree for this frame
-    ASSERT(![[self _frameLoader]->documentLoader() isClientRedirect]);
+    ASSERT(![self _frameLoader]->documentLoader()->isClientRedirect());
     WebFrame *parentFrame = [self parentFrame];
     if (parentFrame) {
         WebHistoryItem *parentItem = parentFrame->_private->currentItem;
@@ -1462,7 +1463,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
        didReceiveServerRedirectForProvisionalLoadForFrame:self];
 }
 
-- (id)_dispatchIdentifierForInitialRequest:(NSURLRequest *)clientRequest fromDocumentLoader:(WebDocumentLoader *)loader
+- (id)_dispatchIdentifierForInitialRequest:(NSURLRequest *)clientRequest fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
     id resourceLoadDelegate = [webView resourceLoadDelegate];
@@ -1473,7 +1474,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
     return [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:webView identifierForInitialRequest:clientRequest fromDataSource:dataSource(loader)];
 }
 
-- (NSURLRequest *)_dispatchResource:(id)identifier willSendRequest:(NSURLRequest *)clientRequest redirectResponse:(NSURLResponse *)redirectResponse fromDocumentLoader:(WebDocumentLoader *)loader
+- (NSURLRequest *)_dispatchResource:(id)identifier willSendRequest:(NSURLRequest *)clientRequest redirectResponse:(NSURLResponse *)redirectResponse fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
     id resourceLoadDelegate = [webView resourceLoadDelegate];
@@ -1484,7 +1485,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
         return [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:webView resource:identifier willSendRequest:clientRequest redirectResponse:redirectResponse fromDataSource:dataSource(loader)];
 }
 
-- (void)_dispatchDidReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchDidReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
     id resourceLoadDelegate = [webView resourceLoadDelegate];
@@ -1495,7 +1496,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
         [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:webView resource:identifier didReceiveAuthenticationChallenge:currentWebChallenge fromDataSource:dataSource(loader)];
 }
 
-- (void)_dispatchDidCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchDidCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)currentWebChallenge forResource:(id)identifier fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
     id resourceLoadDelegate = [webView resourceLoadDelegate];
@@ -1506,7 +1507,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
         [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:webView resource:identifier didCancelAuthenticationChallenge:currentWebChallenge fromDataSource:dataSource(loader)];
 }
 
-- (void)_dispatchResource:(id)identifier didReceiveResponse:(NSURLResponse *)r fromDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchResource:(id)identifier didReceiveResponse:(NSURLResponse *)r fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
 
@@ -1516,7 +1517,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
         [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:webView resource:identifier didReceiveResponse:r fromDataSource:dataSource(loader)];
 }
 
-- (void)_dispatchResource:(id)identifier didReceiveContentLength:(int)lengthReceived fromDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchResource:(id)identifier didReceiveContentLength:(int)lengthReceived fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
 
@@ -1526,7 +1527,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
         [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:webView resource:identifier didReceiveContentLength:(WebNSUInteger)lengthReceived fromDataSource:dataSource(loader)];
 }
 
-- (void)_dispatchResource:(id)identifier didFinishLoadingFromDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchResource:(id)identifier didFinishLoadingFromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
     
@@ -1537,7 +1538,7 @@ static inline WebDataSource *dataSource(WebDocumentLoader *loader)
 }
 
 
-- (void)_dispatchResource:(id)identifier didFailLoadingWithError:error fromDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchResource:(id)identifier didFailLoadingWithError:error fromDocumentLoader:(DocumentLoader*)loader
 {
     WebView *webView = [self webView];
     [[webView _resourceLoadDelegateForwarder] webView:webView resource:identifier didFailLoadingWithError:error fromDataSource:dataSource(loader)];
@@ -1757,7 +1758,7 @@ static inline WebPolicyDecisionListener *decisionListener(WebPolicyDecider *deci
     [[[[self frameView] _scrollView] contentView] setCopiesOnScroll:YES];
 }
 
-- (void)_dispatchDidLoadMainResourceForDocumentLoader:(WebDocumentLoader *)loader
+- (void)_dispatchDidLoadMainResourceForDocumentLoader:(DocumentLoader*)loader
 {
     if ([WebScriptDebugServer listenerCount])
         [[WebScriptDebugServer sharedScriptDebugServer] webView:[self webView]
@@ -1779,32 +1780,32 @@ static inline WebPolicyDecisionListener *decisionListener(WebPolicyDecider *deci
     }
 }
 
-- (void)_clearLoadingFromPageCacheForDocumentLoader:(WebDocumentLoader *)loader
+- (void)_clearLoadingFromPageCacheForDocumentLoader:(DocumentLoader*)loader
 {
     [dataSource(loader) _setLoadingFromPageCache:NO];
 }
 
-- (BOOL)_isDocumentLoaderLoadingFromPageCache:(WebDocumentLoader *)loader
+- (BOOL)_isDocumentLoaderLoadingFromPageCache:(DocumentLoader*)loader
 {
     return [dataSource(loader) _loadingFromPageCache];
 }
 
-- (void)_makeRepresentationForDocumentLoader:(WebDocumentLoader *)loader
+- (void)_makeRepresentationForDocumentLoader:(DocumentLoader*)loader
 {
     [dataSource(loader) _makeRepresentation];
 }
 
-- (void)_revertToProvisionalStateForDocumentLoader:(WebDocumentLoader *)loader
+- (void)_revertToProvisionalStateForDocumentLoader:(DocumentLoader*)loader
 {
     [dataSource(loader) _revertToProvisionalState];
 }
 
-- (void)_setMainDocumentError:(NSError *)error forDocumentLoader:(WebDocumentLoader *)loader
+- (void)_setMainDocumentError:(NSError *)error forDocumentLoader:(DocumentLoader*)loader
 {
     [dataSource(loader) _setMainDocumentError:error];
 }
 
-- (void)_clearUnarchivingStateForLoader:(WebDocumentLoader *)loader
+- (void)_clearUnarchivingStateForLoader:(DocumentLoader*)loader
 {
     [dataSource(loader) _clearUnarchivingState];
 }
@@ -1839,13 +1840,13 @@ static inline WebPolicyDecisionListener *decisionListener(WebPolicyDecider *deci
     [[self webView] setMainFrameDocumentReady:ready];
 }
 
-- (void)_willChangeTitleForDocument:(WebDocumentLoader *)loader
+- (void)_willChangeTitleForDocument:(DocumentLoader*)loader
 {
     // FIXME: Should do this only in main frame case, right?
     [[self webView] _willChangeValueForKey:_WebMainFrameTitleKey];
 }
 
-- (void)_didChangeTitleForDocument:(WebDocumentLoader *)loader
+- (void)_didChangeTitleForDocument:(DocumentLoader*)loader
 {
     // FIXME: Should do this only in main frame case, right?
     [[self webView] _didChangeValueForKey:_WebMainFrameTitleKey];
@@ -1857,22 +1858,22 @@ static inline WebPolicyDecisionListener *decisionListener(WebPolicyDecider *deci
     [[self webView] _downloadURL:[request URL]];
 }
 
-- (void)_finishedLoadingDocument:(WebDocumentLoader *)loader
+- (void)_finishedLoadingDocument:(DocumentLoader*)loader
 {
     [dataSource(loader) _finishedLoading];
 }
 
-- (void)_committedLoadWithDocumentLoader:(WebDocumentLoader *)loader data:(NSData *)data
+- (void)_committedLoadWithDocumentLoader:(DocumentLoader*)loader data:(NSData *)data
 {
     [dataSource(loader) _receivedData:data];
 }
 
-- (void)_documentLoader:(WebDocumentLoader *)loader setMainDocumentError:(NSError *)error
+- (void)_documentLoader:(DocumentLoader*)loader setMainDocumentError:(NSError *)error
 {
     [dataSource(loader) _setMainDocumentError:error];
 }
 
-- (void)_finalSetupForReplaceWithDocumentLoader:(WebDocumentLoader *)loader
+- (void)_finalSetupForReplaceWithDocumentLoader:(DocumentLoader*)loader
 {
     [dataSource(loader) _clearUnarchivingState];
 }
@@ -2137,15 +2138,15 @@ static inline WebPolicyDecisionListener *decisionListener(WebPolicyDecider *deci
     [_private->currentItem setTitle:title];
 }
 
-- (WebDocumentLoader *)_createDocumentLoaderWithRequest:(NSURLRequest *)request
+- (PassRefPtr<DocumentLoader>)_createDocumentLoaderWithRequest:(NSURLRequest *)request
 {
-    WebDocumentLoaderMac *loader = [[WebDocumentLoaderMac alloc] initWithRequest:request];
-    
-    WebDataSource *dataSource = [[WebDataSource alloc] _initWithDocumentLoader:loader];
-    [loader setDataSource:dataSource];
+    RefPtr<WebDocumentLoaderMac> loader = new WebDocumentLoaderMac(request);
+
+    WebDataSource *dataSource = [[WebDataSource alloc] _initWithDocumentLoader:loader.get()];
+    loader->setDataSource(dataSource);
     [dataSource release];
-    
-    return loader;
+
+    return loader.release();
 }
 
 - (void)_prepareForDataSourceReplacement
@@ -2216,7 +2217,7 @@ static inline WebPolicyDecisionListener *decisionListener(WebPolicyDecider *deci
         && loadType != FrameLoadTypeReloadAllowingStaleData
         && loadType != FrameLoadTypeSame
         && ![[self dataSource] isLoading]
-        && ![[self _frameLoader]->documentLoader() isStopping]) {
+        && ![self _frameLoader]->documentLoader()->isStopping()) {
         if ([[[self dataSource] representation] isKindOfClass:[WebHTMLRepresentation class]]) {
             if (![item pageCache]){
                 // Add the items to this page's cache.
index de5bce0d61544f6455576771ab62aac5b11727f4..249bf9e45a5908b72ad2ad69b9fec176ca9fe2d7 100644 (file)
 
 #ifdef __cplusplus
 namespace WebCore {
+    class DocumentLoader;
     class FrameLoader;
 }
+typedef WebCore::DocumentLoader WebCoreDocumentLoader;
 typedef WebCore::FrameLoader WebCoreFrameLoader;
 #else
+@class WebCoreDocumentLoader;
 @class WebCoreFrameLoader;
 #endif
 
@@ -73,7 +76,7 @@ typedef WebCore::FrameLoader WebCoreFrameLoader;
 - (void)_removeInspector:(WebInspector *)inspector;
 
 - (WebCoreFrameLoader*)_frameLoader;
-- (WebDataSource *)_dataSourceForDocumentLoader:(WebDocumentLoader *)loader;
+- (WebDataSource *)_dataSourceForDocumentLoader:(WebCoreDocumentLoader*)loader;
 
 - (NSURLRequest *)_webDataRequestForData:(NSData *)data MIMEType:(NSString *)MIMEType textEncodingName:(NSString *)encodingName baseURL:(NSURL *)URL unreachableURL:(NSURL *)unreachableURL;
 
@@ -110,7 +113,7 @@ typedef WebCore::FrameLoader WebCoreFrameLoader;
 - (void)_recursive_pauseNullEventsForAllNetscapePlugins;
 - (void)_recursive_resumeNullEventsForAllNetscapePlugins;
 
-- (void)_addDocumentLoader:(WebDocumentLoader *)loader toUnarchiveState:(WebArchive *)archive;
+- (void)_addDocumentLoader:(WebCoreDocumentLoader*)loader toUnarchiveState:(WebArchive *)archive;
 
 @end
 
index 765ead26fb17cc2ad46b1f230e5a7ed1a49d3743..24a340fa714b01ca6b0b8f2b1e0abcdbaba6e858 100644 (file)
@@ -41,7 +41,7 @@
 #import "WebView.h"
 #import <Foundation/NSURLResponse.h>
 #import <JavaScriptCore/Assertions.h>
-#import <WebKit/DOM.h>
+#import <WebCore/WebDocumentLoader.h>
 
 @interface WebHTMLRepresentationPrivate : NSObject
 {
 
 - (NSString *)title
 {
-    return [[_private->dataSource _documentLoader] title];
+    return [_private->dataSource _documentLoader]->title();
 }
 
 - (DOMDocument *)DOMDocument
index 564b39c812f2e861b1d0bb556e1137e23854dd73..389aaa5b3f970276e41335620d292eadcf742bb2 100644 (file)
@@ -2199,13 +2199,11 @@ NS_ENDHANDLER
 - (NSString *)_mainFrameOverrideEncoding
 {
     WebDataSource *dataSource = [[self mainFrame] provisionalDataSource];
-    if (dataSource == nil) {
+    if (dataSource == nil)
         dataSource = [[self mainFrame] dataSource];
-    }
-    if (dataSource == nil) {
+    if (dataSource == nil)
         return nil;
-    }
-    return [[dataSource _documentLoader] overrideEncoding];
+    return [dataSource _documentLoader]->overrideEncoding();
 }
 
 - (NSString *)customTextEncodingName