/*

 * Copyright (C) 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.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 "InspectorController.h"

#if ENABLE(INSPECTOR)

#include "CachedResource.h"

#include "Chrome.h"

#include "Console.h"

#include "ConsoleMessage.h"

#include "Cookie.h"

#include "CookieJar.h"

#include "DOMWindow.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "Element.h"

#include "FloatConversion.h"

#include "FloatQuad.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLFrameOwnerElement.h"

#include "HitTestResult.h"

#include "InjectedScript.h"

#include "InjectedScriptHost.h"

#include "InspectorBackend.h"

#include "InspectorCSSStore.h"

#include "InspectorClient.h"

#include "InspectorFrontendClient.h"

#include "InspectorDOMStorageResource.h"

#include "InspectorDatabaseResource.h"

#include "InspectorFrontend.h"

#include "InspectorResource.h"

#include "InspectorValues.h"

#include "InspectorWorkerResource.h"

#include "InspectorTimelineAgent.h"

#include "Page.h"

#include "ProgressTracker.h"

#include "Range.h"

#include "RemoteInspectorFrontend.h"

#include "RenderInline.h"

#include "ResourceRequest.h"

#include "ResourceResponse.h"

#include "ScriptBreakpoint.h"

#include "ScriptCallStack.h"

#include "ScriptFunctionCall.h"

#include "ScriptObject.h"

#include "ScriptProfile.h"

#include "ScriptProfiler.h"

#include "ScriptSourceCode.h"

#include "ScriptString.h"

#include "SecurityOrigin.h"

#include "Settings.h"

#include "SharedBuffer.h"

#include "TextEncoding.h"

#include "TextIterator.h"

#include <wtf/text/CString.h>

#include <wtf/CurrentTime.h>

#include <wtf/ListHashSet.h>

#include <wtf/MD5.h>

#include <wtf/RefCounted.h>

#include <wtf/StdLibExtras.h>

#if ENABLE(DATABASE)

#include "Database.h"

#endif

#if ENABLE(OFFLINE_WEB_APPLICATIONS)

#include "InspectorApplicationCacheAgent.h"

#endif

#if ENABLE(DOM_STORAGE)

#include "Storage.h"

#include "StorageArea.h"

#endif

#if ENABLE(JAVASCRIPT_DEBUGGER)

#include "ScriptDebugServer.h"

#if USE(JSC)

#include <runtime/JSLock.h>

#include <runtime/UString.h>

#include "JSScriptProfile.h"

#else

#include "V8ScriptProfile.h"

#endif

#endif

using namespace std;

namespace WebCore {

static const char* const UserInitiatedProfileName = "org.webkit.profiles.user-initiated";

static const char* const CPUProfileType = "CPU";

static const char* const resourceTrackingEnabledSettingName = "resourceTrackingEnabled";

static const char* const debuggerEnabledSettingName = "debuggerEnabled";

static const char* const profilerEnabledSettingName = "profilerEnabled";

static const char* const inspectorAttachedHeightName = "inspectorAttachedHeight";

static const char* const lastActivePanelSettingName = "lastActivePanel";

static const char* const monitoringXHRSettingName = "xhrMonitor";

int connectedFrontendCount = 0;

const String& InspectorController::frontendSettingsSettingName()

{

    DEFINE_STATIC_LOCAL(String, settingName, ("frontendSettings"));

    return settingName;

}

const String& InspectorController::inspectorStartsAttachedSettingName()

{

    DEFINE_STATIC_LOCAL(String, settingName, ("inspectorStartsAttached"));

    return settingName;

}

static const unsigned defaultAttachedHeight = 300;

static const float minimumAttachedHeight = 250.0f;

static const float maximumAttachedHeightRatio = 0.75f;

static const unsigned maximumConsoleMessages = 1000;

static const unsigned expireConsoleMessagesStep = 100;

static unsigned s_inspectorControllerCount;

namespace {

String md5Base16(const String& string)

{

    static const char digits[] = "0123456789abcdef";

    MD5 md5;

    md5.addBytes(reinterpret_cast<const uint8_t*>(string.characters()), string.length() * 2);

    Vector<uint8_t, 16> digest;

    md5.checksum(digest);

    Vector<char, 32> result;

    for (int i = 0; i < 16; ++i) {

        result.append(digits[(digest[i] >> 4) & 0xf]);

        result.append(digits[digest[i] & 0xf]);

    }

    return String(result.data(), result.size());

}

String formatBreakpointId(const String& sourceID, unsigned lineNumber)

{

    return String::format("%s:%d", sourceID.utf8().data(), lineNumber);

}

}

InspectorController::InspectorController(Page* page, InspectorClient* client)

    : m_inspectedPage(page)

    , m_client(client)

    , m_openingFrontend(false)

    , m_cssStore(new InspectorCSSStore(this))

    , m_expiredConsoleMessageCount(0)

    , m_showAfterVisible(CurrentPanel)

    , m_sessionSettings(InspectorObject::create())

    , m_groupLevel(0)

    , m_searchingForNode(false)

    , m_monitoringXHR(false)

    , m_previousMessage(0)

    , m_resourceTrackingEnabled(false)

    , m_settingsLoaded(false)

    , m_inspectorBackend(InspectorBackend::create(this))

    , m_injectedScriptHost(InjectedScriptHost::create(this))

#if ENABLE(JAVASCRIPT_DEBUGGER)

    , m_debuggerEnabled(false)

    , m_attachDebuggerWhenShown(false)

    , m_pausedScriptState(0)

    , m_breakpointsLoaded(false)

    , m_profilerEnabled(!WTF_USE_JSC)

    , m_recordingUserInitiatedProfile(false)

    , m_currentUserInitiatedProfileNumber(-1)

    , m_nextUserInitiatedProfileNumber(1)

    , m_startProfiling(this, &InspectorController::startUserInitiatedProfiling)

#endif

{

    ASSERT_ARG(page, page);

    ASSERT_ARG(client, client);

    ++s_inspectorControllerCount;

}

InspectorController::~InspectorController()

{

    // These should have been cleared in inspectedPageDestroyed().

    ASSERT(!m_client);

    ASSERT(!m_inspectedPage);

    ASSERT(!m_highlightedNode);

    deleteAllValues(m_frameResources);

    ASSERT(s_inspectorControllerCount);

    --s_inspectorControllerCount;

    releaseFrontendLifetimeAgents();

    m_inspectorBackend->disconnectController();

    m_injectedScriptHost->disconnectController();

}

void InspectorController::inspectedPageDestroyed()

{

    if (m_frontend)

        m_frontend->inspectedPageDestroyed();

    hideHighlight();

    ASSERT(m_inspectedPage);

    m_inspectedPage = 0;

    m_client->inspectorDestroyed();

    m_client = 0;

}

bool InspectorController::enabled() const

{

    if (!m_inspectedPage)

        return false;

    return m_inspectedPage->settings()->developerExtrasEnabled();

}

String InspectorController::setting(const String& key) const

{

    Settings::iterator it = m_settings.find(key);

    if (it != m_settings.end())

        return it->second;

    String value;

    m_client->populateSetting(key, &value);

    m_settings.set(key, value);

    return value;

}

void InspectorController::setSetting(const String& key, const String& value)

{

    m_settings.set(key, value);

    m_client->storeSetting(key, value);

}

void InspectorController::saveApplicationSettings(const String& settings)

{

    setSetting(InspectorController::frontendSettingsSettingName(), settings);

}

void InspectorController::saveSessionSettings(const String& settingsJSON)

{

    m_sessionSettings = InspectorValue::parseJSON(settingsJSON);

}

void InspectorController::inspect(Node* node)

{

    if (!enabled())

        return;

    show();

    if (node->nodeType() != Node::ELEMENT_NODE && node->nodeType() != Node::DOCUMENT_NODE)

        node = node->parentNode();

    m_nodeToFocus = node;

    if (!m_frontend) {

        m_showAfterVisible = ElementsPanel;

        return;

    }

    focusNode();

}

void InspectorController::focusNode()

{

    if (!enabled())

        return;

    ASSERT(m_frontend);

    ASSERT(m_nodeToFocus);

    long id = m_domAgent->pushNodePathToFrontend(m_nodeToFocus.get());

    m_frontend->updateFocusedNode(id);

    m_nodeToFocus = 0;

}

void InspectorController::highlight(Node* node)

{

    if (!enabled())

        return;

    ASSERT_ARG(node, node);

    m_highlightedNode = node;

    m_client->highlight(node);

}

void InspectorController::highlightDOMNode(long nodeId)

{

    Node* node = 0;

    if (m_domAgent && (node = m_domAgent->nodeForId(nodeId)))

        highlight(node);

}

void InspectorController::hideHighlight()

{

    if (!enabled())

        return;

    m_highlightedNode = 0;

    m_client->hideHighlight();

}

bool InspectorController::windowVisible()

{

    return m_frontend;

}

void InspectorController::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, ScriptCallStack* callStack, const String& message)

{

    if (!enabled())

        return;

    bool storeStackTrace = type == TraceMessageType || type == UncaughtExceptionMessageType || type == AssertMessageType;

    addConsoleMessage(callStack->state(), new ConsoleMessage(source, type, level, message, callStack, m_groupLevel, storeStackTrace));

}

void InspectorController::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID)

{

    if (!enabled())

        return;

    addConsoleMessage(0, new ConsoleMessage(source, type, level, message, lineNumber, sourceID, m_groupLevel));

}

void InspectorController::addConsoleMessage(ScriptState* scriptState, PassOwnPtr<ConsoleMessage> consoleMessage)

{

    ASSERT(enabled());

    ASSERT_ARG(consoleMessage, consoleMessage);

    if (m_previousMessage && m_previousMessage->isEqual(scriptState, consoleMessage.get())) {

        m_previousMessage->incrementCount();

        if (m_frontend)

            m_previousMessage->updateRepeatCountInConsole(m_frontend.get());

    } else {

        m_previousMessage = consoleMessage.get();

        m_consoleMessages.append(consoleMessage);

        if (m_frontend)

            m_previousMessage->addToFrontend(m_frontend.get(), m_injectedScriptHost.get());

    }

    if (!m_frontend && m_consoleMessages.size() >= maximumConsoleMessages) {

        m_expiredConsoleMessageCount += expireConsoleMessagesStep;

        m_consoleMessages.remove(0, expireConsoleMessagesStep);

    }

}

void InspectorController::clearConsoleMessages()

{

    m_consoleMessages.clear();

    m_expiredConsoleMessageCount = 0;

    m_previousMessage = 0;

    m_groupLevel = 0;

    m_injectedScriptHost->releaseWrapperObjectGroup(0 /* release the group in all scripts */, "console");

    if (m_domAgent)

        m_domAgent->releaseDanglingNodes();

    if (m_frontend)

        m_frontend->clearConsoleMessages();

}

