/*

 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer. 

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#import "WebFrameLoaderClient.h"

// Terrible hack; lets us get at the WebFrame private structure.

#define private public

#import "WebFrame.h"

#undef private

#import "DOMElementInternal.h"

#import "WebBackForwardList.h"

#import "WebChromeClient.h"

#import "WebDataSourceInternal.h"

#import "WebPolicyDelegatePrivate.h"

#import "WebDocumentInternal.h"

#import "WebDocumentLoaderMac.h"

#import "WebDownloadInternal.h"

#import "WebDynamicScrollBarsView.h"

#import "WebElementDictionary.h"

#import "WebFormDelegate.h"

#import "WebFrameBridge.h"

#import "WebFrameInternal.h"

#import "WebFrameLoadDelegate.h"

#import "WebFrameViewInternal.h"

#import "WebHTMLRepresentation.h"

#import "WebHTMLView.h"

#import "WebHistoryItemInternal.h"

#import "WebHistoryItemPrivate.h"

#import "WebHistoryPrivate.h"

#import "WebIconDatabaseInternal.h"

#import "WebKitErrorsPrivate.h"

#import "WebKitLogging.h"

#import "WebKitNSStringExtras.h"

#import "WebNSURLExtras.h"

#import "WebPanelAuthenticationHandler.h"

#import "WebPolicyDelegate.h"

#import "WebPreferences.h"

#import "WebResourceLoadDelegate.h"

#import "WebResourcePrivate.h"

#import "WebScriptDebugServerPrivate.h"

#import "WebUIDelegate.h"

#import "WebViewInternal.h"

#import <WebCore/AuthenticationMac.h>

#import <WebCore/BlockExceptions.h>

#import <WebCore/CachedPage.h>

#import <WebCore/Chrome.h>

#import <WebCore/Document.h>

#import <WebCore/DocumentLoader.h>

#import <WebCore/EventHandler.h>

#import <WebCore/FormState.h>

#import <WebCore/FrameLoader.h>

#import <WebCore/FrameLoaderTypes.h>

#import <WebCore/Frame.h>

#import <WebCore/FrameTree.h>

#import <WebCore/HistoryItem.h>

#import <WebCore/HitTestResult.h>

#import <WebCore/HTMLFormElement.h>

#import <WebCore/IconDatabase.h>

#import <WebCore/LoaderNSURLExtras.h>

#import <WebCore/MouseEvent.h>

#import <WebCore/Page.h>

#import <WebCore/PlatformString.h>

#import <WebCore/ResourceError.h>

#import <WebCore/ResourceHandle.h>

#import <WebCore/ResourceLoader.h>

#import <WebCore/ResourceRequest.h>

#import <WebCore/WebCoreFrameBridge.h>

#import <WebCore/WebCoreObjCExtras.h>

#import <WebCore/SharedBuffer.h>

#import <WebCore/Widget.h>

#import <WebKit/DOMElement.h>

#import <WebKit/DOMHTMLFormElement.h>

#import <WebKitSystemInterface.h>

#import <wtf/PassRefPtr.h>

using namespace WebCore;

// SPI for NSURLDownload

// Needed for <rdar://problem/5121850> 

@interface NSURLDownload (NSURLDownloadPrivate)

- (void)_setOriginatingURL:(NSURL *)originatingURL;

@end

@interface WebHistoryItem (WebHistoryItemPrivate)

- (BOOL)_wasUserGesture;

@end

@interface WebFramePolicyListener : NSObject <WebPolicyDecisionListener, WebFormSubmissionListener>

{

    Frame* m_frame;

}

- (id)initWithWebCoreFrame:(Frame*)frame;

- (void)invalidate;

@end

static inline WebDataSource *dataSource(DocumentLoader* loader)

{

    return loader ? static_cast<WebDocumentLoaderMac*>(loader)->dataSource() : nil;

}

WebFrameLoaderClient::WebFrameLoaderClient(WebFrame *webFrame)

    : m_webFrame(webFrame)

    , m_policyFunction(0)

    , m_archivedResourcesDeliveryTimer(this, &WebFrameLoaderClient::deliverArchivedResources)

{

}

void WebFrameLoaderClient::frameLoaderDestroyed()

{

    delete this;

}

bool WebFrameLoaderClient::hasWebView() const

{

    return [m_webFrame.get() webView] != nil;

}

bool WebFrameLoaderClient::hasFrameView() const

{

    return m_webFrame->_private->webFrameView != nil;

}

bool WebFrameLoaderClient::privateBrowsingEnabled() const

{

    return [[getWebView(m_webFrame.get()) preferences] privateBrowsingEnabled];

}

void WebFrameLoaderClient::makeDocumentView()

{

    WebFrameView *v = m_webFrame->_private->webFrameView;

    WebDataSource *ds = [m_webFrame.get() _dataSource];

    bool willProduceHTMLView = [[WebFrameView class] _viewClassForMIMEType:[[ds response] MIMEType]] == [WebHTMLView class];

    bool canSkipCreation = [m_webFrame.get() _frameLoader]->committingFirstRealLoad() && willProduceHTMLView;

    if (canSkipCreation) {

        [[v documentView] setDataSource:ds];

        return;

    }

    // Don't suppress scrollbars before the view creation if we're making the view for a non-HTML view.

    if (!willProduceHTMLView)

        [[v _scrollView] setScrollBarsSuppressed:NO repaintOnUnsuppress:NO];

    NSView <WebDocumentView> *documentView = [v _makeDocumentViewForDataSource:ds];

    if (!documentView)

        return;

    WebFrameBridge *bridge = m_webFrame->_private->bridge;

    // FIXME: We could save work and not do this for a top-level view that is not a WebHTMLView.

    [bridge createFrameViewWithNSView:documentView marginWidth:[v _marginWidth] marginHeight:[v _marginHeight]];

    [m_webFrame.get() _updateBackground];

    [bridge installInFrame:[v _scrollView]];

    // Call setDataSource on the document view after it has been placed in the view hierarchy.

    // This what we for the top-level view, so should do this for views in subframes as well.

    [documentView setDataSource:ds];

}

void WebFrameLoaderClient::makeRepresentation(DocumentLoader* loader)

{

    [dataSource(loader) _makeRepresentation];

}

void WebFrameLoaderClient::setDocumentViewFromCachedPage(CachedPage* cachedPage)

{

    DocumentLoader* cachedDocumentLoader = cachedPage->documentLoader();

    ASSERT(cachedDocumentLoader);

    cachedDocumentLoader->setFrame(core(m_webFrame.get()));

    NSView <WebDocumentView> *cachedView = cachedPage->documentView();

    ASSERT(cachedView != nil);

    [cachedView setDataSource:dataSource(cachedDocumentLoader)];

    [m_webFrame->_private->webFrameView _setDocumentView:cachedView];

}

bool WebFrameLoaderClient::hasHTMLView() const

{

    NSView <WebDocumentView> *view = [m_webFrame->_private->webFrameView documentView];

    return [view isKindOfClass:[WebHTMLView class]];

}

void WebFrameLoaderClient::forceLayout()

{

    NSView <WebDocumentView> *view = [m_webFrame->_private->webFrameView documentView];

    if ([view isKindOfClass:[WebHTMLView class]])

        [(WebHTMLView *)view setNeedsToApplyStyles:YES];

    [view setNeedsLayout:YES];

    [view layout];

}

void WebFrameLoaderClient::forceLayoutForNonHTML()

{

    WebFrameView *thisView = m_webFrame->_private->webFrameView;

    NSView <WebDocumentView> *thisDocumentView = [thisView documentView];

    ASSERT(thisDocumentView != nil);

    // Tell the just loaded document to layout.  This may be necessary

    // for non-html content that needs a layout message.

    if (!([[m_webFrame.get() _dataSource] _isDocumentHTML])) {

        [thisDocumentView setNeedsLayout:YES];

        [thisDocumentView layout];

        [thisDocumentView setNeedsDisplay:YES];

    }

}

void WebFrameLoaderClient::setCopiesOnScroll()

{

    [[[m_webFrame->_private->webFrameView _scrollView] contentView] setCopiesOnScroll:YES];

}

void WebFrameLoaderClient::detachedFromParent2()

{

    [m_webFrame->_private->webFrameView _setWebFrame:nil]; // needed for now to be compatible w/ old behavior

}

void WebFrameLoaderClient::detachedFromParent3()

{

    [m_webFrame->_private->webFrameView release];

    m_webFrame->_private->webFrameView = nil;

}

void WebFrameLoaderClient::detachedFromParent4()

{

    m_webFrame->_private->bridge = nil;

}

void WebFrameLoaderClient::download(ResourceHandle* handle, const ResourceRequest& request, const ResourceRequest& initialRequest, const ResourceResponse& response)

{

    id proxy = handle->releaseProxy();

    ASSERT(proxy);

    WebView *webView = getWebView(m_webFrame.get());

    WebDownload *download = [WebDownload _downloadWithLoadingConnection:handle->connection()

                                                                request:request.nsURLRequest()

                                                               response:response.nsURLResponse()

                                                               delegate:[webView downloadDelegate]

                                                                  proxy:proxy];

    setOriginalURLForDownload(download, initialRequest);    

}

void WebFrameLoaderClient::setOriginalURLForDownload(WebDownload *download, const ResourceRequest& initialRequest) const

{

    NSURLRequest *initialURLRequest = initialRequest.nsURLRequest();

    NSURL *originalURL = nil;

    // If there was no referrer, don't traverse the back/forward history

    // since this download was initiated directly. <rdar://problem/5294691>

    if ([initialURLRequest valueForHTTPHeaderField:@"Referer"]) {

        // find the first item in the history that was originated by the user

        WebView *webView = getWebView(m_webFrame.get());

        WebBackForwardList *history = [webView backForwardList];

        int backListCount = [history backListCount];

        for (int backIndex = 0; backIndex <= backListCount && !originalURL; backIndex++) {

            WebHistoryItem *currentItem = [history itemAtIndex:-backIndex];

            if (![currentItem respondsToSelector:@selector(_wasUserGesture)] || [currentItem _wasUserGesture])

                originalURL = [currentItem URL];

        }

    }

    if (!originalURL)

        originalURL = [initialURLRequest URL];

    if ([download respondsToSelector:@selector(_setOriginatingURL:)]) {

        NSString *scheme = [originalURL scheme];

        NSString *host = [originalURL host];

        if (scheme && host && [scheme length] && [host length]) {

            NSNumber *port = [originalURL port];

            if (port && [port intValue] < 0)

                port = nil;

            NSString *hostOnlyURLString;

            if (port)

                hostOnlyURLString = [[NSString alloc] initWithFormat:@"%@://%@:%d", scheme, host, [port intValue]];

            else

                hostOnlyURLString = [[NSString alloc] initWithFormat:@"%@://%@", scheme, host];

            NSURL *hostOnlyURL = [[NSURL alloc] initWithString:hostOnlyURLString];

            [hostOnlyURLString release];

            [download _setOriginatingURL:hostOnlyURL];

            [hostOnlyURL release];

        }

    }

}

bool WebFrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(DocumentLoader* loader, const ResourceRequest& request, const ResourceResponse& response, int length)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (!implementations.didLoadResourceFromMemoryCacheFunc)

        return false;

    CallResourceLoadDelegate(implementations.didLoadResourceFromMemoryCacheFunc, webView, @selector(webView:didLoadResourceFromMemoryCache:response:length:fromDataSource:), request.nsURLRequest(), response.nsURLResponse(), length, dataSource(loader));

    return true;

}

void WebFrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader* loader, const ResourceRequest& request)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    id object = nil;

    BOOL shouldRelease = NO;

    if (implementations.identifierForRequestFunc)

        object = CallResourceLoadDelegate(implementations.identifierForRequestFunc, webView, @selector(webView:identifierForInitialRequest:fromDataSource:), request.nsURLRequest(), dataSource(loader));

    else {

        object = [[NSObject alloc] init];

        shouldRelease = YES;

    }

    [webView _addObject:object forIdentifier:identifier];

    if (shouldRelease)

        [object release];

}

void WebFrameLoaderClient::dispatchWillSendRequest(DocumentLoader* loader, unsigned long identifier, ResourceRequest& request, const ResourceResponse& redirectResponse)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (redirectResponse.isNull())

        static_cast<WebDocumentLoaderMac*>(loader)->increaseLoadCount(identifier);

    if (implementations.willSendRequestFunc)

        request = (NSURLRequest *)CallResourceLoadDelegate(implementations.willSendRequestFunc, webView, @selector(webView:resource:willSendRequest:redirectResponse:fromDataSource:), [webView _objectForIdentifier:identifier], request.nsURLRequest(), redirectResponse.nsURLResponse(), dataSource(loader));

}

void WebFrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(DocumentLoader* loader, unsigned long identifier, const AuthenticationChallenge& challenge)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    NSURLAuthenticationChallenge *webChallenge = mac(challenge);

    if (implementations.didReceiveAuthenticationChallengeFunc) {

        if (id resource = [webView _objectForIdentifier:identifier]) {

            CallResourceLoadDelegate(implementations.didReceiveAuthenticationChallengeFunc, webView, @selector(webView:resource:didReceiveAuthenticationChallenge:fromDataSource:), resource, webChallenge, dataSource(loader));

            return;

        }

    }

    NSWindow *window = [webView hostWindow] ? [webView hostWindow] : [webView window];

    [[WebPanelAuthenticationHandler sharedHandler] startAuthentication:webChallenge window:window];

}

void WebFrameLoaderClient::dispatchDidCancelAuthenticationChallenge(DocumentLoader* loader, unsigned long identifier, const AuthenticationChallenge&challenge)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    NSURLAuthenticationChallenge *webChallenge = mac(challenge);

    if (implementations.didCancelAuthenticationChallengeFunc) {

        if (id resource = [webView _objectForIdentifier:identifier]) {

            CallResourceLoadDelegate(implementations.didCancelAuthenticationChallengeFunc, webView, @selector(webView:resource:didCancelAuthenticationChallenge:fromDataSource:), resource, webChallenge, dataSource(loader));

            return;

        }

    }

    [(WebPanelAuthenticationHandler *)[WebPanelAuthenticationHandler sharedHandler] cancelAuthentication:webChallenge];

}

void WebFrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long identifier, const ResourceResponse& response)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.didReceiveResponseFunc) {

        if (id resource = [webView _objectForIdentifier:identifier])

            CallResourceLoadDelegate(implementations.didReceiveResponseFunc, webView, @selector(webView:resource:didReceiveResponse:fromDataSource:), resource, response.nsURLResponse(), dataSource(loader));

    }

}

NSCachedURLResponse* WebFrameLoaderClient::willCacheResponse(DocumentLoader* loader, unsigned long identifier, NSCachedURLResponse* response) const

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.willCacheResponseFunc) {

        if (id resource = [webView _objectForIdentifier:identifier])

            return CallResourceLoadDelegate(implementations.willCacheResponseFunc, webView, @selector(webView:resource:willCacheResponse:fromDataSource:), resource, response, dataSource(loader));

    }

    return response;

}

void WebFrameLoaderClient::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long identifier, int lengthReceived)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.didReceiveContentLengthFunc) {

        if (id resource = [webView _objectForIdentifier:identifier])

            CallResourceLoadDelegate(implementations.didReceiveContentLengthFunc, webView, @selector(webView:resource:didReceiveContentLength:fromDataSource:), resource, (NSInteger)lengthReceived, dataSource(loader));

    }

}

void WebFrameLoaderClient::dispatchDidFinishLoading(DocumentLoader* loader, unsigned long identifier)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.didFinishLoadingFromDataSourceFunc) {

        if (id resource = [webView _objectForIdentifier:identifier])

            CallResourceLoadDelegate(implementations.didFinishLoadingFromDataSourceFunc, webView, @selector(webView:resource:didFinishLoadingFromDataSource:), resource, dataSource(loader));

    }

    [webView _removeObjectForIdentifier:identifier];

    static_cast<WebDocumentLoaderMac*>(loader)->decreaseLoadCount(identifier);

}

void WebFrameLoaderClient::dispatchDidFailLoading(DocumentLoader* loader, unsigned long identifier, const ResourceError& error)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.didFailLoadingWithErrorFromDataSourceFunc) {

        if (id resource = [webView _objectForIdentifier:identifier])

            CallResourceLoadDelegate(implementations.didFailLoadingWithErrorFromDataSourceFunc, webView, @selector(webView:resource:didFailLoadingWithError:fromDataSource:), resource, (NSError *)error, dataSource(loader));

    }

    [webView _removeObjectForIdentifier:identifier];

    static_cast<WebDocumentLoaderMac*>(loader)->decreaseLoadCount(identifier);

}

void WebFrameLoaderClient::dispatchDidHandleOnloadEvents()

{

    WebView *webView = getWebView(m_webFrame.get());

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.didHandleOnloadEventsForFrameFunc)

        CallFrameLoadDelegate(implementations.didHandleOnloadEventsForFrameFunc, webView, @selector(webView:didHandleOnloadEventsForFrame:), m_webFrame.get());

}

void WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad()

{

    WebView *webView = getWebView(m_webFrame.get());

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.didReceiveServerRedirectForProvisionalLoadForFrameFunc)

        CallFrameLoadDelegate(implementations.didReceiveServerRedirectForProvisionalLoadForFrameFunc, webView, @selector(webView:didHandleOnloadEventsForFrame:), m_webFrame.get());

}

void WebFrameLoaderClient::dispatchDidCancelClientRedirect()

{

    WebView *webView = getWebView(m_webFrame.get());

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.didCancelClientRedirectForFrameFunc)

        CallFrameLoadDelegate(implementations.didCancelClientRedirectForFrameFunc, webView, @selector(webView:didCancelClientRedirectForFrame:), m_webFrame.get());

}

void WebFrameLoaderClient::dispatchWillPerformClientRedirect(const KURL& URL, double delay, double fireDate)

{

    WebView *webView = getWebView(m_webFrame.get());

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.willPerformClientRedirectToURLDelayFireDateForFrameFunc)

        CallFrameLoadDelegate(implementations.willPerformClientRedirectToURLDelayFireDateForFrameFunc, webView, @selector(webView:willPerformClientRedirectToURL:delay:fireDate:forFrame:), URL.getNSURL(), delay, [NSDate dateWithTimeIntervalSince1970:fireDate], m_webFrame.get());

}

void WebFrameLoaderClient::dispatchDidChangeLocationWithinPage()

{

    WebView *webView = getWebView(m_webFrame.get());

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.didChangeLocationWithinPageForFrameFunc)

        CallFrameLoadDelegate(implementations.didChangeLocationWithinPageForFrameFunc, webView, @selector(webView:didChangeLocationWithinPageForFrame:), m_webFrame.get());

}

void WebFrameLoaderClient::dispatchWillClose()

{

    WebView *webView = getWebView(m_webFrame.get());   

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.willCloseFrameFunc)

        CallFrameLoadDelegate(implementations.willCloseFrameFunc, webView, @selector(webView:willCloseFrame:), m_webFrame.get());

}

void WebFrameLoaderClient::dispatchDidReceiveIcon()

{

    ASSERT([m_webFrame.get() _isMainFrame]);

    WebView *webView = getWebView(m_webFrame.get());   

    [webView _dispatchDidReceiveIconFromWebFrame:m_webFrame.get()];

}

void WebFrameLoaderClient::dispatchDidStartProvisionalLoad()

{

    WebView *webView = getWebView(m_webFrame.get());   

    [webView _didStartProvisionalLoadForFrame:m_webFrame.get()];

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.didStartProvisionalLoadForFrameFunc)

        CallFrameLoadDelegate(implementations.didStartProvisionalLoadForFrameFunc, webView, @selector(webView:didStartProvisionalLoadForFrame:), m_webFrame.get());

}

void WebFrameLoaderClient::dispatchDidReceiveTitle(const String& title)

{

    WebView *webView = getWebView(m_webFrame.get());   

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.didReceiveTitleForFrameFunc)

        CallFrameLoadDelegate(implementations.didReceiveTitleForFrameFunc, webView, @selector(webView:didReceiveTitle:forFrame:), (NSString *)title, m_webFrame.get());

}

void WebFrameLoaderClient::dispatchDidCommitLoad()

{

    // Tell the client we've committed this URL.

    ASSERT([m_webFrame->_private->webFrameView documentView] != nil);

    WebView *webView = getWebView(m_webFrame.get());