/*

 * Copyright (C) 2010 Google 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:

 *

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

#include "LayoutTestController.h"

#include "TestNavigationController.h"

#include "TestShell.h"

#include "TestWebWorker.h"

#include "net/base/net_errors.h" // FIXME: can we remove this?

#include "public/WebCString.h"

#include "public/WebConsoleMessage.h"

#include "public/WebContextMenuData.h"

#include "public/WebDataSource.h"

#include "public/WebDragData.h"

#include "public/WebFrame.h"

#include "public/WebGeolocationServiceMock.h"

#include "public/WebHistoryItem.h"

#include "public/WebNode.h"

#include "public/WebRange.h"

#include "public/WebRect.h"

#include "public/WebScreenInfo.h"

#include "public/WebSize.h"

#include "public/WebStorageNamespace.h"

#include "public/WebURLRequest.h"

#include "public/WebURLResponse.h"

#include "public/WebView.h"

#include "public/WebWindowFeatures.h"

#include "skia/ext/platform_canvas.h"

#include "webkit/support/webkit_support.h"

#include <wtf/Assertions.h>

#include <wtf/PassOwnPtr.h>

using namespace WebCore;

using namespace WebKit;

using namespace skia;

using namespace std;

static const int screenWidth = 1920;

static const int screenHeight = 1080;

static const int screenUnavailableBorder = 8;

// WebNavigationType debugging strings taken from PolicyDelegate.mm.

static const char* linkClickedString = "link clicked";

static const char* formSubmittedString = "form submitted";

static const char* backForwardString = "back/forward";

static const char* reloadString = "reload";

static const char* formResubmittedString = "form resubmitted";

static const char* otherString = "other";

static const char* illegalString = "illegal value";

static int nextPageID = 1;

// Used to write a platform neutral file:/// URL by only taking the filename

// (e.g., converts "file:///tmp/foo.txt" to just "foo.txt").

static string urlSuitableForTestResult(const string& url)

{

    if (url.empty() || string::npos == url.find("file://"))

        return url;

    size_t pos = url.rfind('/');

    if (pos == string::npos) {

#if OS(WINDOWS)

        pos = url.rfind('\\');

        if (pos == string::npos)

            pos = 0;

#else

        pos = 0;

#endif

    }

    string filename = url.substr(pos + 1);

    if (filename.empty())

        return "file:"; // A WebKit test has this in its expected output.

    return filename;

}

// Used to write a platform neutral file:/// URL by taking the

// filename and its directory. (e.g., converts

// "file:///tmp/foo/bar.txt" to just "bar.txt").

static string descriptionSuitableForTestResult(const string& url)

{

    if (url.empty() || string::npos == url.find("file://"))

        return url;

    size_t pos = url.rfind('/');

    if (pos == string::npos || !pos)

        return "ERROR:" + url;

    pos = url.rfind('/', pos - 1);

    if (pos == string::npos)

        return "ERROR:" + url;

    return url.substr(pos + 1);

}

// Adds a file called "DRTFakeFile" to |data_object| (CF_HDROP).  Use to fake

// dragging a file.

static void addDRTFakeFileToDataObject(WebDragData* dragData)

{

    dragData->appendToFileNames(WebString::fromUTF8("DRTFakeFile"));

}

// Get a debugging string from a WebNavigationType.

static const char* webNavigationTypeToString(WebNavigationType type)

{

    switch (type) {

    case WebKit::WebNavigationTypeLinkClicked:

        return linkClickedString;

    case WebKit::WebNavigationTypeFormSubmitted:

        return formSubmittedString;

    case WebKit::WebNavigationTypeBackForward:

        return backForwardString;

    case WebKit::WebNavigationTypeReload:

        return reloadString;

    case WebKit::WebNavigationTypeFormResubmitted:

        return formResubmittedString;

    case WebKit::WebNavigationTypeOther:

        return otherString;

    }

    return illegalString;

}

static string URLDescription(const GURL& url)

{

    if (url.SchemeIs("file"))

        return url.ExtractFileName();

    return url.possibly_invalid_spec();

}

static void printResponseDescription(const WebURLResponse& response)

{

    if (response.isNull()) {

        fputs("(null)", stdout);

        return;

    }

    string url = response.url().spec();

    printf("<NSURLResponse %s, http status code %d>",

           descriptionSuitableForTestResult(url).c_str(),

           response.httpStatusCode());

}

static void printErrorDescription(const WebURLError& error)

{

    string domain = error.domain.utf8();

    int code = error.reason;

    if (domain == net::kErrorDomain) {

        domain = "NSURLErrorDomain";

        switch (error.reason) {

        case net::ERR_ABORTED:

            code = -999;

            break;

        case net::ERR_UNSAFE_PORT:

            // Our unsafe port checking happens at the network stack level, but we

            // make this translation here to match the behavior of stock WebKit.

            domain = "WebKitErrorDomain";

            code = 103;

            break;

        case net::ERR_ADDRESS_INVALID:

        case net::ERR_ADDRESS_UNREACHABLE:

            code = -1004;

            break;

        }

    } else

        LOG_ERROR("Unknown error domain");

    printf("<NSError domain %s, code %d, failing URL \"%s\">",

           domain.c_str(), code, error.unreachableURL.spec().data());

}

static void printNodeDescription(const WebNode& node, int exception)

{

    if (exception) {

        fputs("ERROR", stdout);

        return;

    }

    if (node.isNull()) {

        fputs("(null)", stdout);

        return;

    }

    fputs(node.nodeName().utf8().data(), stdout);

    const WebNode& parent = node.parentNode();

    if (!parent.isNull()) {

        fputs(" > ", stdout);

        printNodeDescription(parent, 0);

    }

}

static void printRangeDescription(const WebRange& range)

{

    if (range.isNull()) {

        fputs("(null)", stdout);

        return;

    }

    printf("range from %d of ", range.startOffset());

    int exception = 0;

    WebNode startNode = range.startContainer(exception);

    printNodeDescription(startNode, exception);

    printf(" to %d of ", range.endOffset());

    WebNode endNode = range.endContainer(exception);

    printNodeDescription(endNode, exception);

}

static string editingActionDescription(WebEditingAction action)

{

    switch (action) {

    case WebKit::WebEditingActionTyped:

        return "WebViewInsertActionTyped";

    case WebKit::WebEditingActionPasted:

        return "WebViewInsertActionPasted";

    case WebKit::WebEditingActionDropped:

        return "WebViewInsertActionDropped";

    }

    return "(UNKNOWN ACTION)";

}

static string textAffinityDescription(WebTextAffinity affinity)

{

    switch (affinity) {

    case WebKit::WebTextAffinityUpstream:

        return "NSSelectionAffinityUpstream";

    case WebKit::WebTextAffinityDownstream:

        return "NSSelectionAffinityDownstream";

    }

    return "(UNKNOWN AFFINITY)";

}

// WebViewClient -------------------------------------------------------------

WebView* WebViewHost::createView(WebFrame*, const WebWindowFeatures&, const WebString&)

{

    if (!layoutTestController()->canOpenWindows())

        return 0;

    return m_shell->createWebView()->webView();

}

WebWidget* WebViewHost::createPopupMenu(WebPopupType)

{

    return 0;

}

WebWidget* WebViewHost::createPopupMenu(const WebPopupMenuInfo&)

{

    return 0;

}

WebStorageNamespace* WebViewHost::createSessionStorageNamespace(unsigned quota)

{

    return WebKit::WebStorageNamespace::createSessionStorageNamespace(quota);

}

void WebViewHost::didAddMessageToConsole(const WebConsoleMessage& message, const WebString& sourceName, unsigned sourceLine)

{

    // This matches win DumpRenderTree's UIDelegate.cpp.

    string newMessage;

    if (!message.text.isEmpty()) {

        newMessage = message.text.utf8();

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

        if (fileProtocol != string::npos) {

            newMessage = newMessage.substr(0, fileProtocol)

                + urlSuitableForTestResult(newMessage.substr(fileProtocol));

        }

    }

    printf("CONSOLE MESSAGE: line %d: %s\n", sourceLine, newMessage.data());

}

void WebViewHost::didStartLoading()

{

    m_shell->setIsLoading(true);

}

void WebViewHost::didStopLoading()

{

    m_shell->setIsLoading(false);

}

// The output from these methods in layout test mode should match that

// expected by the layout tests.  See EditingDelegate.m in DumpRenderTree.

bool WebViewHost::shouldBeginEditing(const WebRange& range)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        fputs("EDITING DELEGATE: shouldBeginEditingInDOMRange:", stdout);

        printRangeDescription(range);

        fputs("\n", stdout);

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::shouldEndEditing(const WebRange& range)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        fputs("EDITING DELEGATE: shouldEndEditingInDOMRange:", stdout);

        printRangeDescription(range);

        fputs("\n", stdout);

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::shouldInsertNode(const WebNode& node, const WebRange& range, WebEditingAction action)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        fputs("EDITING DELEGATE: shouldInsertNode:", stdout);

        printNodeDescription(node, 0);

        fputs(" replacingDOMRange:", stdout);

        printRangeDescription(range);

        printf(" givenAction:%s\n", editingActionDescription(action).c_str());

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::shouldInsertText(const WebString& text, const WebRange& range, WebEditingAction action)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        printf("EDITING DELEGATE: shouldInsertText:%s replacingDOMRange:", text.utf8().data());

        printRangeDescription(range);

        printf(" givenAction:%s\n", editingActionDescription(action).c_str());

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::shouldChangeSelectedRange(

    const WebRange& fromRange, const WebRange& toRange, WebTextAffinity affinity, bool stillSelecting)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        fputs("EDITING DELEGATE: shouldChangeSelectedDOMRange:", stdout);

        printRangeDescription(fromRange);

        fputs(" toDOMRange:", stdout);

        printRangeDescription(toRange);

        printf(" affinity:%s stillSelecting:%s\n",

               textAffinityDescription(affinity).c_str(),

               (stillSelecting ? "TRUE" : "FALSE"));

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::shouldDeleteRange(const WebRange& range)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        fputs("EDITING DELEGATE: shouldDeleteDOMRange:", stdout);

        printRangeDescription(range);

        fputs("\n", stdout);

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::shouldApplyStyle(const WebString& style, const WebRange& range)

{

    if (layoutTestController()->shouldDumpEditingCallbacks()) {

        printf("EDITING DELEGATE: shouldApplyStyle:%s toElementsInDOMRange:", style.utf8().data());

        printRangeDescription(range);

        fputs("\n", stdout);

    }

    return layoutTestController()->acceptsEditing();

}

bool WebViewHost::isSmartInsertDeleteEnabled()

{

    return m_smartInsertDeleteEnabled;

}

bool WebViewHost::isSelectTrailingWhitespaceEnabled()

{

    return m_selectTrailingWhitespaceEnabled;

}

void WebViewHost::didBeginEditing()

{

    if (!layoutTestController()->shouldDumpEditingCallbacks())

        return;

    fputs("EDITING DELEGATE: webViewDidBeginEditing:WebViewDidBeginEditingNotification\n", stdout);

}

void WebViewHost::didChangeSelection(bool isEmptySelection)

{

    if (layoutTestController()->shouldDumpEditingCallbacks())

        fputs("EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification\n", stdout);

    // No need to update clipboard with the selected text in DRT.

}

void WebViewHost::didChangeContents()

{

    if (!layoutTestController()->shouldDumpEditingCallbacks())

        return;

    fputs("EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification\n", stdout);

}

void WebViewHost::didEndEditing()

{

    if (!layoutTestController()->shouldDumpEditingCallbacks())

        return;

    fputs("EDITING DELEGATE: webViewDidEndEditing:WebViewDidEndEditingNotification\n", stdout);

}

bool WebViewHost::handleCurrentKeyboardEvent()

{

    if (m_editCommandName.empty())

        return false;

    WebFrame* frame = webView()->focusedFrame();

    if (!frame)

        return false;

    return frame->executeCommand(WebString::fromUTF8(m_editCommandName), WebString::fromUTF8(m_editCommandValue));

}

void WebViewHost::spellCheck(const WebString& text, int& misspelledOffset, int& misspelledLength)

{

    // Check the spelling of the given text.

#if OS(MAC_OS_X)

    // FIXME: rebaseline layout-test results of Windows and Linux so we

    // can enable this mock spellchecker on them.

    m_spellcheck.spellCheckWord(text, &misspelledOffset, &misspelledLength);

#endif

}

WebString WebViewHost::autoCorrectWord(const WebString&)

{

    // Returns an empty string as Mac WebKit ('WebKitSupport/WebEditorClient.mm')

    // does. (If this function returns a non-empty string, WebKit replaces the

    // given misspelled string with the result one. This process executes some

    // editor commands and causes layout-test failures.)

    return WebString();

}

void WebViewHost::runModalAlertDialog(WebFrame*, const WebString& message)

{

    printf("ALERT: %s\n", message.utf8().data());

}

bool WebViewHost::runModalConfirmDialog(WebFrame*, const WebString& message)

{

    printf("CONFIRM: %s\n", message.utf8().data());

    return true;

}

bool WebViewHost::runModalPromptDialog(WebFrame* frame, const WebString& message,

                                       const WebString& defaultValue, WebString*)

{

    printf("PROMPT: %s, default text: %s\n", message.utf8().data(), defaultValue.utf8().data());

    return true;

}

bool WebViewHost::runModalBeforeUnloadDialog(WebFrame*, const WebString&)

{

    return true; // Allow window closure.

}

void WebViewHost::showContextMenu(WebFrame*, const WebContextMenuData&)

{

}

void WebViewHost::setStatusText(const WebString& text)

{

    if (!layoutTestController()->shouldDumpStatusCallbacks())

        return;

    // When running tests, write to stdout.

    printf("UI DELEGATE STATUS CALLBACK: setStatusText:%s\n", text.utf8().data());

}

void WebViewHost::startDragging(const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&)

{

    WebDragData mutableDragData = data;

    if (layoutTestController()->shouldAddFileToPasteboard()) {

        // Add a file called DRTFakeFile to the drag&drop clipboard.

        addDRTFakeFileToDataObject(&mutableDragData);

    }

    // When running a test, we need to fake a drag drop operation otherwise

    // Windows waits for real mouse events to know when the drag is over.

    m_shell->eventSender()->doDragDrop(mutableDragData, mask);

}

void WebViewHost::navigateBackForwardSoon(int offset)

{

    navigationController()->goToOffset(offset);

}

int WebViewHost::historyBackListCount()

{

    return navigationController()->lastCommittedEntryIndex();

}

int WebViewHost::historyForwardListCount()

{

    int currentIndex =navigationController()->lastCommittedEntryIndex();

    return navigationController()->entryCount() - currentIndex - 1;

}

void WebViewHost::focusAccessibilityObject(const WebAccessibilityObject& object)

{

    m_shell->accessibilityController()->setFocusedElement(object);

}

WebNotificationPresenter* WebViewHost::notificationPresenter()

{

    return m_shell->notificationPresenter();

}

WebKit::WebGeolocationService* WebViewHost::geolocationService()

{

    if (!m_geolocationServiceMock.get())