PassRefPtr<WebSocketChannel> WebSocketChannel::create(ExecutionContext* context, WebSocketChannelClient* client)
{
ASSERT(context);
ASSERT(client);
String sourceURL;
unsigned lineNumber = 0;
RefPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
if (callStack && callStack->size()) {
sourceURL = callStack->at(0).sourceURL();
lineNumber = callStack->at(0).lineNumber();
}
if (context->isWorkerGlobalScope()) {
WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
WorkerRunLoop& runLoop = workerGlobalScope->thread()->runLoop();
String mode = webSocketChannelMode + String::number(runLoop.createUniqueId());
return WorkerThreadableWebSocketChannel::create(workerGlobalScope, client, mode, sourceURL, lineNumber);
}
Document* document = toDocument(context);
Settings* settings = document->settings();
if (settings && settings->experimentalWebSocketEnabled()) {
// FIXME: Create and return an "experimental" WebSocketChannel instead of a MainThreadWebSocketChannel.
return MainThreadWebSocketChannel::create(document, client, sourceURL, lineNumber);
}
return MainThreadWebSocketChannel::create(document, client, sourceURL, lineNumber);
}
static void messageHandlerInMainThread(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
{
DOMWindow* firstWindow = firstDOMWindow();
if (!firstWindow->isCurrentlyDisplayedInFrame())
return;
String errorMessage = toWebCoreString(message->Get());
v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
RefPtr<ScriptCallStack> callStack;
// Currently stack trace is only collected when inspector is open.
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
callStack = createScriptCallStack(stackTrace, ScriptCallStack::maxCallStackSizeToCapture);
v8::Handle<v8::Value> resourceName = message->GetScriptResourceName();
bool shouldUseDocumentURL = resourceName.IsEmpty() || !resourceName->IsString();
String resource = shouldUseDocumentURL ? firstWindow->document()->url() : toWebCoreString(resourceName);
RefPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, resource, message->GetLineNumber(), message->GetStartColumn());
// messageHandlerInMainThread can be called while we're creating a new context.
// Since we cannot create a wrapper in the intermediate timing, we need to skip
// creating a wrapper for |event|.
DOMWrapperWorld* world = DOMWrapperWorld::current();
Frame* frame = firstWindow->document()->frame();
if (world && frame && frame->script()->existingWindowShell(world)) {
v8::Local<v8::Value> wrappedEvent = toV8(event.get(), v8::Handle<v8::Object>(), v8::Isolate::GetCurrent());
if (!wrappedEvent.IsEmpty()) {
ASSERT(wrappedEvent->IsObject());
v8::Local<v8::Object>::Cast(wrappedEvent)->SetHiddenValue(V8HiddenPropertyName::error(), data);
}
}
AccessControlStatus corsStatus = message->IsSharedCrossOrigin() ? SharableCrossOrigin : NotSharableCrossOrigin;
firstWindow->document()->reportException(event.release(), callStack, corsStatus);
}
void V8Proxy::reportUnsafeAccessTo(Document* targetDocument)
{
if (!targetDocument)
return;
// FIXME: We should pass both the active and target documents in as arguments.
Frame* source = firstFrame(BindingState::instance());
if (!source)
return;
Document* sourceDocument = source->document();
if (!sourceDocument)
return; // Ignore error if the source document is gone.
// FIXME: This error message should contain more specifics of why the same
// origin check has failed.
String str = "Unsafe JavaScript attempt to access frame with URL " + targetDocument->url().string() +
" from frame with URL " + sourceDocument->url().string() + ". Domains, protocols and ports must match.\n";
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
// NOTE: Safari prints the message in the target page, but it seems like
// it should be in the source page. Even for delayed messages, we put it in
// the source page.
sourceDocument->addConsoleMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, str, stackTrace.release());
}
void V8ConsoleMessage::handler(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
{
// Use the frame where JavaScript is called from.
Frame* frame = V8Proxy::retrieveFrameForEnteredContext();
if (!frame)
return;
Page* page = frame->page();
if (!page)
return;
v8::Handle<v8::String> errorMessageString = message->Get();
ASSERT(!errorMessageString.IsEmpty());
String errorMessage = toWebCoreString(errorMessageString);
v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
RefPtr<ScriptCallStack> callStack;
// Currently stack trace is only collected when inspector is open.
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
callStack = createScriptCallStack(stackTrace, ScriptCallStack::maxCallStackSizeToCapture);
v8::Handle<v8::Value> resourceName = message->GetScriptResourceName();
bool useURL = resourceName.IsEmpty() || !resourceName->IsString();
String resourceNameString = useURL ? frame->document()->url() : toWebCoreString(resourceName);
V8ConsoleMessage consoleMessage(errorMessage, resourceNameString, message->GetLineNumber());
consoleMessage.dispatchNow(page, callStack);
}
PassRefPtr<Inspector::Protocol::Network::Initiator> InspectorResourceAgent::buildInitiatorObject(Document* document)
{
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(JSMainThreadExecState::currentState(), ScriptCallStack::maxCallStackSizeToCapture);
if (stackTrace && stackTrace->size() > 0) {
RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = Inspector::Protocol::Network::Initiator::create()
.setType(Inspector::Protocol::Network::Initiator::Type::Script);
initiatorObject->setStackTrace(stackTrace->buildInspectorArray());
return initiatorObject;
}
if (document && document->scriptableDocumentParser()) {
RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = Inspector::Protocol::Network::Initiator::create()
.setType(Inspector::Protocol::Network::Initiator::Type::Parser);
initiatorObject->setUrl(document->url().string());
initiatorObject->setLineNumber(document->scriptableDocumentParser()->textPosition().m_line.oneBasedInt());
return initiatorObject;
}
if (m_isRecalculatingStyle && m_styleRecalculationInitiator)
return m_styleRecalculationInitiator;
return Inspector::Protocol::Network::Initiator::create()
.setType(Inspector::Protocol::Network::Initiator::Type::Other)
.release();
}
PassRefPtr<InspectorObject> InspectorResourceAgent::buildInitiatorObject(Document* document)
{
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
if (stackTrace && stackTrace->size() > 0) {
RefPtr<InspectorObject> initiatorObject = InspectorObject::create();
initiatorObject->setString("type", "script");
initiatorObject->setArray("stackTrace", stackTrace->buildInspectorArray());
return initiatorObject;
}
if (document && document->scriptableDocumentParser()) {
RefPtr<InspectorObject> initiatorObject = InspectorObject::create();
initiatorObject->setString("type", "parser");
initiatorObject->setString("url", document->url().string());
initiatorObject->setNumber("lineNumber", document->scriptableDocumentParser()->lineNumber().oneBasedInt());
return initiatorObject;
}
if (m_isRecalculatingStyle && m_styleRecalculationInitiator)
return m_styleRecalculationInitiator;
RefPtr<InspectorObject> initiatorObject = InspectorObject::create();
initiatorObject->setString("type", "other");
return initiatorObject;
}
void InspectorResourceAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse)
{
String requestId = IdentifiersFactory::requestId(identifier);
m_resourcesData->resourceCreated(requestId, m_pageAgent->loaderId(loader));
RefPtr<InspectorObject> headers = m_state->getObject(ResourceAgentState::extraRequestHeaders);
if (headers) {
InspectorObject::const_iterator end = headers->end();
for (InspectorObject::const_iterator it = headers->begin(); it != end; ++it) {
String value;
if (it->second->asString(&value))
request.setHTTPHeaderField(it->first, value);
}
}
request.setReportLoadTiming(true);
request.setReportRawHeaders(true);
if (m_state->getBoolean(ResourceAgentState::cacheDisabled)) {
request.setCachePolicy(ReloadIgnoringCacheData);
request.setHTTPHeaderField("Pragma", "no-cache");
request.setHTTPHeaderField("Cache-Control", "no-cache");
}
RefPtr<ScriptCallStack> callStack = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
RefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame> > callStackValue;
if (callStack)
callStackValue = callStack->buildInspectorArray();
else
callStackValue = TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create();
RefPtr<TypeBuilder::Network::Initiator> initiatorObject = buildInitiatorObject(loader->frame() ? loader->frame()->document() : 0);
m_frontend->requestWillBeSent(requestId, m_pageAgent->frameId(loader->frame()), m_pageAgent->loaderId(loader), loader->url().string(), buildObjectForResourceRequest(request), currentTime(), initiatorObject, callStackValue, buildObjectForResourceResponse(redirectResponse, loader));
}
PassRefPtr<TypeBuilder::Network::Initiator> InspectorResourceAgent::buildInitiatorObject(Document* document)
{
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
if (stackTrace && stackTrace->size() > 0) {
RefPtr<TypeBuilder::Network::Initiator> initiatorObject = TypeBuilder::Network::Initiator::create()
.setType(TypeBuilder::Network::Initiator::Type::Script);
initiatorObject->setStackTrace(stackTrace->buildInspectorArray());
return initiatorObject;
}
if (document && document->scriptableDocumentParser()) {
RefPtr<TypeBuilder::Network::Initiator> initiatorObject = TypeBuilder::Network::Initiator::create()
.setType(TypeBuilder::Network::Initiator::Type::Parser);
initiatorObject->setUrl(document->url().string());
initiatorObject->setLineNumber(document->scriptableDocumentParser()->lineNumber().oneBasedInt());
return initiatorObject;
}
if (m_isRecalculatingStyle && m_styleRecalculationInitiator)
return m_styleRecalculationInitiator;
return TypeBuilder::Network::Initiator::create()
.setType(TypeBuilder::Network::Initiator::Type::Other)
.release();
}
PassRefPtr<ScriptCallStack> createScriptCallStack(size_t maxStackSize, bool emptyStackIsAllowed)
{
if (!v8::Context::InContext())
return 0;
v8::HandleScope handleScope;
v8::Handle<v8::StackTrace> stackTrace(v8::StackTrace::CurrentStackTrace(maxStackSize, stackTraceOptions));
return createScriptCallStack(stackTrace, maxStackSize, emptyStackIsAllowed);
}
static void messageHandlerInMainThread(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
{
ASSERT(isMainThread());
// It's possible that messageHandlerInMainThread() is invoked while we're initializing a window.
// In that half-baked situation, we don't have a valid context nor a valid world,
// so just return immediately.
if (DOMWrapperWorld::windowIsBeingInitialized())
return;
v8::Isolate* isolate = v8::Isolate::GetCurrent();
// If called during context initialization, there will be no entered window.
LocalDOMWindow* enteredWindow = enteredDOMWindow(isolate);
if (!enteredWindow)
return;
String errorMessage = toCoreString(message->Get());
v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
RefPtr<ScriptCallStack> callStack = nullptr;
int scriptId = message->GetScriptOrigin().ScriptID()->Value();
// Currently stack trace is only collected when inspector is open.
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
callStack = createScriptCallStack(stackTrace, ScriptCallStack::maxCallStackSizeToCapture, isolate);
bool success = false;
int topScriptId = callStack->at(0).scriptId().toInt(&success);
if (success && topScriptId == scriptId)
scriptId = 0;
} else {
Vector<ScriptCallFrame> callFrames;
callStack = ScriptCallStack::create(callFrames);
}
v8::Handle<v8::Value> resourceName = message->GetScriptOrigin().ResourceName();
bool shouldUseDocumentURL = resourceName.IsEmpty() || !resourceName->IsString();
String resource = shouldUseDocumentURL ? enteredWindow->document()->url() : toCoreString(resourceName.As<v8::String>());
ScriptState* scriptState = ScriptState::current(isolate);
RefPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, resource, message->GetLineNumber(), message->GetStartColumn() + 1, &scriptState->world());
if (V8DOMWrapper::isDOMWrapper(data)) {
v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(data);
const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
DOMException* exception = V8DOMException::toNative(obj);
if (exception && !exception->messageForConsole().isEmpty())
event->setUnsanitizedMessage("Uncaught " + exception->toStringForConsole());
}
}
// This method might be called while we're creating a new context. In this case, we
// avoid storing the exception object, as we can't create a wrapper during context creation.
// FIXME: Can we even get here during initialization now that we bail out when GetEntered returns an empty handle?
LocalFrame* frame = enteredWindow->document()->frame();
if (frame && frame->script().existingWindowProxy(scriptState->world())) {
V8ErrorHandler::storeExceptionOnErrorEventWrapper(event.get(), data, scriptState->context()->Global(), isolate);
}
enteredWindow->document()->reportException(event.release(), scriptId, callStack);
}
void Console::reportMessageToClient(MessageLevel level, const String& message, PassRefPtr<ScriptCallStack> callStack)
{
String stackTrace;
if (m_frame->page()->chrome().client().shouldReportDetailedMessageForSource(callStack->at(0).sourceURL())) {
RefPtr<ScriptCallStack> fullStack = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture);
stackTrace = PageConsole::formatStackTraceString(message, fullStack);
}
m_frame->page()->chrome().client().addMessageToConsole(ConsoleAPIMessageSource, level, message, callStack->at(0).lineNumber(), callStack->at(0).sourceURL(), stackTrace);
}
PassRefPtr<ScriptCallStack> createScriptCallStack(size_t maxStackSize, bool emptyStackIsAllowed)
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
if (!isolate->InContext())
return nullptr;
v8::HandleScope handleScope(isolate);
v8::Handle<v8::StackTrace> stackTrace(v8::StackTrace::CurrentStackTrace(isolate, maxStackSize, stackTraceOptions));
return createScriptCallStack(stackTrace, maxStackSize, emptyStackIsAllowed, isolate);
}
v8::Handle<v8::Value> V8Console::traceCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Console.traceCallback");
Console* imp = V8Console::toNative(args.Holder());
RefPtr<ScriptCallStack> callStack(createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture));
RefPtr<ScriptArguments> scriptArguments(createScriptArguments(args, 0));
imp->trace(scriptArguments.release(), callStack);
return v8Undefined();
}
PassRefPtr<ScriptCallStack> createScriptCallStackForConsole(ScriptState* scriptState, size_t maxStackSize)
{
size_t stackSize = 1;
if (InspectorInstrumentation::hasFrontends()) {
if (InspectorInstrumentation::consoleAgentEnabled(scriptState->executionContext()))
stackSize = maxStackSize;
}
return createScriptCallStack(stackSize);
}
static void internalAddMessage(Page* page, MessageType type, MessageLevel level, JSC::ExecState* state, PassRefPtr<ScriptArguments> prpArguments, bool acceptNoArguments = false, bool printTrace = false)
{
RefPtr<ScriptArguments> arguments = prpArguments;
if (!page)
return;
if (!acceptNoArguments && !arguments->argumentCount())
return;
size_t stackSize = printTrace ? ScriptCallStack::maxCallStackSizeToCapture : 1;
RefPtr<ScriptCallStack> callStack(createScriptCallStack(state, stackSize));
const ScriptCallFrame& lastCaller = callStack->at(0);
String message;
bool gotMessage = arguments->getFirstArgumentAsString(message);
InspectorInstrumentation::addMessageToConsole(page, ConsoleAPIMessageSource, type, level, message, state, arguments);
if (page->settings().privateBrowsingEnabled())
return;
if (gotMessage)
page->chrome().client().addMessageToConsole(ConsoleAPIMessageSource, type, level, message, lastCaller.lineNumber(), lastCaller.columnNumber(), lastCaller.sourceURL());
if (!page->settings().logsPageMessagesToSystemConsoleEnabled() && !PageConsole::shouldPrintExceptions())
return;
PageConsole::printSourceURLAndPosition(lastCaller.sourceURL(), lastCaller.lineNumber());
printf(": ");
PageConsole::printMessageSourceAndLevelPrefix(ConsoleAPIMessageSource, level, printTrace);
for (size_t i = 0; i < arguments->argumentCount(); ++i) {
String argAsString = arguments->argumentAt(i).toString(arguments->globalState());
printf(" %s", argAsString.utf8().data());
}
printf("\n");
if (!printTrace)
return;
for (size_t i = 0; i < callStack->size(); ++i) {
const ScriptCallFrame& callFrame = callStack->at(i);
String functionName = String(callFrame.functionName());
if (functionName.isEmpty())
functionName = ASCIILiteral("(unknown)");
printf("%lu: %s (", static_cast<unsigned long>(i), functionName.utf8().data());
PageConsole::printSourceURLAndPosition(callFrame.sourceURL(), callFrame.lineNumber());
printf(")\n");
}
}
JSValue JSConsole::profileEnd(ExecState* exec)
{
RefPtr<ScriptCallStack> callStack(createScriptCallStack(exec, 1));
const String& title = valueToStringWithUndefinedOrNullCheck(exec, exec->argument(0));
if (exec->hadException())
return jsUndefined();
impl()->profileEnd(title, exec, callStack);
return jsUndefined();
}
PassRefPtr<ScriptCallStack> createScriptCallStackForConsole(JSC::ExecState* exec)
{
size_t maxStackSize = 1;
if (InspectorInstrumentation::hasFrontends()) {
ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
if (InspectorInstrumentation::consoleAgentEnabled(scriptExecutionContext))
maxStackSize = ScriptCallStack::maxCallStackSizeToCapture;
}
return createScriptCallStack(exec, maxStackSize);
}
PromiseTracker::PromiseData::PromiseData(const ScriptObject& promise, const ScriptObject& parentPromise, const ScriptValue& result, V8PromiseCustom::PromiseState state, double timestamp)
: m_promise(promise)
, m_parentPromise(parentPromise)
, m_result(result)
, m_state(state)
, m_timeOnCreate(timestamp)
, m_timeOnSettle(-1)
, m_callStackOnCreate(createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true))
{
}
v8::Handle<v8::Value> V8Console::assertCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Console.assertCallback");
Console* imp = V8Console::toNative(args.Holder());
RefPtr<ScriptCallStack> callStack(createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture));
bool condition = args[0]->BooleanValue();
RefPtr<ScriptArguments> scriptArguments(createScriptArguments(args, 1));
imp->assertCondition(scriptArguments.release(), callStack, condition);
return v8Undefined();
}
void InspectorResourceAgent::identifierForInitialRequest(unsigned long identifier, const KURL& url, DocumentLoader* loader)
{
RefPtr<InspectorObject> loaderObject = buildObjectForDocumentLoader(loader);
RefPtr<ScriptCallStack> callStack = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
RefPtr<InspectorValue> callStackValue;
if (callStack)
callStackValue = callStack->buildInspectorObject();
else
callStackValue = InspectorValue::null();
m_frontend->identifierForInitialRequest(identifier, url.string(), loaderObject, callStackValue);
}
v8::Handle<v8::Value> V8Console::profileEndCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Console.profileEnd");
Console* imp = V8Console::toNative(args.Holder());
RefPtr<ScriptCallStack> callStack(createScriptCallStack(1));
if (!callStack)
return v8::Undefined();
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<WithUndefinedOrNullCheck>, title, args[0]);
imp->profileEnd(title, ScriptState::current(), callStack);
return v8Undefined();
}
Ref<InspectorObject> TimelineRecordFactory::createGenericRecord(JSC::ExecState* state, double startTime, int maxCallStackDepth) {
Ref<InspectorObject> record = InspectorObject::create();
record->setDouble("startTime", startTime);
if (maxCallStackDepth) {
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(state, maxCallStackDepth);
if (stackTrace && stackTrace->size())
record->setValue("stackTrace", stackTrace->buildInspectorArray());
}
return WTF::move(record);
}
PassRefPtr<InspectorObject> TimelineRecordFactory::createGenericRecord(double startTime, int maxCallStackDepth)
{
RefPtr<InspectorObject> record = InspectorObject::create();
record->setDouble("startTime", startTime);
if (maxCallStackDepth) {
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(JSMainThreadExecState::currentState(), maxCallStackDepth);
if (stackTrace && stackTrace->size())
record->setValue("stackTrace", stackTrace->buildInspectorArray());
}
return record.release();
}
PassRefPtrWillBeRawPtr<ScriptCallStack> createScriptCallStackForConsole(size_t maxStackSize, bool emptyStackIsAllowed)
{
size_t stackSize = 1;
if (InspectorInstrumentation::hasFrontends()) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
if (!isolate->InContext())
return nullptr;
if (InspectorInstrumentation::consoleAgentEnabled(currentExecutionContext(isolate)))
stackSize = maxStackSize;
}
return createScriptCallStack(stackSize, emptyStackIsAllowed);
}
PassRefPtr<InspectorObject> TimelineRecordFactory::createGenericRecord(double startTime, int maxCallStackDepth, const String& type)
{
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());
}
record->setString("type", type);
return record.release();
}
EncodedJSValue JSC_HOST_CALL jsConsolePrototypeFunctionGroupCollapsed(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&JSConsole::s_info))
return throwVMTypeError(exec);
JSConsole* castedThis = static_cast<JSConsole*>(asObject(thisValue));
Console* imp = static_cast<Console*>(castedThis->impl());
RefPtr<ScriptArguments> scriptArguments(createScriptArguments(exec, 0));
size_t maxStackSize = imp->shouldCaptureFullStackTrace() ? ScriptCallStack::maxCallStackSizeToCapture : 1;
RefPtr<ScriptCallStack> callStack(createScriptCallStack(exec, maxStackSize));
imp->groupCollapsed(scriptArguments, callStack);
return JSValue::encode(jsUndefined());
}
void FrameConsole::addMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> prpConsoleMessage)
{
RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = prpConsoleMessage;
if (muteCount && consoleMessage->source() != ConsoleAPIMessageSource)
return;
// FIXME: This should not need to reach for the main-frame.
// Inspector code should just take the current frame and know how to walk itself.
ExecutionContext* context = frame().document();
if (!context)
return;
if (!messageStorage())
return;
String messageURL;
unsigned lineNumber = 0;
if (consoleMessage->callStack() && consoleMessage->callStack()->size()) {
lineNumber = consoleMessage->callStack()->at(0).lineNumber();
messageURL = consoleMessage->callStack()->at(0).sourceURL();
} else {
lineNumber = consoleMessage->lineNumber();
messageURL = consoleMessage->url();
}
messageStorage()->reportMessage(m_frame->document(), consoleMessage);
if (consoleMessage->source() == CSSMessageSource || consoleMessage->source() == NetworkMessageSource)
return;
RefPtrWillBeRawPtr<ScriptCallStack> reportedCallStack = nullptr;
if (consoleMessage->source() != ConsoleAPIMessageSource) {
if (consoleMessage->callStack() && frame().chromeClient().shouldReportDetailedMessageForSource(frame(), messageURL))
reportedCallStack = consoleMessage->callStack();
} else {
if (!frame().host() || (consoleMessage->scriptArguments() && !consoleMessage->scriptArguments()->argumentCount()))
return;
if (!allClientReportingMessageTypes().contains(consoleMessage->type()))
return;
if (frame().chromeClient().shouldReportDetailedMessageForSource(frame(), messageURL))
reportedCallStack = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture);
}
String stackTrace;
if (reportedCallStack)
stackTrace = FrameConsole::formatStackTraceString(consoleMessage->message(), reportedCallStack);
frame().chromeClient().addMessageToConsole(m_frame, consoleMessage->source(), consoleMessage->level(), consoleMessage->message(), lineNumber, messageURL, stackTrace);
}
static PassRefPtrWillBeRawPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Local<v8::Message> message, int* const scriptId)
{
v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
*scriptId = message->GetScriptOrigin().ScriptID()->Value();
// Currently stack trace is only collected when inspector is open.
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
callStack = createScriptCallStack(isolate, stackTrace, ScriptCallStack::maxCallStackSizeToCapture);
bool success = false;
int topScriptId = callStack->at(0).scriptId().toInt(&success);
if (success && topScriptId == *scriptId)
*scriptId = 0;
}
return callStack.release();
}
EncodedJSValue JSC_HOST_CALL jsConsolePrototypeFunctionTimeEnd(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&JSConsole::s_info))
return throwVMTypeError(exec);
JSConsole* castedThis = static_cast<JSConsole*>(asObject(thisValue));
Console* imp = static_cast<Console*>(castedThis->impl());
RefPtr<ScriptArguments> scriptArguments(createScriptArguments(exec, 1));
size_t maxStackSize = imp->shouldCaptureFullStackTrace() ? ScriptCallStack::maxCallStackSizeToCapture : 1;
RefPtr<ScriptCallStack> callStack(createScriptCallStack(exec, maxStackSize));
const String& title(valueToStringWithUndefinedOrNullCheck(exec, exec->argument(0)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
imp->timeEnd(title, scriptArguments, callStack);
return JSValue::encode(jsUndefined());
}
void Console::profileEnd(const String& title, ScriptState* state)
{
Page* page = this->page();
if (!page)
return;
if (!InspectorInstrumentation::profilerEnabled(page))
return;
RefPtr<ScriptProfile> profile = ScriptProfiler::stop(state, title);
if (!profile)
return;
m_profiles.append(profile);
RefPtr<ScriptCallStack> callStack(createScriptCallStack(state, 1));
InspectorInstrumentation::addProfile(page, profile, callStack);
}