/*

 * 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.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 COMPUTER, INC. OR

 * 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. 

 */

#include "config.h"

#include "WebKitDLL.h"

#include "WebFrame.h"

#include "CFDictionaryPropertyBag.h"

#include "COMPtr.h"

#include "DOMCoreClasses.h"

#include "IWebError.h"

#include "IWebErrorPrivate.h"

#include "IWebHistory.h"

#include "IWebHistoryItemPrivate.h"

#include "IWebFrameLoadDelegatePrivate.h"

#include "IWebFormDelegate.h"

#include "IWebUIDelegatePrivate.h"

#include "MarshallingHelpers.h"

#include "WebActionPropertyBag.h"

#include "WebDocumentLoader.h"

#include "WebDownload.h"

#include "WebError.h"

#include "WebMutableURLRequest.h"

#include "WebEditorClient.h"

#include "WebFramePolicyListener.h"

#include "WebHistory.h"

#include "WebKit.h"

#include "WebKitStatisticsPrivate.h"

#include "WebNotificationCenter.h"

#include "WebView.h"

#include "WebDataSource.h"

#include "WebHistoryItem.h"

#include "WebURLAuthenticationChallenge.h"

#include "WebURLResponse.h"

#pragma warning( push, 0 )

#include <WebCore/AuthenticationChallenge.h>

#include <WebCore/BString.h>

#include <WebCore/Cache.h>

#include <WebCore/Document.h>

#include <WebCore/DocumentLoader.h>

#include <WebCore/DOMImplementation.h>

#include <WebCore/DOMWindow.h>

#include <WebCore/Event.h>

#include <WebCore/FormState.h>

#include <WebCore/FrameLoader.h>

#include <WebCore/FrameLoadRequest.h>

#include <WebCore/FrameTree.h>

#include <WebCore/FrameView.h>

#include <WebCore/FrameWin.h>

#include <WebCore/GDIObjectCounter.h>

#include <WebCore/GraphicsContext.h>

#include <WebCore/HistoryItem.h>

#include <WebCore/HTMLFormElement.h>

#include <WebCore/HTMLGenericFormElement.h>

#include <WebCore/HTMLInputElement.h>

#include <WebCore/HTMLNames.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/MouseRelatedEvent.h>

#include <WebCore/NotImplemented.h>

#include <WebCore/Page.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PlugInInfoStore.h>

#include <WebCore/PluginDatabaseWin.h>

#include <WebCore/PluginViewWin.h>

#include <WebCore/ResourceHandle.h>

#include <WebCore/ResourceHandleWin.h>

#include <WebCore/ResourceRequest.h>

#include <WebCore/RenderFrame.h>

#include <WebCore/RenderTreeAsText.h>

#include <WebCore/Settings.h>

#include <WebCore/TextIterator.h>

#include <WebCore/kjs_binding.h>

#include <WebCore/kjs_proxy.h>

#include <WebCore/kjs_window.h>

#include <JavaScriptCore/APICast.h>

#include <wtf/MathExtras.h>

#pragma warning(pop)

#include <CoreGraphics/CoreGraphics.h>

// CG SPI used for printing

extern "C" {

    CGAffineTransform CGContextGetBaseCTM(CGContextRef c); 

    void CGContextSetBaseCTM(CGContextRef c, CGAffineTransform m); 

}

using namespace WebCore;

using namespace HTMLNames;

#define FLASH_REDRAW 0

// By imaging to a width a little wider than the available pixels,

// thin pages will be scaled down a little, matching the way they

// print in IE and Camino. This lets them use fewer sheets than they

// would otherwise, which is presumably why other browsers do this.

// Wide pages will be scaled down more than this.

const float PrintingMinimumShrinkFactor = 1.25f;

// This number determines how small we are willing to reduce the page content

// in order to accommodate the widest line. If the page would have to be

// reduced smaller to make the widest line fit, we just clip instead (this

// behavior matches MacIE and Mozilla, at least)

const float PrintingMaximumShrinkFactor = 2.0f;

// {A3676398-4485-4a9d-87DC-CB5A40E6351D}

const GUID IID_WebFrame = 

