/*

 * Copyright (C) 2006, 2007, 2008, 2009, 2010 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 "WebView.h"

#include "CFDictionaryPropertyBag.h"

#include "DOMCoreClasses.h"

#include "FullscreenVideoController.h"

#include "MarshallingHelpers.h"

#include "SoftLinking.h"

#include "WebBackForwardList.h"

#include "WebChromeClient.h"

#include "WebContextMenuClient.h"

#include "WebCoreTextRenderer.h"

#include "WebDatabaseManager.h"

#include "WebDocumentLoader.h"

#include "WebDownload.h"

#include "WebDragClient.h"

#include "WebEditorClient.h"

#include "WebElementPropertyBag.h"

#include "WebFrame.h"

#include "WebGeolocationControllerClient.h"

#include "WebGeolocationPosition.h"

#include "WebIconDatabase.h"

#include "WebInspector.h"

#include "WebInspectorClient.h"

#include "WebKit.h"

#include "WebKitDLL.h"

#include "WebKitLogging.h"

#include "WebKitStatisticsPrivate.h"

#include "WebKitSystemBits.h"

#include "WebMutableURLRequest.h"

#include "WebNotificationCenter.h"

#include "WebPluginHalterClient.h"

#include "WebPreferences.h"

#include "WebScriptWorld.h"

#include "WindowsTouch.h"

#include <JavaScriptCore/APICast.h>

#include <JavaScriptCore/InitializeThreading.h>

#include <JavaScriptCore/JSLock.h>

#include <JavaScriptCore/JSValue.h>

#include <WebCore/AbstractDatabase.h>

#include <WebCore/AXObjectCache.h>

#include <WebCore/ApplicationCacheStorage.h>

#include <WebCore/BString.h>

#include <WebCore/BackForwardList.h>

#include <WebCore/BitmapInfo.h>

#include <WebCore/Cache.h>

#include <WebCore/Chrome.h>

#include <WebCore/ContextMenu.h>

#include <WebCore/ContextMenuController.h>

#include <WebCore/CookieStorageWin.h>

#include <WebCore/Cursor.h>

#include <WebCore/Document.h>

#include <WebCore/DragController.h>

#include <WebCore/DragData.h>

#include <WebCore/Editor.h>

#include <WebCore/EventHandler.h>

#include <WebCore/EventNames.h>

#include <WebCore/FileSystem.h>

#include <WebCore/FloatQuad.h>

#include <WebCore/FocusController.h>

#include <WebCore/FrameLoader.h>

#include <WebCore/FrameTree.h>

#include <WebCore/FrameView.h>

#include <WebCore/FrameWin.h>

#include <WebCore/GDIObjectCounter.h>

#include <WebCore/GraphicsContext.h>

#include <WebCore/HTMLMediaElement.h>

#include <WebCore/HTMLNames.h>

#include <WebCore/HistoryItem.h>

#include <WebCore/HitTestRequest.h>

#include <WebCore/HitTestResult.h>

#include <WebCore/IntRect.h>

#include <WebCore/JSElement.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/Language.h>

#include <WebCore/Logging.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/Page.h>

#include <WebCore/PageCache.h>

#include <WebCore/PageGroup.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PlatformMouseEvent.h>

#include <WebCore/PlatformWheelEvent.h>

#include <WebCore/PluginData.h>

#include <WebCore/PluginDatabase.h>

#include <WebCore/PluginView.h>

#include <WebCore/PopupMenu.h>

#include <WebCore/ProgressTracker.h>

#include <WebCore/RenderLayer.h>

#include <WebCore/RenderTheme.h>

#include <WebCore/RenderTreeAsText.h>

#include <WebCore/RenderView.h>

#include <WebCore/RenderWidget.h>

#include <WebCore/ResourceHandle.h>

#include <WebCore/ResourceHandleClient.h>

#include <WebCore/SchemeRegistry.h>

#include <WebCore/ScriptValue.h>

#include <WebCore/Scrollbar.h>

#include <WebCore/ScrollbarTheme.h>

#include <WebCore/SecurityOrigin.h>

#include <WebCore/SelectionController.h>

#include <WebCore/Settings.h>

#include <WebCore/SimpleFontData.h>

#include <WebCore/TypingCommand.h>

#include <WebCore/WindowMessageBroadcaster.h>

#include <wtf/Threading.h>

#if ENABLE(CLIENT_BASED_GEOLOCATION)

#include <WebCore/GeolocationController.h>

#include <WebCore/GeolocationError.h>

#endif

#if PLATFORM(CG)

#include <CoreGraphics/CGContext.h>

#endif

#if PLATFORM(CF)

#include <CoreFoundation/CoreFoundation.h>

#endif

#if USE(CFNETWORK)

#include <CFNetwork/CFURLCachePriv.h>

#include <CFNetwork/CFURLProtocolPriv.h>

#include <WebKitSystemInterface/WebKitSystemInterface.h> 

#endif

#include <ShlObj.h>

#include <comutil.h>

#include <dimm.h>

#include <oleacc.h>

#include <tchar.h>

#include <windowsx.h>

#include <wtf/HashSet.h>

#include <wtf/text/CString.h>

// Soft link functions for gestures and panning feedback

SOFT_LINK_LIBRARY(USER32);

SOFT_LINK_OPTIONAL(USER32, GetGestureInfo, BOOL, WINAPI, (HGESTUREINFO, PGESTUREINFO));

SOFT_LINK_OPTIONAL(USER32, SetGestureConfig, BOOL, WINAPI, (HWND, DWORD, UINT, PGESTURECONFIG, UINT));

SOFT_LINK_OPTIONAL(USER32, CloseGestureInfoHandle, BOOL, WINAPI, (HGESTUREINFO));

SOFT_LINK_LIBRARY(Uxtheme);

SOFT_LINK_OPTIONAL(Uxtheme, BeginPanningFeedback, BOOL, WINAPI, (HWND));

SOFT_LINK_OPTIONAL(Uxtheme, EndPanningFeedback, BOOL, WINAPI, (HWND, BOOL));

SOFT_LINK_OPTIONAL(Uxtheme, UpdatePanningFeedback, BOOL, WINAPI, (HWND, LONG, LONG, BOOL));

using namespace WebCore;

using namespace std;

using JSC::JSLock;

static HMODULE accessibilityLib;

static HashSet<WebView*> pendingDeleteBackingStoreSet;

static String osVersion();

static String webKitVersion();

WebView* kit(Page* page)

{

    return page ? static_cast<WebChromeClient*>(page->chrome()->client())->webView() : 0;

}

class PreferencesChangedOrRemovedObserver : public IWebNotificationObserver {

public:

    static PreferencesChangedOrRemovedObserver* sharedInstance();

private:

    PreferencesChangedOrRemovedObserver() {}

    ~PreferencesChangedOrRemovedObserver() {}

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID, void**) { return E_FAIL; }

    virtual ULONG STDMETHODCALLTYPE AddRef(void) { return 0; }

    virtual ULONG STDMETHODCALLTYPE Release(void) { return 0; }

public:

    // IWebNotificationObserver

    virtual HRESULT STDMETHODCALLTYPE onNotify( 

        /* [in] */ IWebNotification* notification);

