// File is generated by Source/WebCore/inspector/CodeGeneratorInspector.py

// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.


#include "config.h"
#include "InspectorFrontend.h"
#include <wtf/text/WTFString.h>
#include <wtf/text/CString.h>

#if ENABLE(INSPECTOR)

#include "InspectorFrontendChannel.h"
#include "InspectorValues.h"
#include <wtf/text/WTFString.h>

namespace WebCore {

InspectorFrontend::InspectorFrontend(InspectorFrontendChannel* inspectorFrontendChannel)
    : m_inspectorFrontendChannel(inspectorFrontendChannel)
    , m_inspector(inspectorFrontendChannel)
    , m_memory(inspectorFrontendChannel)
    , m_page(inspectorFrontendChannel)
    , m_runtime(inspectorFrontendChannel)
    , m_console(inspectorFrontendChannel)
    , m_network(inspectorFrontendChannel)
#if ENABLE(SQL_DATABASE)
    , m_database(inspectorFrontendChannel)
#endif // ENABLE(SQL_DATABASE)
    , m_domstorage(inspectorFrontendChannel)
    , m_applicationcache(inspectorFrontendChannel)
#if ENABLE(FILE_SYSTEM)
    , m_filesystem(inspectorFrontendChannel)
#endif // ENABLE(FILE_SYSTEM)
    , m_dom(inspectorFrontendChannel)
    , m_css(inspectorFrontendChannel)
    , m_timeline(inspectorFrontendChannel)
#if ENABLE(JAVASCRIPT_DEBUGGER)
    , m_debugger(inspectorFrontendChannel)
#endif // ENABLE(JAVASCRIPT_DEBUGGER)
#if ENABLE(JAVASCRIPT_DEBUGGER)
    , m_domdebugger(inspectorFrontendChannel)
#endif // ENABLE(JAVASCRIPT_DEBUGGER)
#if ENABLE(JAVASCRIPT_DEBUGGER)
    , m_profiler(inspectorFrontendChannel)
#endif // ENABLE(JAVASCRIPT_DEBUGGER)
#if ENABLE(WORKERS)
    , m_worker(inspectorFrontendChannel)
#endif // ENABLE(WORKERS)
{
}

void InspectorFrontend::Inspector::evaluateForTestInFrontend(int testCallId, const String& script)
{
    RefPtr<InspectorObject> evaluateForTestInFrontendMessage = InspectorObject::create();
    evaluateForTestInFrontendMessage->setString("method", "Inspector.evaluateForTestInFrontend");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("testCallId", testCallId);
    paramsObject->setString("script", script);
    evaluateForTestInFrontendMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(evaluateForTestInFrontendMessage->toJSONString());
}

void InspectorFrontend::Inspector::inspect(/*PassRefPtr<TypeBuilder::Runtime::RemoteObject>*/ PassRefPtr<InspectorObject> object, PassRefPtr<InspectorObject> hints)
{
    RefPtr<InspectorObject> inspectMessage = InspectorObject::create();
    inspectMessage->setString("method", "Inspector.inspect");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("object", object);
    paramsObject->setObject("hints", hints);
    inspectMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(inspectMessage->toJSONString());
}

void InspectorFrontend::Inspector::didCreateWorker(int id, const String& url, bool isShared)
{
    RefPtr<InspectorObject> didCreateWorkerMessage = InspectorObject::create();
    didCreateWorkerMessage->setString("method", "Inspector.didCreateWorker");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("id", id);
    paramsObject->setString("url", url);
    paramsObject->setBoolean("isShared", isShared);
    didCreateWorkerMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(didCreateWorkerMessage->toJSONString());
}

void InspectorFrontend::Inspector::didDestroyWorker(int id)
{
    RefPtr<InspectorObject> didDestroyWorkerMessage = InspectorObject::create();
    didDestroyWorkerMessage->setString("method", "Inspector.didDestroyWorker");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("id", id);
    didDestroyWorkerMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(didDestroyWorkerMessage->toJSONString());
}

void InspectorFrontend::Page::domContentEventFired(double timestamp)
{
    RefPtr<InspectorObject> domContentEventFiredMessage = InspectorObject::create();
    domContentEventFiredMessage->setString("method", "Page.domContentEventFired");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("timestamp", timestamp);
    domContentEventFiredMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(domContentEventFiredMessage->toJSONString());
}

void InspectorFrontend::Page::loadEventFired(double timestamp)
{
    RefPtr<InspectorObject> loadEventFiredMessage = InspectorObject::create();
    loadEventFiredMessage->setString("method", "Page.loadEventFired");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("timestamp", timestamp);
    loadEventFiredMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(loadEventFiredMessage->toJSONString());
}

void InspectorFrontend::Page::frameNavigated(/*PassRefPtr<TypeBuilder::Page::Frame>*/ PassRefPtr<InspectorObject> frame)
{
    RefPtr<InspectorObject> frameNavigatedMessage = InspectorObject::create();
    frameNavigatedMessage->setString("method", "Page.frameNavigated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("frame", frame);
    frameNavigatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(frameNavigatedMessage->toJSONString());
}

void InspectorFrontend::Page::frameDetached(const String& frameId)
{
    RefPtr<InspectorObject> frameDetachedMessage = InspectorObject::create();
    frameDetachedMessage->setString("method", "Page.frameDetached");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("frameId", frameId);
    frameDetachedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(frameDetachedMessage->toJSONString());
}

void InspectorFrontend::Console::messageAdded(/*PassRefPtr<TypeBuilder::Console::ConsoleMessage>*/ PassRefPtr<InspectorObject> message)
{
    RefPtr<InspectorObject> messageAddedMessage = InspectorObject::create();
    messageAddedMessage->setString("method", "Console.messageAdded");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("message", message);
    messageAddedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(messageAddedMessage->toJSONString());
}

void InspectorFrontend::Console::messageRepeatCountUpdated(int count)
{
    RefPtr<InspectorObject> messageRepeatCountUpdatedMessage = InspectorObject::create();
    messageRepeatCountUpdatedMessage->setString("method", "Console.messageRepeatCountUpdated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("count", count);
    messageRepeatCountUpdatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(messageRepeatCountUpdatedMessage->toJSONString());
}

void InspectorFrontend::Console::messagesCleared()
{
    RefPtr<InspectorObject> messagesClearedMessage = InspectorObject::create();
    messagesClearedMessage->setString("method", "Console.messagesCleared");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(messagesClearedMessage->toJSONString());
}

void InspectorFrontend::Network::requestWillBeSent(const String& requestId, const String& frameId, const String& loaderId, const String& documentURL, /*PassRefPtr<TypeBuilder::Network::Request>*/ PassRefPtr<InspectorObject> request, double timestamp, /*PassRefPtr<TypeBuilder::Network::Initiator>*/ PassRefPtr<InspectorObject> initiator, PassRefPtr<InspectorArray> stackTrace, /*PassRefPtr<TypeBuilder::Network::Response>*/ PassRefPtr<InspectorObject> redirectResponse)
{
    RefPtr<InspectorObject> requestWillBeSentMessage = InspectorObject::create();
    requestWillBeSentMessage->setString("method", "Network.requestWillBeSent");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setString("frameId", frameId);
    paramsObject->setString("loaderId", loaderId);
    paramsObject->setString("documentURL", documentURL);
    paramsObject->setObject("request", request);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setObject("initiator", initiator);
    if (stackTrace)
        paramsObject->setArray("stackTrace", stackTrace);
    if (redirectResponse)
        paramsObject->setObject("redirectResponse", redirectResponse);
    requestWillBeSentMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(requestWillBeSentMessage->toJSONString());
}

void InspectorFrontend::Network::requestServedFromCache(const String& requestId)
{
    RefPtr<InspectorObject> requestServedFromCacheMessage = InspectorObject::create();
    requestServedFromCacheMessage->setString("method", "Network.requestServedFromCache");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    requestServedFromCacheMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(requestServedFromCacheMessage->toJSONString());
}

void InspectorFrontend::Network::responseReceived(const String& requestId, const String& frameId, const String& loaderId, double timestamp, const String& type, /*PassRefPtr<TypeBuilder::Network::Response>*/ PassRefPtr<InspectorObject> response)
{
    RefPtr<InspectorObject> responseReceivedMessage = InspectorObject::create();
    responseReceivedMessage->setString("method", "Network.responseReceived");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setString("frameId", frameId);
    paramsObject->setString("loaderId", loaderId);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setString("type", type);
    paramsObject->setObject("response", response);
    responseReceivedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(responseReceivedMessage->toJSONString());
}

void InspectorFrontend::Network::dataReceived(const String& requestId, double timestamp, int dataLength, int encodedDataLength)
{
    RefPtr<InspectorObject> dataReceivedMessage = InspectorObject::create();
    dataReceivedMessage->setString("method", "Network.dataReceived");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setNumber("dataLength", dataLength);
    paramsObject->setNumber("encodedDataLength", encodedDataLength);
    dataReceivedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(dataReceivedMessage->toJSONString());
}

void InspectorFrontend::Network::loadingFinished(const String& requestId, double timestamp)
{
    RefPtr<InspectorObject> loadingFinishedMessage = InspectorObject::create();
    loadingFinishedMessage->setString("method", "Network.loadingFinished");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setNumber("timestamp", timestamp);
    loadingFinishedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(loadingFinishedMessage->toJSONString());
}

void InspectorFrontend::Network::loadingFailed(const String& requestId, double timestamp, const String& errorText, const bool* const canceled)
{
    RefPtr<InspectorObject> loadingFailedMessage = InspectorObject::create();
    loadingFailedMessage->setString("method", "Network.loadingFailed");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setString("errorText", errorText);
    if (canceled)
        paramsObject->setBoolean("canceled", *canceled);
    loadingFailedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(loadingFailedMessage->toJSONString());
}

void InspectorFrontend::Network::requestServedFromMemoryCache(const String& requestId, const String& frameId, const String& loaderId, const String& documentURL, double timestamp, /*PassRefPtr<TypeBuilder::Network::Initiator>*/ PassRefPtr<InspectorObject> initiator, /*PassRefPtr<TypeBuilder::Network::CachedResource>*/ PassRefPtr<InspectorObject> resource)
{
    RefPtr<InspectorObject> requestServedFromMemoryCacheMessage = InspectorObject::create();
    requestServedFromMemoryCacheMessage->setString("method", "Network.requestServedFromMemoryCache");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setString("frameId", frameId);
    paramsObject->setString("loaderId", loaderId);
    paramsObject->setString("documentURL", documentURL);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setObject("initiator", initiator);
    paramsObject->setObject("resource", resource);
    requestServedFromMemoryCacheMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(requestServedFromMemoryCacheMessage->toJSONString());
}

void InspectorFrontend::Network::webSocketWillSendHandshakeRequest(const String& requestId, double timestamp, /*PassRefPtr<TypeBuilder::Network::WebSocketRequest>*/ PassRefPtr<InspectorObject> request)
{
    RefPtr<InspectorObject> webSocketWillSendHandshakeRequestMessage = InspectorObject::create();
    webSocketWillSendHandshakeRequestMessage->setString("method", "Network.webSocketWillSendHandshakeRequest");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setObject("request", request);
    webSocketWillSendHandshakeRequestMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(webSocketWillSendHandshakeRequestMessage->toJSONString());
}

void InspectorFrontend::Network::webSocketHandshakeResponseReceived(const String& requestId, double timestamp, /*PassRefPtr<TypeBuilder::Network::WebSocketResponse>*/ PassRefPtr<InspectorObject> response)
{
    RefPtr<InspectorObject> webSocketHandshakeResponseReceivedMessage = InspectorObject::create();
    webSocketHandshakeResponseReceivedMessage->setString("method", "Network.webSocketHandshakeResponseReceived");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setNumber("timestamp", timestamp);
    paramsObject->setObject("response", response);
    webSocketHandshakeResponseReceivedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(webSocketHandshakeResponseReceivedMessage->toJSONString());
}

void InspectorFrontend::Network::webSocketCreated(const String& requestId, const String& url)
{
    RefPtr<InspectorObject> webSocketCreatedMessage = InspectorObject::create();
    webSocketCreatedMessage->setString("method", "Network.webSocketCreated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setString("url", url);
    webSocketCreatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(webSocketCreatedMessage->toJSONString());
}

void InspectorFrontend::Network::webSocketClosed(const String& requestId, double timestamp)
{
    RefPtr<InspectorObject> webSocketClosedMessage = InspectorObject::create();
    webSocketClosedMessage->setString("method", "Network.webSocketClosed");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("requestId", requestId);
    paramsObject->setNumber("timestamp", timestamp);
    webSocketClosedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(webSocketClosedMessage->toJSONString());
}

#if ENABLE(SQL_DATABASE)

void InspectorFrontend::Database::addDatabase(/*PassRefPtr<TypeBuilder::Database::Database>*/ PassRefPtr<InspectorObject> database)
{
    RefPtr<InspectorObject> addDatabaseMessage = InspectorObject::create();
    addDatabaseMessage->setString("method", "Database.addDatabase");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("database", database);
    addDatabaseMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(addDatabaseMessage->toJSONString());
}

void InspectorFrontend::Database::sqlTransactionSucceeded(int transactionId, PassRefPtr<InspectorArray> columnNames, PassRefPtr<InspectorArray> values)
{
    RefPtr<InspectorObject> sqlTransactionSucceededMessage = InspectorObject::create();
    sqlTransactionSucceededMessage->setString("method", "Database.sqlTransactionSucceeded");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("transactionId", transactionId);
    paramsObject->setArray("columnNames", columnNames);
    paramsObject->setArray("values", values);
    sqlTransactionSucceededMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(sqlTransactionSucceededMessage->toJSONString());
}

void InspectorFrontend::Database::sqlTransactionFailed(int transactionId, PassRefPtr<InspectorObject> sqlError)
{
    RefPtr<InspectorObject> sqlTransactionFailedMessage = InspectorObject::create();
    sqlTransactionFailedMessage->setString("method", "Database.sqlTransactionFailed");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("transactionId", transactionId);
    paramsObject->setObject("sqlError", sqlError);
    sqlTransactionFailedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(sqlTransactionFailedMessage->toJSONString());
}

#endif // ENABLE(SQL_DATABASE)

void InspectorFrontend::DOMStorage::addDOMStorage(/*PassRefPtr<TypeBuilder::DOMStorage::Entry>*/ PassRefPtr<InspectorObject> storage)
{
    RefPtr<InspectorObject> addDOMStorageMessage = InspectorObject::create();
    addDOMStorageMessage->setString("method", "DOMStorage.addDOMStorage");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("storage", storage);
    addDOMStorageMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(addDOMStorageMessage->toJSONString());
}

void InspectorFrontend::DOMStorage::updateDOMStorage(int storageId)
{
    RefPtr<InspectorObject> updateDOMStorageMessage = InspectorObject::create();
    updateDOMStorageMessage->setString("method", "DOMStorage.updateDOMStorage");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("storageId", storageId);
    updateDOMStorageMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(updateDOMStorageMessage->toJSONString());
}

void InspectorFrontend::ApplicationCache::applicationCacheStatusUpdated(const String& frameId, const String& manifestURL, int status)
{
    RefPtr<InspectorObject> applicationCacheStatusUpdatedMessage = InspectorObject::create();
    applicationCacheStatusUpdatedMessage->setString("method", "ApplicationCache.applicationCacheStatusUpdated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("frameId", frameId);
    paramsObject->setString("manifestURL", manifestURL);
    paramsObject->setNumber("status", status);
    applicationCacheStatusUpdatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(applicationCacheStatusUpdatedMessage->toJSONString());
}

void InspectorFrontend::ApplicationCache::networkStateUpdated(bool isNowOnline)
{
    RefPtr<InspectorObject> networkStateUpdatedMessage = InspectorObject::create();
    networkStateUpdatedMessage->setString("method", "ApplicationCache.networkStateUpdated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setBoolean("isNowOnline", isNowOnline);
    networkStateUpdatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(networkStateUpdatedMessage->toJSONString());
}

#if ENABLE(FILE_SYSTEM)

#endif // ENABLE(FILE_SYSTEM)

void InspectorFrontend::DOM::documentUpdated()
{
    RefPtr<InspectorObject> documentUpdatedMessage = InspectorObject::create();
    documentUpdatedMessage->setString("method", "DOM.documentUpdated");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(documentUpdatedMessage->toJSONString());
}

void InspectorFrontend::DOM::setChildNodes(int parentId, PassRefPtr<InspectorArray> nodes)
{
    RefPtr<InspectorObject> setChildNodesMessage = InspectorObject::create();
    setChildNodesMessage->setString("method", "DOM.setChildNodes");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("parentId", parentId);
    paramsObject->setArray("nodes", nodes);
    setChildNodesMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(setChildNodesMessage->toJSONString());
}

void InspectorFrontend::DOM::attributeModified(int nodeId, const String& name, const String& value)
{
    RefPtr<InspectorObject> attributeModifiedMessage = InspectorObject::create();
    attributeModifiedMessage->setString("method", "DOM.attributeModified");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("nodeId", nodeId);
    paramsObject->setString("name", name);
    paramsObject->setString("value", value);
    attributeModifiedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(attributeModifiedMessage->toJSONString());
}

void InspectorFrontend::DOM::attributeRemoved(int nodeId, const String& name)
{
    RefPtr<InspectorObject> attributeRemovedMessage = InspectorObject::create();
    attributeRemovedMessage->setString("method", "DOM.attributeRemoved");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("nodeId", nodeId);
    paramsObject->setString("name", name);
    attributeRemovedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(attributeRemovedMessage->toJSONString());
}

void InspectorFrontend::DOM::inlineStyleInvalidated(PassRefPtr<InspectorArray> nodeIds)
{
    RefPtr<InspectorObject> inlineStyleInvalidatedMessage = InspectorObject::create();
    inlineStyleInvalidatedMessage->setString("method", "DOM.inlineStyleInvalidated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setArray("nodeIds", nodeIds);
    inlineStyleInvalidatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(inlineStyleInvalidatedMessage->toJSONString());
}

void InspectorFrontend::DOM::characterDataModified(int nodeId, const String& characterData)
{
    RefPtr<InspectorObject> characterDataModifiedMessage = InspectorObject::create();
    characterDataModifiedMessage->setString("method", "DOM.characterDataModified");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("nodeId", nodeId);
    paramsObject->setString("characterData", characterData);
    characterDataModifiedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(characterDataModifiedMessage->toJSONString());
}

void InspectorFrontend::DOM::childNodeCountUpdated(int nodeId, int childNodeCount)
{
    RefPtr<InspectorObject> childNodeCountUpdatedMessage = InspectorObject::create();
    childNodeCountUpdatedMessage->setString("method", "DOM.childNodeCountUpdated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("nodeId", nodeId);
    paramsObject->setNumber("childNodeCount", childNodeCount);
    childNodeCountUpdatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(childNodeCountUpdatedMessage->toJSONString());
}

void InspectorFrontend::DOM::childNodeInserted(int parentNodeId, int previousNodeId, /*PassRefPtr<TypeBuilder::DOM::Node>*/ PassRefPtr<InspectorObject> node)
{
    RefPtr<InspectorObject> childNodeInsertedMessage = InspectorObject::create();
    childNodeInsertedMessage->setString("method", "DOM.childNodeInserted");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("parentNodeId", parentNodeId);
    paramsObject->setNumber("previousNodeId", previousNodeId);
    paramsObject->setObject("node", node);
    childNodeInsertedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(childNodeInsertedMessage->toJSONString());
}

void InspectorFrontend::DOM::childNodeRemoved(int parentNodeId, int nodeId)
{
    RefPtr<InspectorObject> childNodeRemovedMessage = InspectorObject::create();
    childNodeRemovedMessage->setString("method", "DOM.childNodeRemoved");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("parentNodeId", parentNodeId);
    paramsObject->setNumber("nodeId", nodeId);
    childNodeRemovedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(childNodeRemovedMessage->toJSONString());
}

void InspectorFrontend::CSS::mediaQueryResultChanged()
{
    RefPtr<InspectorObject> mediaQueryResultChangedMessage = InspectorObject::create();
    mediaQueryResultChangedMessage->setString("method", "CSS.mediaQueryResultChanged");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(mediaQueryResultChangedMessage->toJSONString());
}

void InspectorFrontend::Timeline::eventRecorded(/*PassRefPtr<TypeBuilder::Timeline::TimelineEvent>*/ PassRefPtr<InspectorObject> record)
{
    RefPtr<InspectorObject> eventRecordedMessage = InspectorObject::create();
    eventRecordedMessage->setString("method", "Timeline.eventRecorded");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("record", record);
    eventRecordedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(eventRecordedMessage->toJSONString());
}

#if ENABLE(JAVASCRIPT_DEBUGGER)

void InspectorFrontend::Debugger::globalObjectCleared()
{
    RefPtr<InspectorObject> globalObjectClearedMessage = InspectorObject::create();
    globalObjectClearedMessage->setString("method", "Debugger.globalObjectCleared");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(globalObjectClearedMessage->toJSONString());
}

void InspectorFrontend::Debugger::scriptParsed(const String& scriptId, const String& url, int startLine, int startColumn, int endLine, int endColumn, const bool* const isContentScript, const String& sourceMapURL)
{
    RefPtr<InspectorObject> scriptParsedMessage = InspectorObject::create();
    scriptParsedMessage->setString("method", "Debugger.scriptParsed");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("scriptId", scriptId);
    paramsObject->setString("url", url);
    paramsObject->setNumber("startLine", startLine);
    paramsObject->setNumber("startColumn", startColumn);
    paramsObject->setNumber("endLine", endLine);
    paramsObject->setNumber("endColumn", endColumn);
    if (isContentScript)
        paramsObject->setBoolean("isContentScript", *isContentScript);
    paramsObject->setString("sourceMapURL", sourceMapURL);
    scriptParsedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(scriptParsedMessage->toJSONString());
}

void InspectorFrontend::Debugger::scriptFailedToParse(const String& url, const String& scriptSource, int startLine, int errorLine, const String& errorMessage)
{
    RefPtr<InspectorObject> scriptFailedToParseMessage = InspectorObject::create();
    scriptFailedToParseMessage->setString("method", "Debugger.scriptFailedToParse");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("url", url);
    paramsObject->setString("scriptSource", scriptSource);
    paramsObject->setNumber("startLine", startLine);
    paramsObject->setNumber("errorLine", errorLine);
    paramsObject->setString("errorMessage", errorMessage);
    scriptFailedToParseMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(scriptFailedToParseMessage->toJSONString());
}

void InspectorFrontend::Debugger::breakpointResolved(const String& breakpointId, /*PassRefPtr<TypeBuilder::Debugger::Location>*/ PassRefPtr<InspectorObject> location)
{
    RefPtr<InspectorObject> breakpointResolvedMessage = InspectorObject::create();
    breakpointResolvedMessage->setString("method", "Debugger.breakpointResolved");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setString("breakpointId", breakpointId);
    paramsObject->setObject("location", location);
    breakpointResolvedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(breakpointResolvedMessage->toJSONString());
}

void InspectorFrontend::Debugger::paused(PassRefPtr<InspectorArray> callFrames, const String& reason, PassRefPtr<InspectorObject> data)
{
    RefPtr<InspectorObject> pausedMessage = InspectorObject::create();
    pausedMessage->setString("method", "Debugger.paused");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setArray("callFrames", callFrames);
    paramsObject->setString("reason", reason);
    if (data)
        paramsObject->setObject("data", data);
    pausedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(pausedMessage->toJSONString());
}

void InspectorFrontend::Debugger::resumed()
{
    RefPtr<InspectorObject> resumedMessage = InspectorObject::create();
    resumedMessage->setString("method", "Debugger.resumed");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(resumedMessage->toJSONString());
}

#endif // ENABLE(JAVASCRIPT_DEBUGGER)

#if ENABLE(JAVASCRIPT_DEBUGGER)

#endif // ENABLE(JAVASCRIPT_DEBUGGER)

#if ENABLE(JAVASCRIPT_DEBUGGER)

void InspectorFrontend::Profiler::addProfileHeader(PassRefPtr<InspectorObject> header)
{
    RefPtr<InspectorObject> addProfileHeaderMessage = InspectorObject::create();
    addProfileHeaderMessage->setString("method", "Profiler.addProfileHeader");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setObject("header", header);
    addProfileHeaderMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(addProfileHeaderMessage->toJSONString());
}

void InspectorFrontend::Profiler::addHeapSnapshotChunk(int uid, const String& chunk)
{
    RefPtr<InspectorObject> addHeapSnapshotChunkMessage = InspectorObject::create();
    addHeapSnapshotChunkMessage->setString("method", "Profiler.addHeapSnapshotChunk");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("uid", uid);
    paramsObject->setString("chunk", chunk);
    addHeapSnapshotChunkMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(addHeapSnapshotChunkMessage->toJSONString());
}

void InspectorFrontend::Profiler::finishHeapSnapshot(int uid)
{
    RefPtr<InspectorObject> finishHeapSnapshotMessage = InspectorObject::create();
    finishHeapSnapshotMessage->setString("method", "Profiler.finishHeapSnapshot");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("uid", uid);
    finishHeapSnapshotMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(finishHeapSnapshotMessage->toJSONString());
}

void InspectorFrontend::Profiler::setRecordingProfile(bool isProfiling)
{
    RefPtr<InspectorObject> setRecordingProfileMessage = InspectorObject::create();
    setRecordingProfileMessage->setString("method", "Profiler.setRecordingProfile");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setBoolean("isProfiling", isProfiling);
    setRecordingProfileMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(setRecordingProfileMessage->toJSONString());
}

void InspectorFrontend::Profiler::resetProfiles()
{
    RefPtr<InspectorObject> resetProfilesMessage = InspectorObject::create();
    resetProfilesMessage->setString("method", "Profiler.resetProfiles");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(resetProfilesMessage->toJSONString());
}

void InspectorFrontend::Profiler::reportHeapSnapshotProgress(int done, int total)
{
    RefPtr<InspectorObject> reportHeapSnapshotProgressMessage = InspectorObject::create();
    reportHeapSnapshotProgressMessage->setString("method", "Profiler.reportHeapSnapshotProgress");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("done", done);
    paramsObject->setNumber("total", total);
    reportHeapSnapshotProgressMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(reportHeapSnapshotProgressMessage->toJSONString());
}

#endif // ENABLE(JAVASCRIPT_DEBUGGER)

#if ENABLE(WORKERS)

void InspectorFrontend::Worker::workerCreated(int workerId, const String& url, bool inspectorConnected)
{
    RefPtr<InspectorObject> workerCreatedMessage = InspectorObject::create();
    workerCreatedMessage->setString("method", "Worker.workerCreated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("workerId", workerId);
    paramsObject->setString("url", url);
    paramsObject->setBoolean("inspectorConnected", inspectorConnected);
    workerCreatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(workerCreatedMessage->toJSONString());
}

void InspectorFrontend::Worker::workerTerminated(int workerId)
{
    RefPtr<InspectorObject> workerTerminatedMessage = InspectorObject::create();
    workerTerminatedMessage->setString("method", "Worker.workerTerminated");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("workerId", workerId);
    workerTerminatedMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(workerTerminatedMessage->toJSONString());
}

void InspectorFrontend::Worker::dispatchMessageFromWorker(int workerId, PassRefPtr<InspectorObject> message)
{
    RefPtr<InspectorObject> dispatchMessageFromWorkerMessage = InspectorObject::create();
    dispatchMessageFromWorkerMessage->setString("method", "Worker.dispatchMessageFromWorker");
    RefPtr<InspectorObject> paramsObject = InspectorObject::create();
    paramsObject->setNumber("workerId", workerId);
    paramsObject->setObject("message", message);
    dispatchMessageFromWorkerMessage->setObject("params", paramsObject);
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(dispatchMessageFromWorkerMessage->toJSONString());
}

void InspectorFrontend::Worker::disconnectedFromWorker()
{
    RefPtr<InspectorObject> disconnectedFromWorkerMessage = InspectorObject::create();
    disconnectedFromWorkerMessage->setString("method", "Worker.disconnectedFromWorker");
    if (m_inspectorFrontendChannel)
        m_inspectorFrontendChannel->sendMessageToFrontend(disconnectedFromWorkerMessage->toJSONString());
}

#endif // ENABLE(WORKERS)


} // namespace WebCore

#endif // ENABLE(INSPECTOR)