{ 0xa3676398, 0x4485, 0x4a9d, { 0x87, 0xdc, 0xcb, 0x5a, 0x40, 0xe6, 0x35, 0x1d } };

//-----------------------------------------------------------------------------

// Helpers to convert from WebCore to WebKit type

WebFrame* kit(Frame* frame)

{

    if (!frame)

        return 0;

    FrameLoaderClient* frameLoaderClient = frame->loader()->client();

    if (frameLoaderClient)

        return static_cast<WebFrame*>(frameLoaderClient);  // eek, is there a better way than static cast?

    return 0;

}

Frame* core(WebFrame* webFrame)

{

    if (!webFrame)

        return 0;

    return webFrame->impl();

}

// This function is not in WebFrame.h because we don't want to advertise the ability to get a non-const Frame from a const WebFrame

Frame* core(const WebFrame* webFrame)

{

    if (!webFrame)

        return 0;

    return const_cast<WebFrame*>(webFrame)->impl();

}

//-----------------------------------------------------------------------------

class FormValuesPropertyBag : public IPropertyBag, public IPropertyBag2

{

public:

    FormValuesPropertyBag(HashMap<String, String>* formValues) : m_formValues(formValues) {}

    // IUnknown

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);

    virtual ULONG STDMETHODCALLTYPE AddRef(void);

    virtual ULONG STDMETHODCALLTYPE Release(void);

    // IPropertyBag

    virtual /* [local] */ HRESULT STDMETHODCALLTYPE Read( 

        /* [in] */ LPCOLESTR pszPropName,

        /* [out][in] */ VARIANT* pVar,

        /* [in] */ IErrorLog* pErrorLog);

    virtual HRESULT STDMETHODCALLTYPE Write( 

        /* [in] */ LPCOLESTR pszPropName,

        /* [in] */ VARIANT* pVar);

    // IPropertyBag2

    virtual HRESULT STDMETHODCALLTYPE Read( 

        /* [in] */ ULONG cProperties,

        /* [in] */ PROPBAG2 *pPropBag,

        /* [in] */ IErrorLog *pErrLog,

        /* [out] */ VARIANT *pvarValue,

        /* [out] */ HRESULT *phrError);

    virtual HRESULT STDMETHODCALLTYPE Write( 

        /* [in] */ ULONG cProperties,

        /* [in] */ PROPBAG2 *pPropBag,

        /* [in] */ VARIANT *pvarValue);

    virtual HRESULT STDMETHODCALLTYPE CountProperties( 

        /* [out] */ ULONG *pcProperties);

    virtual HRESULT STDMETHODCALLTYPE GetPropertyInfo( 

        /* [in] */ ULONG iProperty,

        /* [in] */ ULONG cProperties,

        /* [out] */ PROPBAG2 *pPropBag,

        /* [out] */ ULONG *pcProperties);

    virtual HRESULT STDMETHODCALLTYPE LoadObject( 

        /* [in] */ LPCOLESTR pstrName,

        /* [in] */ DWORD dwHint,

        /* [in] */ IUnknown *pUnkObject,

        /* [in] */ IErrorLog *pErrLog);

protected:

    HashMap<String, String>* m_formValues;

};

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::QueryInterface(REFIID riid, void** ppvObject)

{

    *ppvObject = 0;

    if (IsEqualGUID(riid, IID_IUnknown))

        *ppvObject = this;

    else if (IsEqualGUID(riid, IID_IPropertyBag))

        *ppvObject = static_cast<IPropertyBag*>(this);

    else if (IsEqualGUID(riid, IID_IPropertyBag2))

        *ppvObject = static_cast<IPropertyBag2*>(this);

    else

        return E_NOINTERFACE;

    AddRef();

    return S_OK;

}

ULONG STDMETHODCALLTYPE FormValuesPropertyBag::AddRef(void)

{

    return 1;

}

ULONG STDMETHODCALLTYPE FormValuesPropertyBag::Release(void)

