/*

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

 * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>

 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)

 * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/

 *

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

 */

#include "config.h"

#include "DumpRenderTreeQt.h"

#include "../../../WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h"

#include "EventSenderQt.h"

#include "GCControllerQt.h"

#include "LayoutTestControllerQt.h"

#include "TextInputControllerQt.h"

#include "testplugin.h"

#include "WorkQueue.h"

#include <QApplication>

#include <QBuffer>

#include <QCryptographicHash>

#include <QDir>

#include <QFile>

#include <QFileInfo>

#include <QFocusEvent>

#include <QFontDatabase>

#include <QLocale>

#include <QNetworkAccessManager>

#include <QNetworkReply>

#include <QNetworkRequest>

#include <QPaintDevice>

#include <QPaintEngine>

#ifndef QT_NO_PRINTER

#include <QPrinter>

#endif

#include <QUndoStack>

#include <QUrl>

#include <qwebsettings.h>

#include <qwebsecurityorigin.h>

#ifndef QT_NO_UITOOLS

#include <QtUiTools/QUiLoader>

#endif

#ifdef Q_WS_X11

#include <fontconfig/fontconfig.h>

#endif

#include <limits.h>

#include <locale.h>

#ifndef Q_OS_WIN

#include <unistd.h>

#endif

#include <qdebug.h>

namespace WebCore {

NetworkAccessManager::NetworkAccessManager(QObject* parent)

    : QNetworkAccessManager(parent)

{

#ifndef QT_NO_OPENSSL

    connect(this, SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)),

            this, SLOT(sslErrorsEncountered(QNetworkReply*, const QList<QSslError>&)));

#endif

}

#ifndef QT_NO_OPENSSL

void NetworkAccessManager::sslErrorsEncountered(QNetworkReply* reply, const QList<QSslError>& errors)

{

    if (reply->url().host() == "127.0.0.1" || reply->url().host() == "localhost") {

        bool ignore = true;

        // Accept any HTTPS certificate.

        foreach (const QSslError& error, errors) {

            if (error.error() < QSslError::UnableToGetIssuerCertificate || error.error() > QSslError::HostNameMismatch) {

                ignore = false;

                break;

            }

        }

        if (ignore)

            reply->ignoreSslErrors();

    }

}

#endif

#ifndef QT_NO_PRINTER

class NullPrinter : public QPrinter {

public:

    class NullPaintEngine : public QPaintEngine {

    public:

        virtual bool begin(QPaintDevice*) { return true; }

        virtual bool end() { return true; }

        virtual QPaintEngine::Type type() const { return QPaintEngine::User; }

        virtual void drawPixmap(const QRectF& r, const QPixmap& pm, const QRectF& sr) { }

        virtual void updateState(const QPaintEngineState& state) { }

    };

    virtual QPaintEngine* paintEngine() const { return const_cast<NullPaintEngine*>(&m_engine); }

    NullPaintEngine m_engine;

};

#endif

WebPage::WebPage(QObject* parent, DumpRenderTree* drt)

    : QWebPage(parent)

    , m_webInspector(0)

    , m_drt(drt)

{

    QWebSettings* globalSettings = QWebSettings::globalSettings();

    globalSettings->setFontSize(QWebSettings::MinimumFontSize, 5);

    globalSettings->setFontSize(QWebSettings::MinimumLogicalFontSize, 5);

    globalSettings->setFontSize(QWebSettings::DefaultFontSize, 16);

    globalSettings->setFontSize(QWebSettings::DefaultFixedFontSize, 13);

    globalSettings->setAttribute(QWebSettings::JavascriptCanOpenWindows, true);

    globalSettings->setAttribute(QWebSettings::JavascriptCanAccessClipboard, true);

    globalSettings->setAttribute(QWebSettings::LinksIncludedInFocusChain, false);

    globalSettings->setAttribute(QWebSettings::PluginsEnabled, true);

    globalSettings->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, true);

    globalSettings->setAttribute(QWebSettings::JavascriptEnabled, true);

    globalSettings->setAttribute(QWebSettings::PrivateBrowsingEnabled, false);

    globalSettings->setAttribute(QWebSettings::SpatialNavigationEnabled, false);

    connect(this, SIGNAL(geometryChangeRequested(const QRect &)),

            this, SLOT(setViewGeometry(const QRect & )));

    setNetworkAccessManager(m_drt->networkAccessManager());

    setPluginFactory(new TestPlugin(this));

    connect(this, SIGNAL(requestPermissionFromUser(QWebFrame*, QWebPage::PermissionDomain)), this, SLOT(requestPermission(QWebFrame*, QWebPage::PermissionDomain)));

    connect(this, SIGNAL(checkPermissionFromUser(QWebFrame*, QWebPage::PermissionDomain, QWebPage::PermissionPolicy&)), this, SLOT(checkPermission(QWebFrame*, QWebPage::PermissionDomain, QWebPage::PermissionPolicy&)));

    connect(this, SIGNAL(cancelRequestsForPermissionFromUser(QWebFrame*, QWebPage::PermissionDomain)), this, SLOT(cancelRequestsForPermissionFromUser(QWebFrame*, QWebPage::PermissionDomain)));

}