void InspectorController::startGroup(MessageSource source, ScriptCallStack* callStack, bool collapsed)

{

    ++m_groupLevel;

    addConsoleMessage(callStack->state(), new ConsoleMessage(source, collapsed ? StartGroupCollapsedMessageType : StartGroupMessageType, LogMessageLevel, String(), callStack, m_groupLevel));

}

void InspectorController::endGroup(MessageSource source, unsigned lineNumber, const String& sourceURL)

{

    if (!m_groupLevel)

        return;

    --m_groupLevel;

    addConsoleMessage(0, new ConsoleMessage(source, EndGroupMessageType, LogMessageLevel, String(), lineNumber, sourceURL, m_groupLevel));

}

void InspectorController::markTimeline(const String& message)

{

    if (timelineAgent())

        timelineAgent()->didMarkTimeline(message);

}

void InspectorController::storeLastActivePanel(const String& panelName)

{

    setSetting(lastActivePanelSettingName, panelName);

}

void InspectorController::mouseDidMoveOverElement(const HitTestResult& result, unsigned)

{

    if (!enabled() || !m_searchingForNode)

        return;

    Node* node = result.innerNode();

    while (node && node->nodeType() == Node::TEXT_NODE)

        node = node->parentNode();

    if (node)

        highlight(node);

}

