/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Implementation of WebFrameLoaderClient

*

*/

#include <Browser_platform_variant.hrh>

#include "config.h"

#include <../bidi.h>

#include "WebFrameLoaderClient.h"

#include "ResourceError.h"

#include "DebugStream.h"

#include "DocumentLoader.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "HTMLFrameOwnerElement.h"

#include "HtmlNames.h"

#include "HTMLFrameElement.h"

#include "WebCoreFrameBridge.h"

#include "HTMLFormElement.h"

#include "HTMLObjectElement.h"

#include "FrameView.h"

#include "Document.h"

#include "WebCoreWidget.h"

#include "WebFrame.h"

#include "WebView.h"

#include "WebFrameView.h"

#include "WebFrameBridge.h"

#include "WebDocumentLoader.h"

#include "brctl.h"

#include "page.h"

#include "ProgressTracker.h"

#include "WebPolicyManager.h"

#include "StaticObjectsContainer.h"

#include "ResourceLoaderDelegate.h"

#include "BrCtlWindowObserver.h"

#include "WmlDispatcher.h"

#include "WebUtil.h"

#include "errordefs.h"

#include "WebFepTextEditor.h"

#include "SettingsContainer.h"

#include "WebTabbedNavigation.h"

#include "StaticObjectsContainer.h"

#include "WebCursor.h"

#include "WebCharsetData.h"

#include "WebKitLogger.h"

#include "PluginHandler.h"

#include "MIMETypeRegistry.h"

using namespace WebCore;

using namespace HTMLNames;

// this should be changed if we wanna have a counter per window.

static int total_bytes = 0;

static CBrCtl* brctl(WebFrame* webFrame)

{

    ASSERT(hasWebView());

    ASSERT(hasFrameView());

    return webFrame->frameView()->topView()->brCtl();

}

WebFrameLoaderClient::WebFrameLoaderClient(WebFrame* webFrame)

    : m_webFrame(webFrame)

{

    m_webPolicyManager = new WebPolicyManager(this);

    m_WmlContentListener = 0;

}

WebFrameLoaderClient::~WebFrameLoaderClient()

{

    delete m_webPolicyManager;

    if (m_WmlContentListener) delete m_WmlContentListener;

}

void WebFrameLoaderClient::frameLoaderDestroyed() 

{ 

    delete this;

}

bool WebFrameLoaderClient::hasWebView() const 

{

    return m_webFrame != NULL;; 

}

bool WebFrameLoaderClient::hasFrameView() const 

{

    return m_webFrame->frameView() != NULL; 

}

bool WebFrameLoaderClient::privateBrowsingEnabled() const

{

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

    return false; 

}

void WebFrameLoaderClient::makeDocumentView()

{

    WebFrameView *v = m_webFrame->frameView();

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

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

    //if (!documentView)

    //    return;

    if (m_webFrame && 

        m_webFrame->frameView() && 

        m_webFrame->frameView()->topView()&&

        !m_webFrame->parentFrame()) {

        m_webFrame->frameView()->topView()->setEditable(false);

    }

    WebFrameBridge *bridge = m_webFrame->bridge();

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

    //(MWebCoreWidget* view, int marginWidth, int marginHeight)    

    bridge->createFrameViewWithScrollView(v, v->marginWidth(), v->marginHeight());

    //m_webFrame.get() _updateBackground];

    bridge->installInFrame(v);

    // 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* docLoader)

{

    if (isWMLContent(m_response.mimeType())) {

        // call the WmlDispatcher Headers routine to set the WML flag

        if (! m_WmlContentListener) {

            m_WmlContentListener = CWmlDispatcher::NewL(brctl(m_webFrame), core(m_webFrame) );

            brctl(m_webFrame)->setWmlDispatcher(m_WmlContentListener);

        }

        TRAPD(err,m_WmlContentListener->HeadersL( 0, m_response ));

    }

    else{

        if (m_WmlContentListener) {

            m_WmlContentListener->MakeWmlVisible(EFalse);

        brctl(m_webFrame)->setWmlMode(EFalse);

            brctl(m_webFrame)->MakeVisible(ETrue);

        }

        if (FrameLoadTypeRedirectWithLockedHistory == core(m_webFrame)->loader()->loadType())

            m_webFrame->frameView()->topView()->setRedirectWithLockedHistory(true);

        if (docLoader->isLoadingMainResource()&&

            core(m_webFrame)->loader()->isLoadingMainFrame() &&

            FrameLoadTypeStandard == core(m_webFrame)->loader()->loadType()){

            m_webFrame->frameView()->topView()->resetZoomLevel();

        }

        if (!core(m_webFrame)->ownerElement()) {

            brctl(m_webFrame)->settings()->setTabbedNavigation(!(brctl(m_webFrame)->capabilities()&TBrCtlDefs::ECapabilityCursorNavigation));

            StaticObjectsContainer::instance()->webCursor()->cursorUpdate(true);

            m_webFrame->frameView()->topView()->tabbedNavigation()->clear();

		}        

    }

}

void WebFrameLoaderClient::setDocumentViewFromCachedPage(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];

    */

    notImplemented(); 

}

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];

    */

    if (core(m_webFrame)->document()->isHTMLDocument())

    {

        core(m_webFrame)->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];

    }

    */

    if (core(m_webFrame)->document()->isImageDocument())

    {

        core(m_webFrame)->view()->layout();

    }

}