WebPage::~WebPage()

{

    delete m_webInspector;

}

QWebInspector* WebPage::webInspector()

{

    if (!m_webInspector) {

        m_webInspector = new QWebInspector;

        m_webInspector->setPage(this);

    }

    return m_webInspector;

}

void WebPage::resetSettings()

{

    // After each layout test, reset the settings that may have been changed by

    // layoutTestController.overridePreference() or similar.

    settings()->resetFontSize(QWebSettings::DefaultFontSize);

    settings()->resetAttribute(QWebSettings::JavascriptCanOpenWindows);

    settings()->resetAttribute(QWebSettings::JavascriptEnabled);

    settings()->resetAttribute(QWebSettings::PrivateBrowsingEnabled);

    settings()->resetAttribute(QWebSettings::SpatialNavigationEnabled);

    settings()->resetAttribute(QWebSettings::LinksIncludedInFocusChain);

    settings()->resetAttribute(QWebSettings::OfflineWebApplicationCacheEnabled);

    settings()->resetAttribute(QWebSettings::LocalContentCanAccessRemoteUrls);

    settings()->resetAttribute(QWebSettings::PluginsEnabled);

    settings()->resetAttribute(QWebSettings::JavascriptCanAccessClipboard);

    settings()->resetAttribute(QWebSettings::AutoLoadImages);

    m_drt->layoutTestController()->setCaretBrowsingEnabled(false);

    m_drt->layoutTestController()->setFrameFlatteningEnabled(false);

    m_drt->layoutTestController()->setSmartInsertDeleteEnabled(true);

    m_drt->layoutTestController()->setSelectTrailingWhitespaceEnabled(false);

    // globalSettings must be reset explicitly.

    m_drt->layoutTestController()->setXSSAuditorEnabled(false);

    QWebSettings::setMaximumPagesInCache(0); // reset to default

    settings()->setUserStyleSheetUrl(QUrl()); // reset to default

}

QWebPage *WebPage::createWindow(QWebPage::WebWindowType)

{

    return m_drt->createWindow();

}

void WebPage::javaScriptAlert(QWebFrame*, const QString& message)

{

    if (!isTextOutputEnabled())

        return;

    fprintf(stdout, "ALERT: %s\n", message.toUtf8().constData());

}

void WebPage::requestPermission(QWebFrame* frame, QWebPage::PermissionDomain domain)

{

    switch (domain) {

    case NotificationsPermissionDomain:

        if (!m_drt->layoutTestController()->ignoreReqestForPermission())

            setUserPermission(frame, domain, PermissionGranted);

        break;

    default:

        break;

    }

}

void WebPage::checkPermission(QWebFrame* frame, QWebPage::PermissionDomain domain, QWebPage::PermissionPolicy& policy)

{

    switch (domain) {

    case NotificationsPermissionDomain:

        {

        QUrl url = frame->url();

        policy = m_drt->layoutTestController()->checkDesktopNotificationPermission(url.scheme() + "://" + url.host()) ? PermissionGranted : PermissionDenied;

        break;

        }

    default:

        break;

    }

}

void WebPage::cancelRequestsForPermission(QWebFrame*, QWebPage::PermissionDomain)

{

}

static QString urlSuitableForTestResult(const QString& url)

{

    if (url.isEmpty() || !url.startsWith(QLatin1String("file://")))

        return url;

    return QFileInfo(url).fileName();

}

void WebPage::javaScriptConsoleMessage(const QString& message, int lineNumber, const QString&)

{

    if (!isTextOutputEnabled())

        return;

    QString newMessage;

    if (!message.isEmpty()) {

        newMessage = message;

        size_t fileProtocol = newMessage.indexOf(QLatin1String("file://"));

        if (fileProtocol != -1) {

            newMessage = newMessage.left(fileProtocol) + urlSuitableForTestResult(newMessage.mid(fileProtocol));

        }

    }

    fprintf (stdout, "CONSOLE MESSAGE: line %d: %s\n", lineNumber, newMessage.toUtf8().constData());

}