private:

    HRESULT notifyPreferencesChanged(WebCacheModel);

    HRESULT notifyPreferencesRemoved(WebCacheModel);

};

PreferencesChangedOrRemovedObserver* PreferencesChangedOrRemovedObserver::sharedInstance()

{

    static PreferencesChangedOrRemovedObserver* shared = new PreferencesChangedOrRemovedObserver;

    return shared;

}

HRESULT PreferencesChangedOrRemovedObserver::onNotify(IWebNotification* notification)

{

    HRESULT hr = S_OK;

    COMPtr<IUnknown> unkPrefs;

    hr = notification->getObject(&unkPrefs);

    if (FAILED(hr))

        return hr;

    COMPtr<IWebPreferences> preferences(Query, unkPrefs);

    if (!preferences)

        return E_NOINTERFACE;

    WebCacheModel cacheModel;

    hr = preferences->cacheModel(&cacheModel);

    if (FAILED(hr))

        return hr;

    BSTR nameBSTR;

    hr = notification->name(&nameBSTR);

    if (FAILED(hr))

        return hr;

    BString name;

    name.adoptBSTR(nameBSTR);

    if (wcscmp(name, WebPreferences::webPreferencesChangedNotification()) == 0)

        return notifyPreferencesChanged(cacheModel);

    if (wcscmp(name, WebPreferences::webPreferencesRemovedNotification()) == 0)

        return notifyPreferencesRemoved(cacheModel);

    ASSERT_NOT_REACHED();

    return E_FAIL;

}

HRESULT PreferencesChangedOrRemovedObserver::notifyPreferencesChanged(WebCacheModel cacheModel)

{

    HRESULT hr = S_OK;

    if (!WebView::didSetCacheModel() || cacheModel > WebView::cacheModel())

        WebView::setCacheModel(cacheModel);

    else if (cacheModel < WebView::cacheModel()) {

        WebCacheModel sharedPreferencesCacheModel;

        hr = WebPreferences::sharedStandardPreferences()->cacheModel(&sharedPreferencesCacheModel);

        if (FAILED(hr))

            return hr;

        WebView::setCacheModel(max(sharedPreferencesCacheModel, WebView::maxCacheModelInAnyInstance()));

    }

    return hr;

}

HRESULT PreferencesChangedOrRemovedObserver::notifyPreferencesRemoved(WebCacheModel cacheModel)