void WebFrameLoaderClient::setCopiesOnScroll()

{

    m_webFrame->frameView()->setMayUseCopyScroll(true);

}

void WebFrameLoaderClient::detachedFromParent2()

{

    // m_webFrame->_private->inspectors makeObjectsPerformSelector:@selector(_webFrameDetached:) withObject:m_webFrame.get()];

    if (m_webFrame->frameView())

        m_webFrame->frameView()->setWebFrame(NULL);

}

void WebFrameLoaderClient::detachedFromParent3()

{

    m_webFrame->setFrameView(NULL);

}

void WebFrameLoaderClient::detachedFromParent4()

{

    m_webFrame->setBridge(NULL);

}

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]; 

    NSURL *originalURL = nil;

    WebBackForwardList *history = [webView backForwardList];

    WebHistoryItem *currentItem = nil;

    int backListCount = [history backListCount];

    int backCount = 0;

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

    // by the user

    while (backListCount > 0 && !originalURL) {

        currentItem = [history itemAtIndex:backCount--];

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

            originalURL = [currentItem URL];

    }

    if (originalURL && [download respondsToSelector:@selector(_setOriginatingURL:)])

        [download _setOriginatingURL:originalURL];

    */

    StaticObjectsContainer::instance()->resourceLoaderDelegate()->download(handle, request, response);

    brctl(m_webFrame)->HandleBrowserLoadEventL(TBrCtlDefs::EEventNewUrlContentArrived, 0, 0 ); // must send this for progress bar to go away

    brctl(m_webFrame)->HandleBrowserLoadEventL(TBrCtlDefs::EEventUrlLoadingFinished, 0, 0 );

    brctl(m_webFrame)->HandleBrowserLoadEventL(TBrCtlDefs::EEventContentFinished, 0, 0 );

    brctl(m_webFrame)->HandleBrowserLoadEventL(TBrCtlDefs::EEventLoadFinished, 0, 0 );

}

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    id object;

    BOOL shouldRelease = NO;

    if (implementations.delegateImplementsIdentifierForRequest)

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

    else {

        object = [[NSObject alloc] init];

        shouldRelease = YES;

    }

    [webView _addObject:object forIdentifier:identifier];

    if (shouldRelease)

        [object release];

    */

    notImplemented(); 

}

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    */

    if (redirectResponse.isNull())

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

    /*

    if (implementations.delegateImplementsWillSendRequest)

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

    */

}

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

{

    /*

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

    id resourceLoadDelegate = [webView resourceLoadDelegate];

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    NSURLAuthenticationChallenge *webChallenge = mac(challenge);

    if (implementations.delegateImplementsDidReceiveAuthenticationChallenge) {

        [resourceLoadDelegate webView:webView resource:[webView _objectForIdentifier:identifier] didReceiveAuthenticationChallenge:webChallenge fromDataSource:dataSource(loader)];

        return;

    }

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

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

    */

    notImplemented(); 

}

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