void InspectorController::handleMousePress()

{

    if (!enabled())

        return;

    ASSERT(m_searchingForNode);

    if (!m_highlightedNode)

        return;

    RefPtr<Node> node = m_highlightedNode;

    setSearchingForNode(false);

    inspect(node.get());

}

void InspectorController::setInspectorFrontendClient(PassOwnPtr<InspectorFrontendClient> client)

{

    ASSERT(!m_inspectorFrontendClient);

    m_inspectorFrontendClient = client;

}

void InspectorController::inspectedWindowScriptObjectCleared(Frame* frame)

{

    // If the page is supposed to serve as InspectorFrontend notify inspetor frontend

    // client that it's cleared so that the client can expose inspector bindings.

    if (m_inspectorFrontendClient && frame == m_inspectedPage->mainFrame())

        m_inspectorFrontendClient->windowObjectCleared();

    if (!enabled() || !m_frontend || frame != m_inspectedPage->mainFrame())

        return;

    m_injectedScriptHost->discardInjectedScripts();

}

void InspectorController::setSearchingForNode(bool enabled)

{

    if (m_searchingForNode == enabled)

        return;

    m_searchingForNode = enabled;

    if (!m_searchingForNode)

        hideHighlight();

    if (m_frontend) {

        if (enabled)

            m_frontend->searchingForNodeWasEnabled();

        else

            m_frontend->searchingForNodeWasDisabled();

    }

}