{

    return 0;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::Read(LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* /*pErrorLog*/)

{

    HRESULT hr = S_OK;

    if (!pszPropName || !pVar)

        return E_POINTER;

    String key(pszPropName);

    if (!m_formValues->contains(key))

        return E_INVALIDARG;

    String value = m_formValues->get(key);

    VARTYPE requestedType = V_VT(pVar);

    VariantClear(pVar);

    V_VT(pVar) = VT_BSTR;

    V_BSTR(pVar) = SysAllocStringLen(value.characters(), value.length());

    if (value.length() && !V_BSTR(pVar))

        return E_OUTOFMEMORY;

    if (requestedType != VT_BSTR && requestedType != VT_EMPTY)

        hr = VariantChangeType(pVar, pVar, VARIANT_NOUSEROVERRIDE | VARIANT_ALPHABOOL, requestedType);

    return hr;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::Write(LPCOLESTR pszPropName, VARIANT* pVar)

{

    if (!pszPropName || !pVar)

        return E_POINTER;

    VariantClear(pVar);

    return E_FAIL;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::Read( 

    /* [in] */ ULONG cProperties,

    /* [in] */ PROPBAG2* pPropBag,

    /* [in] */ IErrorLog* pErrLog,

    /* [out] */ VARIANT* pvarValue,

    /* [out] */ HRESULT* phrError)

{

    if (cProperties > (size_t)m_formValues->size())

        return E_INVALIDARG;

    if (!pPropBag || !pvarValue || !phrError)

        return E_POINTER;

    for (ULONG i=0; i<cProperties; i++) {

        VariantInit(&pvarValue[i]);

        phrError[i] = Read(pPropBag->pstrName, &pvarValue[i], pErrLog);

    }

    return S_OK;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::Write( 

    /* [in] */ ULONG /*cProperties*/,

    /* [in] */ PROPBAG2* pPropBag,

    /* [in] */ VARIANT* pvarValue)

{

    if (!pPropBag || !pvarValue)

        return E_POINTER;

    return E_FAIL;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::CountProperties( 

    /* [out] */ ULONG* pcProperties)

{

    *pcProperties = m_formValues->size();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::GetPropertyInfo( 

    /* [in] */ ULONG iProperty,

    /* [in] */ ULONG cProperties,

    /* [out] */ PROPBAG2* pPropBag,

    /* [out] */ ULONG* pcProperties)

{

    if (iProperty > (size_t)m_formValues->size() || iProperty+cProperties > (size_t)m_formValues->size())

        return E_INVALIDARG;

    if (!pPropBag || !pcProperties)

        return E_POINTER;

    *pcProperties = 0;

    ULONG i = 0;

    ULONG endProperty = iProperty + cProperties;

    for (HashMap<String, String>::iterator it = m_formValues->begin(); i<endProperty; i++) {

        if (i >= iProperty) {

            int storeIndex = (*pcProperties)++;

            pPropBag[storeIndex].dwType = PROPBAG2_TYPE_DATA;

            pPropBag[storeIndex].vt = VT_BSTR;

            pPropBag[storeIndex].cfType = CF_TEXT;

            pPropBag[storeIndex].dwHint = 0;

            pPropBag[storeIndex].pstrName = const_cast<LPOLESTR>(it->first.charactersWithNullTermination());

        }

        ++it;

    }

    return S_OK;

}

HRESULT STDMETHODCALLTYPE FormValuesPropertyBag::LoadObject( 

    /* [in] */ LPCOLESTR pstrName,

    /* [in] */ DWORD /*dwHint*/,

    /* [in] */ IUnknown* pUnkObject,

    /* [in] */ IErrorLog* /*pErrLog*/)

{

    if (!pstrName || !pUnkObject)

        return E_POINTER;

    return E_FAIL;

}

//-----------------------------------------------------------------------------

static Element *elementFromDOMElement(IDOMElement *element)

{

    if (!element)

        return 0;

    COMPtr<IDOMElementPrivate> elePriv;

    HRESULT hr = element->QueryInterface(IID_IDOMElementPrivate, (void**) &elePriv);

    if (SUCCEEDED(hr)) {

        Element* ele;

        hr = elePriv->coreElement((void**)&ele);

        if (SUCCEEDED(hr))

            return ele;

    }

    return 0;

}

static HTMLFormElement *formElementFromDOMElement(IDOMElement *element)

{

    if (!element)

        return 0;

    IDOMElementPrivate* elePriv;

    HRESULT hr = element->QueryInterface(IID_IDOMElementPrivate, (void**) &elePriv);

    if (SUCCEEDED(hr)) {

        Element* ele;

        hr = elePriv->coreElement((void**)&ele);

        elePriv->Release();

        if (SUCCEEDED(hr) && ele && ele->hasTagName(formTag))

            return static_cast<HTMLFormElement*>(ele);

    }

    return 0;

}

static HTMLInputElement* inputElementFromDOMElement(IDOMElement* element)

{

    if (!element)

        return 0;

    IDOMElementPrivate* elePriv;

    HRESULT hr = element->QueryInterface(IID_IDOMElementPrivate, (void**) &elePriv);

    if (SUCCEEDED(hr)) {

        Element* ele;

        hr = elePriv->coreElement((void**)&ele);

        elePriv->Release();

        if (SUCCEEDED(hr) && ele && ele->hasTagName(inputTag))

            return static_cast<HTMLInputElement*>(ele);

    }

    return 0;

}

// WebFramePrivate ------------------------------------------------------------

class WebFrame::WebFramePrivate {

public:

    WebFramePrivate() 

        : frame(0)

        , webView(0)

        , m_policyFunction(0)

        , m_pluginView(0) 

        , m_hasSentResponseToPlugin(false) 

    { 

    }

    ~WebFramePrivate() { }

    FrameView* frameView() { return frame ? frame->view() : 0; }

    Frame* frame;

    WebView* webView;

    FramePolicyFunction m_policyFunction;

    COMPtr<WebFramePolicyListener> m_policyListener;

    // Points to the plugin view that data should be redirected to.

    PluginViewWin* m_pluginView;

    bool m_hasSentResponseToPlugin;

};

// WebFrame ----------------------------------------------------------------

WebFrame::WebFrame()

: m_refCount(0)

, d(new WebFrame::WebFramePrivate)

, m_quickRedirectComing(false)

, m_inPrintingMode(false)

, m_pageHeight(0)

{

    WebFrameCount++;

    gClassCount++;

}

WebFrame::~WebFrame()

{

    delete d;

    WebFrameCount--;

    gClassCount--;

}

WebFrame* WebFrame::createInstance()

{

    WebFrame* instance = new WebFrame();

    instance->AddRef();

    return instance;

}

HRESULT STDMETHODCALLTYPE WebFrame::setAllowsScrolling(

    /* [in] */ BOOL flag)

{

    if (Frame* frame = core(this))

        if (FrameView* view = frame->view())

            view->setAllowsScrolling(!!flag);

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebFrame::allowsScrolling(

    /* [retval][out] */ BOOL *flag)

{

    if (flag)

        if (Frame* frame = core(this))

            if (FrameView* view = frame->view())

                *flag = view->allowsScrolling();

    return S_OK;

}

// IUnknown -------------------------------------------------------------------

HRESULT STDMETHODCALLTYPE WebFrame::QueryInterface(REFIID riid, void** ppvObject)

{

    *ppvObject = 0;

    if (IsEqualGUID(riid, IID_WebFrame))

        *ppvObject = this;

    else if (IsEqualGUID(riid, IID_IUnknown))

        *ppvObject = static_cast<IWebFrame*>(this);

    else if (IsEqualGUID(riid, IID_IWebFrame))

        *ppvObject = static_cast<IWebFrame*>(this);

    else if (IsEqualGUID(riid, IID_IWebFramePrivate))

        *ppvObject = static_cast<IWebFramePrivate*>(this);

    else

        return E_NOINTERFACE;

    AddRef();

    return S_OK;

}

ULONG STDMETHODCALLTYPE WebFrame::AddRef(void)

{

    return ++m_refCount;

}

ULONG STDMETHODCALLTYPE WebFrame::Release(void)

{

    ULONG newRef = --m_refCount;

    if (!newRef)

        delete(this);

    return newRef;

}

// IWebFrame -------------------------------------------------------------------

HRESULT STDMETHODCALLTYPE WebFrame::name( 

    /* [retval][out] */ BSTR* frameName)

{

    if (!frameName) {

        ASSERT_NOT_REACHED();

        return E_POINTER;

    }

    *frameName = 0;

    Frame* coreFrame = core(this);

    if (!coreFrame)