/*

 * Copyright (C) 2010 Google Inc. All rights reserved.

 * Copyright (C) 2010 Pawel Hajdan (phajdan.jr@chromium.org)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

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

 *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT

 * OWNER 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 "LayoutTestController.h"

#include "DRTDevToolsAgent.h"

#include "TestShell.h"

#include "WebViewHost.h"

#include "base/string_util.h"

#include "public/WebAnimationController.h"

#include "public/WebConsoleMessage.h"

#include "public/WebDocument.h"

#include "public/WebFrame.h"

#include "public/WebGeolocationServiceMock.h"

#include "public/WebInputElement.h"

#include "public/WebKit.h"

#include "public/WebNotificationPresenter.h"

#include "public/WebScriptSource.h"

#include "public/WebSecurityPolicy.h"

#include "public/WebSettings.h"

#include "public/WebSize.h"

#include "public/WebURL.h"

#include "public/WebView.h"

#include "webkit/support/webkit_support.h"

#include <wtf/text/WTFString.h>

#if OS(WINDOWS)

#include <wtf/OwnArrayPtr.h>

#endif

using namespace WebCore;

using namespace WebKit;

using namespace std;

LayoutTestController::LayoutTestController(TestShell* shell)

    : m_timeoutFactory(this)

    , m_shell(shell)

    , m_workQueue(this)

{

    // Initialize the map that associates methods of this class with the names

    // they will use when called by JavaScript.  The actual binding of those

    // names to their methods will be done by calling bindToJavaScript() (defined

    // by CppBoundClass, the parent to LayoutTestController).

    bindMethod("dumpAsText", &LayoutTestController::dumpAsText);

    bindMethod("dumpChildFrameScrollPositions", &LayoutTestController::dumpChildFrameScrollPositions);

    bindMethod("dumpChildFramesAsText", &LayoutTestController::dumpChildFramesAsText);

    bindMethod("dumpDatabaseCallbacks", &LayoutTestController::dumpDatabaseCallbacks);

    bindMethod("dumpEditingCallbacks", &LayoutTestController::dumpEditingCallbacks);

    bindMethod("dumpBackForwardList", &LayoutTestController::dumpBackForwardList);

    bindMethod("dumpFrameLoadCallbacks", &LayoutTestController::dumpFrameLoadCallbacks);

    bindMethod("dumpResourceLoadCallbacks", &LayoutTestController::dumpResourceLoadCallbacks);

    bindMethod("dumpStatusCallbacks", &LayoutTestController::dumpWindowStatusChanges);

    bindMethod("dumpTitleChanges", &LayoutTestController::dumpTitleChanges);

    bindMethod("setAcceptsEditing", &LayoutTestController::setAcceptsEditing);

    bindMethod("waitUntilDone", &LayoutTestController::waitUntilDone);

    bindMethod("notifyDone", &LayoutTestController::notifyDone);

    bindMethod("queueReload", &LayoutTestController::queueReload);

    bindMethod("queueLoadingScript", &LayoutTestController::queueLoadingScript);

    bindMethod("queueNonLoadingScript", &LayoutTestController::queueNonLoadingScript);

    bindMethod("queueLoad", &LayoutTestController::queueLoad);

    bindMethod("queueBackNavigation", &LayoutTestController::queueBackNavigation);

    bindMethod("queueForwardNavigation", &LayoutTestController::queueForwardNavigation);

    bindMethod("windowCount", &LayoutTestController::windowCount);

    bindMethod("setCanOpenWindows", &LayoutTestController::setCanOpenWindows);

    bindMethod("setCloseRemainingWindowsWhenComplete", &LayoutTestController::setCloseRemainingWindowsWhenComplete);

    bindMethod("objCIdentityIsEqual", &LayoutTestController::objCIdentityIsEqual);

    bindMethod("setAlwaysAcceptCookies", &LayoutTestController::setAlwaysAcceptCookies);

    bindMethod("showWebInspector", &LayoutTestController::showWebInspector);

    bindMethod("closeWebInspector", &LayoutTestController::closeWebInspector);

    bindMethod("setWindowIsKey", &LayoutTestController::setWindowIsKey);

    bindMethod("setTabKeyCyclesThroughElements", &LayoutTestController::setTabKeyCyclesThroughElements);

    bindMethod("setUserStyleSheetLocation", &LayoutTestController::setUserStyleSheetLocation);

    bindMethod("setUserStyleSheetEnabled", &LayoutTestController::setUserStyleSheetEnabled);

    bindMethod("setAuthorAndUserStylesEnabled", &LayoutTestController::setAuthorAndUserStylesEnabled);

    bindMethod("pathToLocalResource", &LayoutTestController::pathToLocalResource);

    bindMethod("addFileToPasteboardOnDrag", &LayoutTestController::addFileToPasteboardOnDrag);

    bindMethod("execCommand", &LayoutTestController::execCommand);

    bindMethod("isCommandEnabled", &LayoutTestController::isCommandEnabled);

    bindMethod("setPopupBlockingEnabled", &LayoutTestController::setPopupBlockingEnabled);

    bindMethod("setStopProvisionalFrameLoads", &LayoutTestController::setStopProvisionalFrameLoads);

    bindMethod("setSmartInsertDeleteEnabled", &LayoutTestController::setSmartInsertDeleteEnabled);

    bindMethod("setSelectTrailingWhitespaceEnabled", &LayoutTestController::setSelectTrailingWhitespaceEnabled);

    bindMethod("pauseAnimationAtTimeOnElementWithId", &LayoutTestController::pauseAnimationAtTimeOnElementWithId);

    bindMethod("pauseTransitionAtTimeOnElementWithId", &LayoutTestController::pauseTransitionAtTimeOnElementWithId);

    bindMethod("elementDoesAutoCompleteForElementWithId", &LayoutTestController::elementDoesAutoCompleteForElementWithId);

    bindMethod("numberOfActiveAnimations", &LayoutTestController::numberOfActiveAnimations);

    bindMethod("disableImageLoading", &LayoutTestController::disableImageLoading);

    bindMethod("setIconDatabaseEnabled", &LayoutTestController::setIconDatabaseEnabled);

    bindMethod("setCustomPolicyDelegate", &LayoutTestController::setCustomPolicyDelegate);

    bindMethod("setScrollbarPolicy", &LayoutTestController::setScrollbarPolicy);

    bindMethod("waitForPolicyDelegate", &LayoutTestController::waitForPolicyDelegate);

    bindMethod("setWillSendRequestClearHeader", &LayoutTestController::setWillSendRequestClearHeader);

    bindMethod("setWillSendRequestReturnsNullOnRedirect", &LayoutTestController::setWillSendRequestReturnsNullOnRedirect);

    bindMethod("setWillSendRequestReturnsNull", &LayoutTestController::setWillSendRequestReturnsNull);

    bindMethod("addOriginAccessWhitelistEntry", &LayoutTestController::addOriginAccessWhitelistEntry);

    bindMethod("removeOriginAccessWhitelistEntry", &LayoutTestController::removeOriginAccessWhitelistEntry);

    bindMethod("clearAllDatabases", &LayoutTestController::clearAllDatabases);

    bindMethod("setDatabaseQuota", &LayoutTestController::setDatabaseQuota);

    bindMethod("setPOSIXLocale", &LayoutTestController::setPOSIXLocale);

    bindMethod("counterValueForElementById", &LayoutTestController::counterValueForElementById);

    bindMethod("addUserScript", &LayoutTestController::addUserScript);

    bindMethod("addUserStyleSheet", &LayoutTestController::addUserStyleSheet);

    bindMethod("pageNumberForElementById", &LayoutTestController::pageNumberForElementById);

    bindMethod("numberOfPages", &LayoutTestController::numberOfPages);

    bindMethod("dumpSelectionRect", &LayoutTestController::dumpSelectionRect);

    bindMethod("grantDesktopNotificationPermission", &LayoutTestController::grantDesktopNotificationPermission);

    // The following are stubs.

    bindMethod("dumpAsWebArchive", &LayoutTestController::dumpAsWebArchive);

    bindMethod("setMainFrameIsFirstResponder", &LayoutTestController::setMainFrameIsFirstResponder);

    bindMethod("dumpSelectionRect", &LayoutTestController::dumpSelectionRect);

    bindMethod("display", &LayoutTestController::display);

    bindMethod("testRepaint", &LayoutTestController::testRepaint);

    bindMethod("repaintSweepHorizontally", &LayoutTestController::repaintSweepHorizontally);

    bindMethod("clearBackForwardList", &LayoutTestController::clearBackForwardList);

    bindMethod("keepWebHistory", &LayoutTestController::keepWebHistory);

    bindMethod("storeWebScriptObject", &LayoutTestController::storeWebScriptObject);

    bindMethod("accessStoredWebScriptObject", &LayoutTestController::accessStoredWebScriptObject);

    bindMethod("objCClassNameOf", &LayoutTestController::objCClassNameOf);

    bindMethod("addDisallowedURL", &LayoutTestController::addDisallowedURL);

    bindMethod("callShouldCloseOnWebView", &LayoutTestController::callShouldCloseOnWebView);

    bindMethod("setCallCloseOnWebViews", &LayoutTestController::setCallCloseOnWebViews);

    bindMethod("setPrivateBrowsingEnabled", &LayoutTestController::setPrivateBrowsingEnabled);

    bindMethod("setUseDashboardCompatibilityMode", &LayoutTestController::setUseDashboardCompatibilityMode);

    bindMethod("setJavaScriptCanAccessClipboard", &LayoutTestController::setJavaScriptCanAccessClipboard);

    bindMethod("setXSSAuditorEnabled", &LayoutTestController::setXSSAuditorEnabled);

    bindMethod("evaluateScriptInIsolatedWorld", &LayoutTestController::evaluateScriptInIsolatedWorld);

    bindMethod("overridePreference", &LayoutTestController::overridePreference);

    bindMethod("setAllowUniversalAccessFromFileURLs", &LayoutTestController::setAllowUniversalAccessFromFileURLs);

    bindMethod("setAllowFileAccessFromFileURLs", &LayoutTestController::setAllowFileAccessFromFileURLs);

    bindMethod("setTimelineProfilingEnabled", &LayoutTestController::setTimelineProfilingEnabled);

    bindMethod("evaluateInWebInspector", &LayoutTestController::evaluateInWebInspector);

    bindMethod("forceRedSelectionColors", &LayoutTestController::forceRedSelectionColors);

    bindMethod("setEditingBehavior", &LayoutTestController::setEditingBehavior);

    bindMethod("setGeolocationPermission", &LayoutTestController::setGeolocationPermission);

    bindMethod("setMockGeolocationPosition", &LayoutTestController::setMockGeolocationPosition);

    bindMethod("setMockGeolocationError", &LayoutTestController::setMockGeolocationError);

    bindMethod("abortModal", &LayoutTestController::abortModal);

    // The fallback method is called when an unknown method is invoked.

    bindFallbackMethod(&LayoutTestController::fallbackMethod);

    // Shared properties.

    // globalFlag is used by a number of layout tests in

    // LayoutTests\http\tests\security\dataURL.

    bindProperty("globalFlag", &m_globalFlag);

    // webHistoryItemCount is used by tests in LayoutTests\http\tests\history

    bindProperty("webHistoryItemCount", &m_webHistoryItemCount);

}

LayoutTestController::WorkQueue::~WorkQueue()

{

    reset();

}

void LayoutTestController::WorkQueue::processWorkSoon()

{

    if (m_controller->m_shell->webViewHost()->topLoadingFrame())

        return;

    if (!m_queue.isEmpty()) {

        // We delay processing queued work to avoid recursion problems.

        m_timer.Start(base::TimeDelta(), this, &WorkQueue::processWork);

    } else if (!m_controller->m_waitUntilDone) {

        m_controller->m_shell->testFinished();

    }

}

void LayoutTestController::WorkQueue::processWork()

{

    TestShell* shell = m_controller->m_shell;

    // Quit doing work once a load is in progress.

    while (!m_queue.isEmpty()) {

        bool startedLoad = m_queue.first()->run(shell);

        delete m_queue.takeFirst();

        if (startedLoad)

            return;

    }

    if (!m_controller->m_waitUntilDone && !shell->webViewHost()->topLoadingFrame())

        shell->testFinished();

}

void LayoutTestController::WorkQueue::reset()

{

    m_frozen = false;

    while (!m_queue.isEmpty()) {

        delete m_queue.takeFirst();

    }

}

void LayoutTestController::WorkQueue::addWork(WorkItem* work)

{

    if (m_frozen) {

        delete work;

        return;

    }

    m_queue.append(work);

}

void LayoutTestController::dumpAsText(const CppArgumentList& arguments, CppVariant* result)

{

    m_dumpAsText = true;

    m_generatePixelResults = false;

    // Optional paramater, describing whether it's allowed to dump pixel results in dumpAsText mode.

    if (arguments.size() > 0 && arguments[0].isBool())

        m_generatePixelResults = arguments[0].value.boolValue;

    result->setNull();

}

void LayoutTestController::dumpDatabaseCallbacks(const CppArgumentList&, CppVariant* result)

{

    // Do nothing; we don't use this flag anywhere for now

    result->setNull();

}

void LayoutTestController::dumpEditingCallbacks(const CppArgumentList&, CppVariant* result)

{

    m_dumpEditingCallbacks = true;

    result->setNull();

}

void LayoutTestController::dumpBackForwardList(const CppArgumentList&, CppVariant* result)

{

    m_dumpBackForwardList = true;

    result->setNull();

}

void LayoutTestController::dumpFrameLoadCallbacks(const CppArgumentList&, CppVariant* result)

{

    m_dumpFrameLoadCallbacks = true;

    result->setNull();

}

void LayoutTestController::dumpResourceLoadCallbacks(const CppArgumentList&, CppVariant* result)

{

    m_dumpResourceLoadCallbacks = true;

    result->setNull();

}

void LayoutTestController::dumpChildFrameScrollPositions(const CppArgumentList&, CppVariant* result)

{

    m_dumpChildFrameScrollPositions = true;

    result->setNull();

}

void LayoutTestController::dumpChildFramesAsText(const CppArgumentList&, CppVariant* result)

{

    m_dumpChildFramesAsText = true;

    result->setNull();

}

void LayoutTestController::dumpWindowStatusChanges(const CppArgumentList&, CppVariant* result)

{

    m_dumpWindowStatusChanges = true;

    result->setNull();

}

void LayoutTestController::dumpTitleChanges(const CppArgumentList&, CppVariant* result)

{

    m_dumpTitleChanges = true;

    result->setNull();

}

void LayoutTestController::setAcceptsEditing(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() > 0 && arguments[0].isBool())

        m_acceptsEditing = arguments[0].value.boolValue;

    result->setNull();

}

void LayoutTestController::waitUntilDone(const CppArgumentList&, CppVariant* result)

{

    if (!webkit_support::BeingDebugged()) {

        webkit_support::PostDelayedTaskFromHere(

            m_timeoutFactory.NewRunnableMethod(&LayoutTestController::notifyDoneTimedOut),

            m_shell->layoutTestTimeout());

    }

    m_waitUntilDone = true;

    result->setNull();

}

void LayoutTestController::notifyDone(const CppArgumentList&, CppVariant* result)

{

    // Test didn't timeout. Kill the timeout timer.

    m_timeoutFactory.RevokeAll();

    completeNotifyDone(false);

    result->setNull();

}

void LayoutTestController::notifyDoneTimedOut()

{

    completeNotifyDone(true);

}

void LayoutTestController::completeNotifyDone(bool isTimeout)

{

    if (m_waitUntilDone && !m_shell->webViewHost()->topLoadingFrame() && m_workQueue.isEmpty()) {

        if (isTimeout)

            m_shell->testTimedOut();

        else

            m_shell->testFinished();

    }

    m_waitUntilDone = false;

}

class WorkItemBackForward : public LayoutTestController::WorkItem {

public:

    WorkItemBackForward(int distance) : m_distance(distance) {}

    bool run(TestShell* shell)

    {

        shell->goToOffset(m_distance);

        return true; // FIXME: Did it really start a navigation?

    }

private:

    int m_distance;

};

void LayoutTestController::queueBackNavigation(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() > 0 && arguments[0].isNumber())

        m_workQueue.addWork(new WorkItemBackForward(-arguments[0].toInt32()));

    result->setNull();

}

void LayoutTestController::queueForwardNavigation(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() > 0 && arguments[0].isNumber())

        m_workQueue.addWork(new WorkItemBackForward(arguments[0].toInt32()));

    result->setNull();

}

class WorkItemReload : public LayoutTestController::WorkItem {

public:

    bool run(TestShell* shell)

    {

        shell->reload();

        return true;

    }

};

void LayoutTestController::queueReload(const CppArgumentList&, CppVariant* result)

{

    m_workQueue.addWork(new WorkItemReload);

    result->setNull();

}

class WorkItemLoadingScript : public LayoutTestController::WorkItem {

public:

    WorkItemLoadingScript(const string& script) : m_script(script) {}

    bool run(TestShell* shell)

    {

        shell->webView()->mainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(m_script)));

        return true; // FIXME: Did it really start a navigation?

    }

private:

    string m_script;

};

class WorkItemNonLoadingScript : public LayoutTestController::WorkItem {

public:

    WorkItemNonLoadingScript(const string& script) : m_script(script) {}

    bool run(TestShell* shell)

    {

        shell->webView()->mainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(m_script)));

        return false;

    }

private:

    string m_script;

};

void LayoutTestController::queueLoadingScript(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() > 0 && arguments[0].isString())

        m_workQueue.addWork(new WorkItemLoadingScript(arguments[0].toString()));

    result->setNull();

}

void LayoutTestController::queueNonLoadingScript(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() > 0 && arguments[0].isString())

        m_workQueue.addWork(new WorkItemNonLoadingScript(arguments[0].toString()));

    result->setNull();

}

class WorkItemLoad : public LayoutTestController::WorkItem {

public:

    WorkItemLoad(const WebURL& url, const WebString& target)

        : m_url(url)

        , m_target(target) {}

    bool run(TestShell* shell)

    {

        shell->webViewHost()->loadURLForFrame(m_url, m_target);

        return true; // FIXME: Did it really start a navigation?

    }

private:

    WebURL m_url;

    WebString m_target;

};

void LayoutTestController::queueLoad(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() > 0 && arguments[0].isString()) {

        // FIXME: Implement WebURL::resolve() and avoid GURL.

        GURL currentURL = m_shell->webView()->mainFrame()->url();

        GURL fullURL = currentURL.Resolve(arguments[0].toString());

        string target = "";

        if (arguments.size() > 1 && arguments[1].isString())

            target = arguments[1].toString();

        m_workQueue.addWork(new WorkItemLoad(fullURL, WebString::fromUTF8(target)));

    }

    result->setNull();

}

void LayoutTestController::objCIdentityIsEqual(const CppArgumentList& arguments, CppVariant* result)

{

    if (arguments.size() < 2) {

        // This is the best we can do to return an error.

        result->setNull();

        return;

    }

    result->set(arguments[0].isEqual(arguments[1]));

}

void LayoutTestController::reset()

{

    if (m_shell) {

        m_shell->webView()->setZoomLevel(false, 0);

        m_shell->webView()->setTabKeyCyclesThroughElements(true);

#if !OS(DARWIN) && !OS(WINDOWS) // Actually, TOOLKIT_GTK

        // (Constants copied because we can't depend on the header that defined

        // them from this file.)

        m_shell->webView()->setSelectionColors(0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);

#endif

        m_shell->webView()->removeAllUserContent();

    }

    m_dumpAsText = false;

    m_dumpEditingCallbacks = false;

    m_dumpFrameLoadCallbacks = false;

    m_dumpResourceLoadCallbacks = false;

    m_dumpBackForwardList = false;

    m_dumpChildFrameScrollPositions = false;

    m_dumpChildFramesAsText = false;

    m_dumpWindowStatusChanges = false;

    m_dumpSelectionRect = false;

    m_dumpTitleChanges = false;

    m_generatePixelResults = true;

    m_acceptsEditing = true;

    m_waitUntilDone = false;

    m_canOpenWindows = false;

    m_testRepaint = false;

    m_sweepHorizontally = false;

    m_shouldAddFileToPasteboard = false;

    m_stopProvisionalFrameLoads = false;

    m_globalFlag.set(false);

    m_webHistoryItemCount.set(0);

    m_userStyleSheetLocation = WebURL();

    webkit_support::SetAcceptAllCookies(false);

    WebSecurityPolicy::resetOriginAccessWhitelists();

    // Reset the default quota for each origin to 5MB

    webkit_support::SetDatabaseQuota(5 * 1024 * 1024);

    setlocale(LC_ALL, "");

    if (m_closeRemainingWindows)

        m_shell->closeRemainingWindows();

    else

        m_closeRemainingWindows = true;

    m_workQueue.reset();

}

void LayoutTestController::locationChangeDone()

{

    m_webHistoryItemCount.set(m_shell->navigationEntryCount());

    // No more new work after the first complete load.

    m_workQueue.setFrozen(true);

    if (!m_waitUntilDone)

        m_workQueue.processWorkSoon();

}

void LayoutTestController::policyDelegateDone()

{

    ASSERT(m_waitUntilDone);

    m_shell->testFinished();

    m_waitUntilDone = false;

}

void LayoutTestController::setCanOpenWindows(const CppArgumentList&, CppVariant* result)