/*

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

#include "AbstractDatabase.h"

#include "Base64.h"

#include "BarInfo.h"

#include "BeforeUnloadEvent.h"

#include "CSSComputedStyleDeclaration.h"

#include "CSSRuleList.h"

#include "CSSStyleSelector.h"

#include "Chrome.h"

#include "Console.h"

#include "DocumentLoader.h"

#include "DOMApplicationCache.h"

#include "DOMSelection.h"

#include "DOMTimer.h"

#include "Database.h"

#include "DatabaseCallback.h"

#include "DeviceOrientationController.h"

#include "PageTransitionEvent.h"

#include "Document.h"

#include "Element.h"

#include "EventException.h"

#include "EventListener.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HTMLFrameOwnerElement.h"

#include "History.h"

#include "IndexedDatabase.h"

#include "IndexedDatabaseRequest.h"

#include "InspectorController.h"

#include "InspectorTimelineAgent.h"

#include "Location.h"

#include "StyleMedia.h"

#include "MessageEvent.h"

#include "Navigator.h"

#include "NotificationCenter.h"

#include "Page.h"

#include "PageGroup.h"

#include "Performance.h"

#include "PlatformScreen.h"

#include "PlatformString.h"

#include "Screen.h"

#include "SecurityOrigin.h"

#include "SerializedScriptValue.h"

#include "Settings.h"

#include "Storage.h"

#include "StorageArea.h"

#include "StorageNamespace.h"

#include "SuddenTermination.h"

#include "WebKitPoint.h"

#include <algorithm>

#include <wtf/CurrentTime.h>

#include <wtf/MathExtras.h>

#include <wtf/text/CString.h>

using std::min;

using std::max;

namespace WebCore {

class PostMessageTimer : public TimerBase {

public:

    PostMessageTimer(DOMWindow* window, PassRefPtr<SerializedScriptValue> message, const String& sourceOrigin, PassRefPtr<DOMWindow> source, PassOwnPtr<MessagePortChannelArray> channels, SecurityOrigin* targetOrigin)

        : m_window(window)

        , m_message(message)

        , m_origin(sourceOrigin)

        , m_source(source)

        , m_channels(channels)

        , m_targetOrigin(targetOrigin)

    {

    }

    PassRefPtr<MessageEvent> event(ScriptExecutionContext* context)

    {

        OwnPtr<MessagePortArray> messagePorts = MessagePort::entanglePorts(*context, m_channels.release());

        return MessageEvent::create(messagePorts.release(), m_message, m_origin, "", m_source);

    }

    SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }

private:

    virtual void fired()

    {

        m_window->postMessageTimerFired(this);

    }

    RefPtr<DOMWindow> m_window;

    RefPtr<SerializedScriptValue> m_message;

    String m_origin;

    RefPtr<DOMWindow> m_source;

    OwnPtr<MessagePortChannelArray> m_channels;

    RefPtr<SecurityOrigin> m_targetOrigin;

};

typedef HashCountedSet<DOMWindow*> DOMWindowSet;

static DOMWindowSet& windowsWithUnloadEventListeners()

{

    DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithUnloadEventListeners, ());

    return windowsWithUnloadEventListeners;

}

static DOMWindowSet& windowsWithBeforeUnloadEventListeners()

{

    DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithBeforeUnloadEventListeners, ());

    return windowsWithBeforeUnloadEventListeners;

}

static void addUnloadEventListener(DOMWindow* domWindow)

{

    DOMWindowSet& set = windowsWithUnloadEventListeners();

    if (set.isEmpty())

        disableSuddenTermination();

    set.add(domWindow);

}

static void removeUnloadEventListener(DOMWindow* domWindow)

{

    DOMWindowSet& set = windowsWithUnloadEventListeners();

    DOMWindowSet::iterator it = set.find(domWindow);

    if (it == set.end())

        return;

    set.remove(it);

    if (set.isEmpty())

        enableSuddenTermination();

}

static void removeAllUnloadEventListeners(DOMWindow* domWindow)

{

    DOMWindowSet& set = windowsWithUnloadEventListeners();

    DOMWindowSet::iterator it = set.find(domWindow);

    if (it == set.end())

        return;

    set.removeAll(it);

    if (set.isEmpty())

        enableSuddenTermination();

}

static void addBeforeUnloadEventListener(DOMWindow* domWindow)

{

    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();

    if (set.isEmpty())

        disableSuddenTermination();

    set.add(domWindow);

}

static void removeBeforeUnloadEventListener(DOMWindow* domWindow)

{

    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();

    DOMWindowSet::iterator it = set.find(domWindow);

    if (it == set.end())

        return;

    set.remove(it);

    if (set.isEmpty())

        enableSuddenTermination();

}

static void removeAllBeforeUnloadEventListeners(DOMWindow* domWindow)

{

    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();

    DOMWindowSet::iterator it = set.find(domWindow);

    if (it == set.end())

        return;

    set.removeAll(it);

    if (set.isEmpty())

        enableSuddenTermination();

}

static bool allowsBeforeUnloadListeners(DOMWindow* window)

{

    ASSERT_ARG(window, window);

    Frame* frame = window->frame();

    if (!frame)

        return false;

    Page* page = frame->page();

    if (!page)

        return false;

    return frame == page->mainFrame();

}

bool DOMWindow::dispatchAllPendingBeforeUnloadEvents()

{

    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();

    if (set.isEmpty())

        return true;

    static bool alreadyDispatched = false;

    ASSERT(!alreadyDispatched);

    if (alreadyDispatched)

        return true;

    Vector<RefPtr<DOMWindow> > windows;

    DOMWindowSet::iterator end = set.end();

    for (DOMWindowSet::iterator it = set.begin(); it != end; ++it)

        windows.append(it->first);

    size_t size = windows.size();

    for (size_t i = 0; i < size; ++i) {

        DOMWindow* window = windows[i].get();

        if (!set.contains(window))

            continue;

        Frame* frame = window->frame();

        if (!frame)

            continue;

        if (!frame->loader()->shouldClose())

            return false;

    }

    enableSuddenTermination();

    alreadyDispatched = true;

    return true;

}

unsigned DOMWindow::pendingUnloadEventListeners() const

{

    return windowsWithUnloadEventListeners().count(const_cast<DOMWindow*>(this));

}

void DOMWindow::dispatchAllPendingUnloadEvents()

{

    DOMWindowSet& set = windowsWithUnloadEventListeners();

    if (set.isEmpty())

        return;

    static bool alreadyDispatched = false;

    ASSERT(!alreadyDispatched);

    if (alreadyDispatched)

        return;

    Vector<RefPtr<DOMWindow> > windows;

    DOMWindowSet::iterator end = set.end();

    for (DOMWindowSet::iterator it = set.begin(); it != end; ++it)

        windows.append(it->first);

    size_t size = windows.size();

    for (size_t i = 0; i < size; ++i) {

        DOMWindow* window = windows[i].get();

        if (!set.contains(window))

            continue;

        window->dispatchEvent(PageTransitionEvent::create(eventNames().pagehideEvent, false), window->document());

        window->dispatchEvent(Event::create(eventNames().unloadEvent, false, false), window->document());

    }

    enableSuddenTermination();

    alreadyDispatched = true;

}

// This function:

// 1) Validates the pending changes are not changing to NaN

// 2) Constrains the window rect to no smaller than 100 in each dimension and no

//    bigger than the the float rect's dimensions.

// 3) Constrain window rect to within the top and left boundaries of the screen rect

// 4) Constraint the window rect to within the bottom and right boundaries of the

//    screen rect.

// 5) Translate the window rect coordinates to be within the coordinate space of

//    the screen rect.

void DOMWindow::adjustWindowRect(const FloatRect& screen, FloatRect& window, const FloatRect& pendingChanges)

{

    // Make sure we're in a valid state before adjusting dimensions.

    ASSERT(isfinite(screen.x()));

    ASSERT(isfinite(screen.y()));

    ASSERT(isfinite(screen.width()));

    ASSERT(isfinite(screen.height()));

    ASSERT(isfinite(window.x()));

    ASSERT(isfinite(window.y()));

    ASSERT(isfinite(window.width()));

    ASSERT(isfinite(window.height()));

    // Update window values if new requested values are not NaN.

    if (!isnan(pendingChanges.x()))

        window.setX(pendingChanges.x());

    if (!isnan(pendingChanges.y()))

        window.setY(pendingChanges.y());

    if (!isnan(pendingChanges.width()))

        window.setWidth(pendingChanges.width());

    if (!isnan(pendingChanges.height()))

        window.setHeight(pendingChanges.height());

    // Resize the window to between 100 and the screen width and height.

    window.setWidth(min(max(100.0f, window.width()), screen.width()));

    window.setHeight(min(max(100.0f, window.height()), screen.height()));

    // Constrain the window position to the screen.

    window.setX(max(screen.x(), min(window.x(), screen.right() - window.width())));

    window.setY(max(screen.y(), min(window.y(), screen.bottom() - window.height())));

}

void DOMWindow::parseModalDialogFeatures(const String& featuresArg, HashMap<String, String>& map)

{

    Vector<String> features;

    featuresArg.split(';', features);

    Vector<String>::const_iterator end = features.end();

    for (Vector<String>::const_iterator it = features.begin(); it != end; ++it) {

        String s = *it;

        int pos = s.find('=');

        int colonPos = s.find(':');

        if (pos >= 0 && colonPos >= 0)

            continue; // ignore any strings that have both = and :

        if (pos < 0)

            pos = colonPos;

        if (pos < 0) {

            // null string for value means key without value

            map.set(s.stripWhiteSpace().lower(), String());

        } else {

            String key = s.left(pos).stripWhiteSpace().lower();

            String val = s.substring(pos + 1).stripWhiteSpace().lower();

            int spacePos = val.find(' ');

            if (spacePos != -1)

                val = val.left(spacePos);

            map.set(key, val);

        }

    }

}

bool DOMWindow::allowPopUp(Frame* activeFrame)

{

    ASSERT(activeFrame);

    Settings* settings = activeFrame->settings();

    return settings && settings->javaScriptCanOpenWindowsAutomatically();

}

bool DOMWindow::canShowModalDialog(const Frame* frame)

{

    if (!frame)

        return false;

    Page* page = frame->page();

    if (!page)

        return false;

    return page->chrome()->canRunModal();

}

bool DOMWindow::canShowModalDialogNow(const Frame* frame)

{

    if (!frame)

        return false;

    Page* page = frame->page();

    if (!page)

        return false;

    return page->chrome()->canRunModalNow();

}

DOMWindow::DOMWindow(Frame* frame)

    : m_frame(frame)

{

}

DOMWindow::~DOMWindow()

{

    if (m_frame)

        m_frame->clearFormerDOMWindow(this);

    removeAllUnloadEventListeners(this);

    removeAllBeforeUnloadEventListeners(this);

}

ScriptExecutionContext* DOMWindow::scriptExecutionContext() const

{

    return document();

}

void DOMWindow::disconnectFrame()

{

    m_frame = 0;

    clear();

}

void DOMWindow::clear()

{

    if (m_screen)

        m_screen->disconnectFrame();

    m_screen = 0;

    if (m_selection)

        m_selection->disconnectFrame();

    m_selection = 0;

    if (m_history)

        m_history->disconnectFrame();

    m_history = 0;

    if (m_locationbar)

        m_locationbar->disconnectFrame();

    m_locationbar = 0;

    if (m_menubar)

        m_menubar->disconnectFrame();

    m_menubar = 0;

    if (m_personalbar)

        m_personalbar->disconnectFrame();

    m_personalbar = 0;

    if (m_scrollbars)

        m_scrollbars->disconnectFrame();

    m_scrollbars = 0;

    if (m_statusbar)

        m_statusbar->disconnectFrame();

    m_statusbar = 0;

    if (m_toolbar)

        m_toolbar->disconnectFrame();

    m_toolbar = 0;

    if (m_console)

        m_console->disconnectFrame();

    m_console = 0;

    if (m_navigator)

        m_navigator->disconnectFrame();

    m_navigator = 0;

#if ENABLE(WEB_TIMING)

    if (m_performance)

        m_performance->disconnectFrame();

    m_performance = 0;

#endif

    if (m_location)

        m_location->disconnectFrame();

    m_location = 0;

    if (m_media)

        m_media->disconnectFrame();

    m_media = 0;

#if ENABLE(DOM_STORAGE)

    if (m_sessionStorage)

        m_sessionStorage->disconnectFrame();

    m_sessionStorage = 0;

    if (m_localStorage)

        m_localStorage->disconnectFrame();

    m_localStorage = 0;

#endif

#if ENABLE(OFFLINE_WEB_APPLICATIONS)

    if (m_applicationCache)

        m_applicationCache->disconnectFrame();

    m_applicationCache = 0;

#endif

#if ENABLE(NOTIFICATIONS)

    if (m_notifications)

        m_notifications->disconnectFrame();

    m_notifications = 0;

#endif

#if ENABLE(INDEXED_DATABASE)

    m_indexedDatabaseRequest = 0;

#endif

}

#if ENABLE(ORIENTATION_EVENTS)

int DOMWindow::orientation() const

{

    if (!m_frame)

        return 0;

    return m_frame->orientation();

}

#endif

Screen* DOMWindow::screen() const

{

    if (!m_screen)

        m_screen = Screen::create(m_frame);

    return m_screen.get();

}

History* DOMWindow::history() const

{

    if (!m_history)

        m_history = History::create(m_frame);

    return m_history.get();

}

BarInfo* DOMWindow::locationbar() const

{

    if (!m_locationbar)

        m_locationbar = BarInfo::create(m_frame, BarInfo::Locationbar);

    return m_locationbar.get();

}

BarInfo* DOMWindow::menubar() const

{

    if (!m_menubar)

        m_menubar = BarInfo::create(m_frame, BarInfo::Menubar);

    return m_menubar.get();

}

BarInfo* DOMWindow::personalbar() const

{