void InspectorFrontend::DOM::shadowRootPushed(int hostId, PassRefPtr<TypeBuilder::DOM::Node> root)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "DOM.shadowRootPushed");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("hostId", hostId);
paramsObject->setValue("root", root);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
static PassRefPtr<InspectorObject> buildObjectForCachedResource(const CachedResource& cachedResource, DocumentLoader* loader)
{
RefPtr<InspectorObject> resourceObject = InspectorObject::create();
resourceObject->setString("url", cachedResource.url());
resourceObject->setString("type", InspectorPageAgent::cachedResourceTypeString(cachedResource));
resourceObject->setNumber("bodySize", cachedResource.encodedSize());
RefPtr<InspectorObject> resourceResponse = buildObjectForResourceResponse(cachedResource.response(), loader);
if (resourceResponse)
resourceObject->setObject("response", resourceResponse);
return resourceObject;
}
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::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());
}
void InspectorFrontend::DOM::characterDataModified(int nodeId, const String& characterData)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "DOM.characterDataModified");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("nodeId", nodeId);
paramsObject->setString("characterData", characterData);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void LoggingCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, const SkPaint& paint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawPosTextH");
params->setString("text", stringForText(text, byteLength, paint));
size_t pointsCount = paint.countText(text, byteLength);
params->setArray("xpos", arrayForSkScalars(pointsCount, xpos));
params->setNumber("constY", constY);
params->setObject("paint", objectForSkPaint(paint));
this->SkCanvas::onDrawPosTextH(text, byteLength, xpos, constY, paint);
}
void InspectorCSSAgent::getStylesForNode(long nodeId, RefPtr<InspectorValue>* result)
{
Element* element = elementForId(nodeId);
if (!element)
return;
RefPtr<InspectorObject> resultObject = InspectorObject::create();
InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(element);
if (styleSheet)
resultObject->setObject("inlineStyle", styleSheet->buildObjectForStyle(element->style()));
RefPtr<CSSComputedStyleDeclaration> computedStyleInfo = computedStyle(element, true); // Support the viewing of :visited information in computed style.
RefPtr<InspectorStyle> computedInspectorStyle = InspectorStyle::create(InspectorCSSId(), computedStyleInfo, 0);
resultObject->setObject("computedStyle", computedInspectorStyle->buildObjectForStyle());
CSSStyleSelector* selector = element->ownerDocument()->styleSelector();
RefPtr<CSSRuleList> matchedRules = selector->styleRulesForElement(element, false, true);
resultObject->setArray("matchedCSSRules", buildArrayForRuleList(matchedRules.get()));
resultObject->setObject("styleAttributes", buildObjectForAttributeStyles(element));
RefPtr<InspectorArray> pseudoElements = InspectorArray::create();
for (PseudoId pseudoId = FIRST_PUBLIC_PSEUDOID; pseudoId < AFTER_LAST_INTERNAL_PSEUDOID; pseudoId = static_cast<PseudoId>(pseudoId + 1)) {
RefPtr<CSSRuleList> matchedRules = selector->pseudoStyleRulesForElement(element, pseudoId, false, true);
if (matchedRules && matchedRules->length()) {
RefPtr<InspectorObject> pseudoStyles = InspectorObject::create();
pseudoStyles->setNumber("pseudoId", static_cast<int>(pseudoId));
pseudoStyles->setArray("rules", buildArrayForRuleList(matchedRules.get()));
pseudoElements->pushObject(pseudoStyles.release());
}
}
resultObject->setArray("pseudoElements", pseudoElements.release());
RefPtr<InspectorArray> inheritedStyles = InspectorArray::create();
Element* parentElement = element->parentElement();
while (parentElement) {
RefPtr<InspectorObject> parentStyle = InspectorObject::create();
if (parentElement->style() && parentElement->style()->length()) {
InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(parentElement);
if (styleSheet)
parentStyle->setObject("inlineStyle", styleSheet->buildObjectForStyle(styleSheet->styleForId(InspectorCSSId(styleSheet->id(), 0))));
}
CSSStyleSelector* parentSelector = parentElement->ownerDocument()->styleSelector();
RefPtr<CSSRuleList> parentMatchedRules = parentSelector->styleRulesForElement(parentElement, false, true);
parentStyle->setArray("matchedCSSRules", buildArrayForRuleList(parentMatchedRules.get()));
inheritedStyles->pushObject(parentStyle.release());
parentElement = parentElement->parentElement();
}
resultObject->setArray("inherited", inheritedStyles.release());
*result = resultObject.release();
}
void InspectorFrontend::Network::webSocketClosed(const TypeBuilder::Network::RequestId& requestId, double timestamp)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "Network.webSocketClosed");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setString("requestId", requestId);
paramsObject->setNumber("timestamp", timestamp);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorResourceFinishEvent::data(unsigned long identifier, double finishTime, bool didFail)
{
String requestId = IdentifiersFactory::requestId(identifier);
RefPtr<JSONObject> data = JSONObject::create();
data->setString("requestId", requestId);
data->setBoolean("didFail", didFail);
if (finishTime)
data->setNumber("networkTime", finishTime);
return TracedValue::fromJSONValue(data);
}
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::DOM::shadowRootPopped(int hostId, int rootId)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "DOM.shadowRootPopped");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("hostId", hostId);
paramsObject->setNumber("rootId", rootId);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void InspectorFrontend::Worker::dispatchMessageFromWorker(int workerId, PassRefPtr<InspectorObject> message)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "Worker.dispatchMessageFromWorker");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("workerId", workerId);
paramsObject->setValue("message", message);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void InspectorFrontend::Profiler::addHeapSnapshotChunk(int uid, const String& chunk)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "Profiler.addHeapSnapshotChunk");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("uid", uid);
paramsObject->setString("chunk", chunk);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void InspectorFrontend::CSS::namedFlowRemoved(int documentNodeId, const String& flowName)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "CSS.namedFlowRemoved");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("documentNodeId", documentNodeId);
paramsObject->setString("flowName", flowName);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorReceiveResponseEvent::data(unsigned long identifier, LocalFrame* frame, const ResourceResponse& response)
{
String requestId = IdentifiersFactory::requestId(identifier);
RefPtr<JSONObject> data = JSONObject::create();
data->setString("requestId", requestId);
data->setString("frame", toHexString(frame));
data->setNumber("statusCode", response.httpStatusCode());
data->setString("mimeType", response.mimeType());
return TracedValue::fromJSONValue(data);
}
void InspectorFrontend::Inspector::evaluateForTestInFrontend(int testCallId, const String& script)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "Inspector.evaluateForTestInFrontend");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("testCallId", testCallId);
paramsObject->setString("script", script);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void InspectorDOMStorageResource::bind(InspectorFrontend* frontend)
{
ASSERT(!m_frontend);
m_frontend = frontend->domstorage();
RefPtr<InspectorObject> jsonObject = InspectorObject::create();
jsonObject->setString("host", m_frame->document()->securityOrigin()->host());
jsonObject->setBoolean("isLocalStorage", m_isLocalStorage);
jsonObject->setNumber("id", m_id);
m_frontend->addDOMStorage(jsonObject);
}
void InspectorFrontend::DOM::attributeRemoved(int nodeId, const String& name)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "DOM.attributeRemoved");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("nodeId", nodeId);
paramsObject->setString("name", name);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void InspectorFrontend::DOM::setChildNodes(int parentId, PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > nodes)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "DOM.setChildNodes");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("parentId", parentId);
paramsObject->setValue("nodes", nodes);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
PassRefPtr<InspectorObject> TimelineRecordFactory::createGenericRecord(double startTime, int maxCallStackDepth)
{
RefPtr<InspectorObject> record = InspectorObject::create();
record->setNumber("startTime", startTime);
if (maxCallStackDepth) {
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(maxCallStackDepth, true);
if (stackTrace && stackTrace->size())
record->setValue("stackTrace", stackTrace->buildInspectorArray());
}
return record.release();
}
void InspectorFrontend::Worker::workerCreated(int workerId, const String& url, bool inspectorConnected)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "Worker.workerCreated");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setNumber("workerId", workerId);
paramsObject->setString("url", url);
paramsObject->setBoolean("inspectorConnected", inspectorConnected);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
void InspectorFrontend::Debugger::scriptParsed(const TypeBuilder::Debugger::ScriptId& scriptId, const String& url, int startLine, int startColumn, int endLine, int endColumn, const bool* const isContentScript, const String* const sourceMapURL, const bool* const hasSourceURL)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->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);
if (sourceMapURL)
paramsObject->setString("sourceMapURL", *sourceMapURL);
if (hasSourceURL)
paramsObject->setBoolean("hasSourceURL", *hasSourceURL);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
PassRefPtr<JSONObject> LoggingCanvas::objectForSkPaint(const SkPaint& paint)
{
RefPtr<JSONObject> paintItem = JSONObject::create();
paintItem->setNumber("textSize", paint.getTextSize());
paintItem->setNumber("textScaleX", paint.getTextScaleX());
paintItem->setNumber("textSkewX", paint.getTextSkewX());
if (SkShader* shader = paint.getShader())
paintItem->setObject("shader", objectForSkShader(*shader));
paintItem->setString("color", stringForSkColor(paint.getColor()));
paintItem->setNumber("strokeWidth", paint.getStrokeWidth());
paintItem->setNumber("strokeMiter", paint.getStrokeMiter());
paintItem->setString("flags", stringForSkPaintFlags(paint));
paintItem->setString("filterLevel", filterQualityName(paint.getFilterQuality()));
paintItem->setString("textAlign", textAlignName(paint.getTextAlign()));
paintItem->setString("strokeCap", strokeCapName(paint.getStrokeCap()));
paintItem->setString("strokeJoin", strokeJoinName(paint.getStrokeJoin()));
paintItem->setString("styleName", styleName(paint.getStyle()));
paintItem->setString("textEncoding", textEncodingName(paint.getTextEncoding()));
paintItem->setString("hinting", hintingName(paint.getHinting()));
return paintItem.release();
}
void InspectorFrontend::ApplicationCache::applicationCacheStatusUpdated(const TypeBuilder::Network::FrameId& frameId, const String& manifestURL, int status)
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString("method", "ApplicationCache.applicationCacheStatusUpdated");
RefPtr<InspectorObject> paramsObject = InspectorObject::create();
paramsObject->setString("frameId", frameId);
paramsObject->setString("manifestURL", manifestURL);
paramsObject->setNumber("status", status);
jsonMessage->setObject("params", paramsObject);
if (m_inspectorFrontendChannel)
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->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::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::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 ConsoleMessage::addToFrontend(InspectorFrontend* frontend, InjectedScriptHost* injectedScriptHost)
{
RefPtr<InspectorObject> jsonObj = InspectorObject::create();
jsonObj->setNumber("source", static_cast<int>(m_source));
jsonObj->setNumber("type", static_cast<int>(m_type));
jsonObj->setNumber("level", static_cast<int>(m_level));
jsonObj->setNumber("line", static_cast<int>(m_line));
jsonObj->setString("url", m_url);
jsonObj->setNumber("repeatCount", static_cast<int>(m_repeatCount));
jsonObj->setString("message", m_message);
if (m_type == NetworkErrorMessageType)
jsonObj->setNumber("requestId", m_requestId);
if (m_arguments && m_arguments->argumentCount()) {
InjectedScript injectedScript = injectedScriptHost->injectedScriptFor(m_arguments->globalState());
if (!injectedScript.hasNoValue()) {
RefPtr<InspectorArray> jsonArgs = InspectorArray::create();
for (unsigned i = 0; i < m_arguments->argumentCount(); ++i) {
RefPtr<InspectorValue> inspectorValue = injectedScript.wrapForConsole(m_arguments->argumentAt(i));
if (!inspectorValue) {
ASSERT_NOT_REACHED();
return;
}
jsonArgs->pushValue(inspectorValue);
}
jsonObj->setArray("parameters", jsonArgs);
}
}
if (m_callStack)
jsonObj->setArray("stackTrace", m_callStack->buildInspectorObject());
frontend->addConsoleMessage(jsonObj);
}
void LoggingCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, const SkPaint* paint, DrawBitmapRectFlags flags)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawBitmapRectToRect");
params->setObject("bitmap", objectForSkBitmap(bitmap));
if (src)
params->setObject("src", objectForSkRect(*src));
params->setObject("dst", objectForSkRect(dst));
if (paint)
params->setObject("paint", objectForSkPaint(*paint));
params->setNumber("flags", flags);
this->SkCanvas::onDrawBitmapRect(bitmap, src, dst, paint, flags);
}
static PassRefPtr<InspectorObject> buildInspectorObjectFor(const v8::CpuProfileNode* node)
{
v8::HandleScope handleScope;
RefPtr<InspectorObject> result = InspectorObject::create();
result->setString("functionName", toWebCoreString(node->GetFunctionName()));
result->setString("url", toWebCoreString(node->GetScriptResourceName()));
result->setNumber("lineNumber", node->GetLineNumber());
result->setNumber("totalTime", node->GetTotalTime());
result->setNumber("selfTime", node->GetSelfTime());
result->setNumber("numberOfCalls", 0);
result->setBoolean("visible", true);
result->setNumber("callUID", node->GetCallUid());
RefPtr<InspectorArray> children = InspectorArray::create();
const int childrenCount = node->GetChildrenCount();
for (int i = 0; i < childrenCount; i++) {
const v8::CpuProfileNode* child = node->GetChild(i);
children->pushObject(buildInspectorObjectFor(child));
}
result->setArray("children", children);
return result.release();
}