bool WebPage::javaScriptConfirm(QWebFrame*, const QString& msg)

{

    if (!isTextOutputEnabled())

        return true;

    fprintf(stdout, "CONFIRM: %s\n", msg.toUtf8().constData());

    return true;

}

bool WebPage::javaScriptPrompt(QWebFrame*, const QString& msg, const QString& defaultValue, QString* result)

{

    if (!isTextOutputEnabled())

        return true;

    fprintf(stdout, "PROMPT: %s, default text: %s\n", msg.toUtf8().constData(), defaultValue.toUtf8().constData());

    *result = defaultValue;

    return true;

}

bool WebPage::acceptNavigationRequest(QWebFrame* frame, const QNetworkRequest& request, NavigationType type)

{

    if (m_drt->layoutTestController()->waitForPolicy()) {

        QString url = QString::fromUtf8(request.url().toEncoded());

        QString typeDescription;

        switch (type) {

        case NavigationTypeLinkClicked:

            typeDescription = "link clicked";

            break;

        case NavigationTypeFormSubmitted:

            typeDescription = "form submitted";

            break;

        case NavigationTypeBackOrForward:

            typeDescription = "back/forward";

            break;

        case NavigationTypeReload:

            typeDescription = "reload";

            break;

        case NavigationTypeFormResubmitted:

            typeDescription = "form resubmitted";

            break;

        case NavigationTypeOther:

            typeDescription = "other";

            break;

        default:

            typeDescription = "illegal value";

        }

        if (isTextOutputEnabled())

            fprintf(stdout, "Policy delegate: attempt to load %s with navigation type '%s'\n",

                    url.toUtf8().constData(), typeDescription.toUtf8().constData());

        m_drt->layoutTestController()->notifyDone();

    }

    return QWebPage::acceptNavigationRequest(frame, request, type);

}

bool WebPage::supportsExtension(QWebPage::Extension extension) const

{

    if (extension == QWebPage::ErrorPageExtension)

        return m_drt->layoutTestController()->shouldHandleErrorPages();

    return false;

}

bool WebPage::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)

{

    const QWebPage::ErrorPageExtensionOption* info = static_cast<const QWebPage::ErrorPageExtensionOption*>(option);

    // Lets handle error pages for the main frame for now.

    if (info->frame != mainFrame())

        return false;

    QWebPage::ErrorPageExtensionReturn* errorPage = static_cast<QWebPage::ErrorPageExtensionReturn*>(output);

    errorPage->content = QString("data:text/html,<body/>").toUtf8();

    return true;

}

QObject* WebPage::createPlugin(const QString& classId, const QUrl& url, const QStringList& paramNames, const QStringList& paramValues)

{

    Q_UNUSED(url);

    Q_UNUSED(paramNames);

    Q_UNUSED(paramValues);

#ifndef QT_NO_UITOOLS

    QUiLoader loader;

    return loader.createWidget(classId, view());

#else

    Q_UNUSED(classId);

    return 0;

#endif

}

bool WebPage::allowGeolocationRequest(QWebFrame *)

{

    return m_drt->layoutTestController()->geolocationPermission();

}

void WebPage::setViewGeometry(const QRect& rect)

{

    if (WebViewGraphicsBased* v = qobject_cast<WebViewGraphicsBased*>(view()))

        v->scene()->setSceneRect(QRectF(rect));

    else if (QWidget *v = view())

        v->setGeometry(rect);

}

WebViewGraphicsBased::WebViewGraphicsBased(QWidget* parent)

    : m_item(new QGraphicsWebView)

{

    setScene(new QGraphicsScene(this));

    scene()->addItem(m_item);

}

DumpRenderTree::DumpRenderTree()

    : m_dumpPixels(false)

    , m_stdin(0)

    , m_enableTextOutput(false)

    , m_singleFileMode(false)

    , m_graphicsBased(false)

    , m_persistentStoragePath(QString(getenv("DUMPRENDERTREE_TEMP")))

