void InspectorOverlay::reset(const IntSize& viewportSize, const IntSize& frameViewFullSize)
{
RefPtr<InspectorObject> resetData = InspectorObject::create();
resetData->setNumber("deviceScaleFactor", m_page->deviceScaleFactor());
resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
resetData->setObject("frameViewFullSize", buildObjectForSize(frameViewFullSize));
evaluateInOverlay("reset", resetData.release());
}
void LoggingCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawDRRect");
params->setObject("outer", objectForSkRRect(outer));
params->setObject("inner", objectForSkRRect(inner));
params->setObject("paint", objectForSkPaint(paint));
this->SkCanvas::onDrawDRRect(outer, inner, paint);
}
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::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());
}
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::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::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());
}
static PassRefPtr<InspectorObject> buildObjectForCachedResource(DocumentLoader* loader, const CachedResource& cachedResource)
{
RefPtr<InspectorObject> resourceObject = InspectorObject::create();
resourceObject->setString("url", cachedResource.url());
resourceObject->setString("type", cachedResourceTypeString(cachedResource));
resourceObject->setNumber("encodedSize", cachedResource.encodedSize());
resourceObject->setObject("response", buildObjectForResourceResponse(cachedResource.response()));
resourceObject->setObject("loader", buildObjectForDocumentLoader(loader));
return resourceObject;
}
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::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::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::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::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());
}
SkCanvas::SaveLayerStrategy LoggingCanvas::willSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("saveLayer");
if (bounds)
params->setObject("bounds", objectForSkRect(*bounds));
if (paint)
params->setObject("paint", objectForSkPaint(*paint));
params->setString("saveFlags", saveFlagsToString(flags));
return this->SkCanvas::willSaveLayer(bounds, paint, flags);
}
void LoggingCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawSprite");
params->setObject("bitmap", objectForSkBitmap(bitmap));
params->setNumber("left", left);
params->setNumber("top", top);
if (paint)
params->setObject("paint", objectForSkPaint(*paint));
this->SkCanvas::onDrawSprite(bitmap, left, top, 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 LoggingCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, const SkMatrix* matrix, const SkPaint& paint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawTextOnPath");
params->setString("text", stringForText(text, byteLength, paint));
params->setObject("path", objectForSkPath(path));
if (matrix)
params->setArray("matrix", arrayForSkMatrix(*matrix));
params->setObject("paint", objectForSkPaint(paint));
this->SkCanvas::onDrawTextOnPath(text, byteLength, path, matrix, paint);
}
void LoggingCanvas::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawBitmapNine");
params->setObject("bitmap", objectForSkBitmap(bitmap));
params->setObject("center", objectForSkIRect(center));
params->setObject("dst", objectForSkRect(dst));
if (paint)
params->setObject("paint", objectForSkPaint(*paint));
this->SkCanvas::onDrawBitmapNine(bitmap, center, dst, paint);
}
void LoggingCanvas::onDrawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawImage");
params->setNumber("left", left);
params->setNumber("top", top);
params->setObject("image", objectForSkImage(image));
if (paint)
params->setObject("paint", objectForSkPaint(*paint));
this->SkCanvas::onDrawImage(image, left, top, paint);
}
SkCanvas::SaveLayerStrategy LoggingCanvas::getSaveLayerStrategy(const SaveLayerRec& rec)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("saveLayer");
if (rec.fBounds)
params->setObject("bounds", objectForSkRect(*rec.fBounds));
if (rec.fPaint)
params->setObject("paint", objectForSkPaint(*rec.fPaint));
params->setString("saveFlags", saveLayerFlagsToString(rec.fSaveLayerFlags));
return this->SkCanvas::getSaveLayerStrategy(rec);
}
void LoggingCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint)
{
AutoLogger logger(this);
RefPtr<JSONObject> params = logger.logItemWithParams("drawImageRect");
params->setObject("image", objectForSkImage(image));
if (src)
params->setObject("src", objectForSkRect(*src));
params->setObject("dst", objectForSkRect(dst));
if (paint)
params->setObject("paint", objectForSkPaint(*paint));
this->SkCanvas::onDrawImageRect(image, src, dst, paint, constraint);
}
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::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 InspectorOverlay::reset(const IntSize& viewportSize, const IntSize& frameViewFullSize, int scrollX, int scrollY)
{
RefPtr<JSONObject> resetData = JSONObject::create();
resetData->setNumber("pageScaleFactor", m_page->pageScaleFactor());
resetData->setNumber("deviceScaleFactor", m_page->deviceScaleFactor());
resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
resetData->setObject("frameViewFullSize", buildObjectForSize(frameViewFullSize));
resetData->setNumber("pageZoomFactor", m_page->mainFrame()->pageZoomFactor());
resetData->setNumber("scrollX", scrollX);
resetData->setNumber("scrollY", scrollY);
evaluateInOverlay("reset", resetData.release());
}
static PassRefPtr<InspectorObject> buildObjectForFrameResource(Frame* frame)
{
FrameLoader* frameLoader = frame->loader();
DocumentLoader* loader = frameLoader->documentLoader();
RefPtr<InspectorObject> resourceObject = InspectorObject::create();
resourceObject->setString("url", loader->url().string());
resourceObject->setObject("loader", buildObjectForDocumentLoader(loader));
resourceObject->setObject("request", buildObjectForResourceRequest(loader->request()));
resourceObject->setObject("response", buildObjectForResourceResponse(loader->response()));
return resourceObject;
}
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 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);
}
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 InspectorResourceAgent::willSendWebSocketHandshakeRequest(unsigned long identifier, const WebSocketHandshakeRequest& request)
{
RefPtr<InspectorObject> requestObject = InspectorObject::create();
requestObject->setObject("webSocketHeaderFields", buildObjectForHeaders(request.headerFields()));
requestObject->setString("webSocketRequestKey3", createReadableStringFromBinary(request.key3().value, sizeof(request.key3().value)));
m_frontend->willSendWebSocketHandshakeRequest(identifier, currentTime(), requestObject);
}
void InspectorDebuggerAgent::setBreakpointByUrl(ErrorString* errorString, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const String* const optionalCondition, String* outBreakpointId, RefPtr<InspectorArray>& locations)
{
if (!optionalURL == !optionalURLRegex) {
*errorString = "Either url or urlRegex must be specified.";
return;
}
String url = optionalURL ? *optionalURL : *optionalURLRegex;
int columnNumber = optionalColumnNumber ? *optionalColumnNumber : 0;
String condition = optionalCondition ? *optionalCondition : "";
bool isRegex = optionalURLRegex;
String breakpointId = (isRegex ? "/" + url + "/" : url) + ':' + String::number(lineNumber) + ':' + String::number(columnNumber);
RefPtr<InspectorObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
if (breakpointsCookie->find(breakpointId) != breakpointsCookie->end()) {
*errorString = "Breakpoint at specified location already exists.";
return;
}
breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex));
m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
for (ScriptsMap::iterator it = m_scripts.begin(); it != m_scripts.end(); ++it) {
if (!matches(it->second.url, url, isRegex))
continue;
RefPtr<InspectorObject> location = resolveBreakpoint(breakpointId, it->first, breakpoint);
if (location)
locations->pushObject(location);
}
*outBreakpointId = breakpointId;
}