{

    HRESULT hr = S_OK;

    if (cacheModel == WebView::cacheModel()) {

        WebCacheModel sharedPreferencesCacheModel;

        hr = WebPreferences::sharedStandardPreferences()->cacheModel(&sharedPreferencesCacheModel);

        if (FAILED(hr))

            return hr;

        WebView::setCacheModel(max(sharedPreferencesCacheModel, WebView::maxCacheModelInAnyInstance()));

    }

    return hr;

}

const LPCWSTR kWebViewWindowClassName = L"WebViewWindowClass";

const int WM_XP_THEMECHANGED = 0x031A;

const int WM_VISTA_MOUSEHWHEEL = 0x020E;

static const int maxToolTipWidth = 250;

static const int delayBeforeDeletingBackingStoreMsec = 5000;

static ATOM registerWebView();

static void initializeStaticObservers();

static HRESULT updateSharedSettingsFromPreferencesIfNeeded(IWebPreferences*);

HRESULT createMatchEnumerator(Vector<IntRect>* rects, IEnumTextMatches** matches);

static bool continuousSpellCheckingEnabled;

static bool grammarCheckingEnabled;

static bool s_didSetCacheModel;

static WebCacheModel s_cacheModel = WebCacheModelDocumentViewer;

enum {

    UpdateActiveStateTimer = 1,

    DeleteBackingStoreTimer = 2,

};

// WebView ----------------------------------------------------------------

bool WebView::s_allowSiteSpecificHacks = false;

WebView::WebView()

    : m_refCount(0)

#if !ASSERT_DISABLED

    , m_deletionHasBegun(false)

#endif

    , m_hostWindow(0)

    , m_viewWindow(0)

    , m_mainFrame(0)

    , m_page(0)

    , m_hasCustomDropTarget(false)

    , m_useBackForwardList(true)

    , m_userAgentOverridden(false)

    , m_zoomMultiplier(1.0f)

    , m_mouseActivated(false)

    , m_dragData(0)

    , m_currentCharacterCode(0)

    , m_isBeingDestroyed(false)

    , m_paintCount(0)

    , m_hasSpellCheckerDocumentTag(false)

    , m_smartInsertDeleteEnabled(false)

    , m_didClose(false)

    , m_inIMEComposition(0)

    , m_toolTipHwnd(0)

    , m_closeWindowTimer(0)

    , m_topLevelParent(0)

    , m_deleteBackingStoreTimerActive(false)

    , m_transparent(false)

    , m_selectTrailingWhitespaceEnabled(false)

    , m_lastPanX(0)

    , m_lastPanY(0)

    , m_xOverpan(0)

    , m_yOverpan(0)

#if USE(ACCELERATED_COMPOSITING)

    , m_isAcceleratedCompositing(false)

#endif

    , m_nextDisplayIsSynchronous(false)

    , m_lastSetCursor(0)

{

    JSC::initializeThreading();

    WTF::initializeMainThread();

    m_backingStoreSize.cx = m_backingStoreSize.cy = 0;

    CoCreateInstance(CLSID_DragDropHelper, 0, CLSCTX_INPROC_SERVER, IID_IDropTargetHelper,(void**)&m_dropTargetHelper);

    initializeStaticObservers();

    WebPreferences* sharedPreferences = WebPreferences::sharedStandardPreferences();

    BOOL enabled;

    if (SUCCEEDED(sharedPreferences->continuousSpellCheckingEnabled(&enabled)))

        continuousSpellCheckingEnabled = !!enabled;

    if (SUCCEEDED(sharedPreferences->grammarCheckingEnabled(&enabled)))

        grammarCheckingEnabled = !!enabled;

    WebViewCount++;

    gClassCount++;

    gClassNameCount.add("WebView");

}

WebView::~WebView()

{

    deleteBackingStore();

    // the tooltip window needs to be explicitly destroyed since it isn't a WS_CHILD

    if (::IsWindow(m_toolTipHwnd))

        ::DestroyWindow(m_toolTipHwnd);

    ASSERT(!m_page);

    ASSERT(!m_preferences);

    ASSERT(!m_viewWindow);

    WebViewCount--;

    gClassCount--;

    gClassNameCount.remove("WebView");

}

WebView* WebView::createInstance()

{

    WebView* instance = new WebView();

    instance->AddRef();

    return instance;

}

void initializeStaticObservers()

{

    static bool initialized;

    if (initialized)

        return;

    initialized = true;

    IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();

    notifyCenter->addObserver(PreferencesChangedOrRemovedObserver::sharedInstance(), WebPreferences::webPreferencesChangedNotification(), 0);

    notifyCenter->addObserver(PreferencesChangedOrRemovedObserver::sharedInstance(), WebPreferences::webPreferencesRemovedNotification(), 0);

}