void InspectorController::setMonitoringXHR(bool enabled)

{

    if (m_monitoringXHR == enabled)

        return;

    m_monitoringXHR = enabled;

    setSetting(monitoringXHRSettingName, enabled ? "true" : "false");

    if (m_frontend) {

        if (enabled)

            m_frontend->monitoringXHRWasEnabled();

        else

            m_frontend->monitoringXHRWasDisabled();

    }

}

void InspectorController::connectFrontend(const ScriptObject& webInspector)

{

    m_openingFrontend = false;

    releaseFrontendLifetimeAgents();

    m_frontend = new InspectorFrontend(webInspector, m_client);

    m_remoteFrontend = new RemoteInspectorFrontend(m_client);

    m_domAgent = InspectorDOMAgent::create(m_cssStore.get(), m_remoteFrontend.get());

    if (m_timelineAgent)

        m_timelineAgent->resetFrontendProxyObject(m_remoteFrontend.get());

    // Initialize Web Inspector title.

    m_frontend->inspectedURLChanged(m_inspectedPage->mainFrame()->loader()->url().string());

    populateScriptObjects();

#if ENABLE(JAVASCRIPT_DEBUGGER)

    if (ScriptDebugServer::shared().isDebuggerAlwaysEnabled()) {

        // FIXME (40364): This will force pushing script sources to frontend even if script

        // panel is inactive.

        enableDebuggerFromFrontend(false);

    } else {

        String debuggerEnabled = setting(debuggerEnabledSettingName);

        if (debuggerEnabled == "true" || m_attachDebuggerWhenShown)

            enableDebugger();

        String profilerEnabled = setting(profilerEnabledSettingName);

        if (profilerEnabled == "true")

            enableProfiler();

    }

#endif

    if (m_showAfterVisible == CurrentPanel) {

        String lastActivePanelSetting = setting(lastActivePanelSettingName);

        m_showAfterVisible = specialPanelForJSName(lastActivePanelSetting);

    }

    if (m_nodeToFocus)