{

    QByteArray viewMode = getenv("QT_DRT_WEBVIEW_MODE");

    if (viewMode == "graphics")

        setGraphicsBased(true);

    DumpRenderTreeSupportQt::overwritePluginDirectories();

    QWebSettings::enablePersistentStorage(m_persistentStoragePath);

    m_networkAccessManager = new NetworkAccessManager(this);

    // create our primary testing page/view.

    if (isGraphicsBased()) {

        WebViewGraphicsBased* view = new WebViewGraphicsBased(0);

        m_page = new WebPage(view, this);

        view->setPage(m_page);

        m_mainView = view;

    } else {

        QWebView* view = new QWebView(0);

        m_page = new WebPage(view, this);

        view->setPage(m_page);

        m_mainView = view;

    }

    m_mainView->setContextMenuPolicy(Qt::NoContextMenu);

    m_mainView->resize(QSize(LayoutTestController::maxViewWidth, LayoutTestController::maxViewHeight));

    // clean up cache by resetting quota.

    qint64 quota = webPage()->settings()->offlineWebApplicationCacheQuota();

    webPage()->settings()->setOfflineWebApplicationCacheQuota(quota);

    // create our controllers. This has to be done before connectFrame,

    // as it exports there to the JavaScript DOM window.

    m_controller = new LayoutTestController(this);

    connect(m_controller, SIGNAL(showPage()), this, SLOT(showPage()));

    connect(m_controller, SIGNAL(hidePage()), this, SLOT(hidePage()));

    connect(m_controller, SIGNAL(done()), this, SLOT(dump()));

    m_eventSender = new EventSender(m_page);

    m_textInputController = new TextInputController(m_page);

    m_gcController = new GCController(m_page);

    // now connect our different signals

    connect(m_page, SIGNAL(frameCreated(QWebFrame *)),

            this, SLOT(connectFrame(QWebFrame *)));

    connectFrame(m_page->mainFrame());

    connect(m_page, SIGNAL(loadFinished(bool)),

            m_controller, SLOT(maybeDump(bool)));

    // We need to connect to loadStarted() because notifyDone should only

    // dump results itself when the last page loaded in the test has finished loading.

    connect(m_page, SIGNAL(loadStarted()),

            m_controller, SLOT(resetLoadFinished()));

    connect(m_page, SIGNAL(windowCloseRequested()), this, SLOT(windowCloseRequested()));

    connect(m_page, SIGNAL(printRequested(QWebFrame*)), this, SLOT(dryRunPrint(QWebFrame*)));

    connect(m_page->mainFrame(), SIGNAL(titleChanged(const QString&)),

            SLOT(titleChanged(const QString&)));

    connect(m_page, SIGNAL(databaseQuotaExceeded(QWebFrame*,QString)),

            this, SLOT(dumpDatabaseQuota(QWebFrame*,QString)));

    connect(m_page, SIGNAL(statusBarMessage(const QString&)),

            this, SLOT(statusBarMessage(const QString&)));

    QObject::connect(this, SIGNAL(quit()), qApp, SLOT(quit()), Qt::QueuedConnection);

    DumpRenderTreeSupportQt::setDumpRenderTreeModeEnabled(true);

    QFocusEvent event(QEvent::FocusIn, Qt::ActiveWindowFocusReason);

    QApplication::sendEvent(m_mainView, &event);

}

DumpRenderTree::~DumpRenderTree()

{

    delete m_mainView;

    delete m_stdin;

}

static void clearHistory(QWebPage* page)

{

    // QWebHistory::clear() leaves current page, so remove it as well by setting

    // max item count to 0, and then setting it back to it's original value.

    QWebHistory* history = page->history();

    int itemCount = history->maximumItemCount();

    history->clear();

    history->setMaximumItemCount(0);

    history->setMaximumItemCount(itemCount);

}

void DumpRenderTree::dryRunPrint(QWebFrame* frame)

{

#ifndef QT_NO_PRINTER

    NullPrinter printer;

    frame->print(&printer);

#endif

}

void DumpRenderTree::resetToConsistentStateBeforeTesting()

{

    // reset so that any current loads are stopped

    // NOTE: that this has to be done before the layoutTestController is

    // reset or we get timeouts for some tests.

    m_page->blockSignals(true);

    m_page->triggerAction(QWebPage::Stop);

    m_page->blockSignals(false);

    // reset the layoutTestController at this point, so that we under no

    // circumstance dump (stop the waitUntilDone timer) during the reset

    // of the DRT.

    m_controller->reset();

    // reset mouse clicks counter

    m_eventSender->resetClickCount();

    closeRemainingWindows();

    m_page->resetSettings();

    m_page->undoStack()->clear();

    m_page->mainFrame()->setZoomFactor(1.0);

    clearHistory(m_page);

    DumpRenderTreeSupportQt::clearFrameName(m_page->mainFrame());

    m_page->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAsNeeded);

    m_page->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAsNeeded);

    WorkQueue::shared()->clear();

    WorkQueue::shared()->setFrozen(false);

    DumpRenderTreeSupportQt::resetOriginAccessWhiteLists();

    // Qt defaults to Windows editing behavior.

    DumpRenderTreeSupportQt::setEditingBehavior(m_page, "win");