static HashSet<WebView*>& allWebViewsSet()

{

    static HashSet<WebView*> allWebViewsSet;

    return allWebViewsSet;

}

void WebView::addToAllWebViewsSet()

{

    allWebViewsSet().add(this);

}

void WebView::removeFromAllWebViewsSet()

{

    allWebViewsSet().remove(this);

}

void WebView::setCacheModel(WebCacheModel cacheModel)

{

#if USE(CFNETWORK)

    if (s_didSetCacheModel && cacheModel == s_cacheModel)

        return;

    RetainPtr<CFURLCacheRef> cfurlCache(AdoptCF, CFURLCacheCopySharedURLCache());

    RetainPtr<CFStringRef> cfurlCacheDirectory(AdoptCF, wkCopyFoundationCacheDirectory());

    if (!cfurlCacheDirectory)

        cfurlCacheDirectory.adoptCF(WebCore::localUserSpecificStorageDirectory().createCFString());

    // As a fudge factor, use 1000 instead of 1024, in case the reported byte 

    // count doesn't align exactly to a megabyte boundary.

    unsigned long long memSize = WebMemorySize() / 1024 / 1000;

    unsigned long long diskFreeSize = WebVolumeFreeSize(cfurlCacheDirectory.get()) / 1024 / 1000;

    unsigned cacheTotalCapacity = 0;

    unsigned cacheMinDeadCapacity = 0;

    unsigned cacheMaxDeadCapacity = 0;

    double deadDecodedDataDeletionInterval = 0;

    unsigned pageCacheCapacity = 0;

    CFIndex cfurlCacheMemoryCapacity = 0;

    CFIndex cfurlCacheDiskCapacity = 0;

    switch (cacheModel) {

    case WebCacheModelDocumentViewer: {

        // Page cache capacity (in pages)

        pageCacheCapacity = 0;

        // Object cache capacities (in bytes)

        if (memSize >= 2048)

            cacheTotalCapacity = 96 * 1024 * 1024;

        else if (memSize >= 1536)

            cacheTotalCapacity = 64 * 1024 * 1024;

        else if (memSize >= 1024)

            cacheTotalCapacity = 32 * 1024 * 1024;

        else if (memSize >= 512)

            cacheTotalCapacity = 16 * 1024 * 1024; 

        cacheMinDeadCapacity = 0;

        cacheMaxDeadCapacity = 0;

        // Foundation memory cache capacity (in bytes)

        cfurlCacheMemoryCapacity = 0;

        // Foundation disk cache capacity (in bytes)

        cfurlCacheDiskCapacity = CFURLCacheDiskCapacity(cfurlCache.get());

        break;

    }

    case WebCacheModelDocumentBrowser: {

        // Page cache capacity (in pages)

        if (memSize >= 1024)

            pageCacheCapacity = 3;

        else if (memSize >= 512)

            pageCacheCapacity = 2;

        else if (memSize >= 256)

            pageCacheCapacity = 1;

        else

            pageCacheCapacity = 0;

        // Object cache capacities (in bytes)

        if (memSize >= 2048)

            cacheTotalCapacity = 96 * 1024 * 1024;

        else if (memSize >= 1536)

            cacheTotalCapacity = 64 * 1024 * 1024;

        else if (memSize >= 1024)

            cacheTotalCapacity = 32 * 1024 * 1024;

        else if (memSize >= 512)

            cacheTotalCapacity = 16 * 1024 * 1024; 

        cacheMinDeadCapacity = cacheTotalCapacity / 8;

        cacheMaxDeadCapacity = cacheTotalCapacity / 4;

        // Foundation memory cache capacity (in bytes)

        if (memSize >= 2048)

            cfurlCacheMemoryCapacity = 4 * 1024 * 1024;

        else if (memSize >= 1024)

            cfurlCacheMemoryCapacity = 2 * 1024 * 1024;

        else if (memSize >= 512)

            cfurlCacheMemoryCapacity = 1 * 1024 * 1024;

        else

            cfurlCacheMemoryCapacity =      512 * 1024; 

        // Foundation disk cache capacity (in bytes)

        if (diskFreeSize >= 16384)

            cfurlCacheDiskCapacity = 50 * 1024 * 1024;

        else if (diskFreeSize >= 8192)

            cfurlCacheDiskCapacity = 40 * 1024 * 1024;

        else if (diskFreeSize >= 4096)

            cfurlCacheDiskCapacity = 30 * 1024 * 1024;

        else

            cfurlCacheDiskCapacity = 20 * 1024 * 1024;

        break;

    }

    case WebCacheModelPrimaryWebBrowser: {

        // Page cache capacity (in pages)

        // (Research indicates that value / page drops substantially after 3 pages.)

        if (memSize >= 2048)

            pageCacheCapacity = 5;

        else if (memSize >= 1024)