{

    /*

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

    id resourceLoadDelegate = [webView resourceLoadDelegate];

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    NSURLAuthenticationChallenge *webChallenge = mac(challenge);

    if (implementations.delegateImplementsDidCancelAuthenticationChallenge) {

        [resourceLoadDelegate webView:webView resource:[webView _objectForIdentifier:identifier] didCancelAuthenticationChallenge:webChallenge fromDataSource:dataSource(loader)];

        return;

    }

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

    */

    notImplemented(); 

}       

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidReceiveResponse)

        implementations.didReceiveResponseFunc(resourceLoadDelegate, @selector(webView:resource:didReceiveResponse:fromDataSource:), webView, [webView _objectForIdentifier:identifier], response.nsURLResponse(), dataSource(loader));

    */

    m_firstData = true;

    m_response = response;

}

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidReceiveContentLength)

        implementations.didReceiveContentLengthFunc(resourceLoadDelegate, @selector(webView:resource:didReceiveContentLength:fromDataSource:), webView, [webView _objectForIdentifier:identifier], (WebNSUInteger)lengthReceived, dataSource(loader));

    */

    // tot:fixme lemgthReceived is actually the content length, not how much was received. The logic has to change

    total_bytes+=lengthReceived;

}

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidFinishLoadingFromDataSource)

        implementations.didFinishLoadingFromDataSourceFunc(resourceLoadDelegate, @selector(webView:resource:didFinishLoadingFromDataSource:), webView, [webView _objectForIdentifier:identifier], dataSource(loader));

    [webView _removeObjectForIdentifier:identifier];

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

    */

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

    notImplemented(); 

}

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidFailLoadingWithErrorFromDataSource)

        implementations.didFailLoadingWithErrorFromDataSourceFunc(resourceLoadDelegate, @selector(webView:resource:didFailLoadingWithError:fromDataSource:), webView, [webView _objectForIdentifier:identifier], error, dataSource(loader));

    [webView _removeObjectForIdentifier:identifier];

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

    */  

    //

    if (brctl(m_webFrame)->wmlMode() && m_WmlContentListener) {

        m_WmlContentListener->HandleError(identifier,error.errorCode());

    }

    //

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

}

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

{

    /*

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

    id resourceLoadDelegate = WebViewGetResourceLoadDelegate(webView);

    WebResourceDelegateImplementationCache implementations = WebViewGetResourceLoadDelegateImplementations(webView);

    if (!implementations.delegateImplementsDidLoadResourceFromMemoryCache)

        return false;

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

    return true;

    */

    notImplemented(); 

    return false; 

}

void WebFrameLoaderClient::dispatchDidHandleOnloadEvents()

{

    /*

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

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidHandleOnloadEventsForFrame) {

        id frameLoadDelegate = WebViewGetFrameLoadDelegate(webView);

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

    }

    */

    notImplemented(); 

}

void WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad()

{

    /*

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

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidReceiveServerRedirectForProvisionalLoadForFrame) {

        id frameLoadDelegate = WebViewGetFrameLoadDelegate(webView);

        implementations.didReceiveServerRedirectForProvisionalLoadForFrameFunc(frameLoadDelegate, @selector(webView:didReceiveServerRedirectForProvisionalLoadForFrame:), webView, m_webFrame.get());

    }

    */

    notImplemented(); 

}

void WebFrameLoaderClient::dispatchDidCancelClientRedirect()

{

    /*

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

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidCancelClientRedirectForFrame) {

        id frameLoadDelegate = WebViewGetFrameLoadDelegate(webView);

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

    }

    */

    notImplemented(); 

}

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

{

    /*

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

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsWillPerformClientRedirectToURLDelayFireDateForFrame) {

        id frameLoadDelegate = WebViewGetFrameLoadDelegate(webView);

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

    }

    */

    notImplemented(); 

}

void WebFrameLoaderClient::dispatchDidChangeLocationWithinPage()

{

    /*

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

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidChangeLocationWithinPageForFrame) {

        id frameLoadDelegate = WebViewGetFrameLoadDelegate(webView);

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

    }

    */

    notImplemented(); 

}

void WebFrameLoaderClient::dispatchWillClose()

{

    /*

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

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsWillCloseFrame) {

        id frameLoadDelegate = WebViewGetFrameLoadDelegate(webView);

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

    }

    */

    notImplemented(); 

}

void WebFrameLoaderClient::dispatchDidReceiveIcon()

{

    /*

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

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

    // FIXME: This willChangeValueForKey call is too late, because the icon has already changed by now.

    [webView _willChangeValueForKey:_WebMainFrameIconKey];

    WebFrameLoadDelegateImplementationCache implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    if (implementations.delegateImplementsDidReceiveIconForFrame) {