From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/console/Console.cpp | 2440 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2440 insertions(+) create mode 100644 dom/console/Console.cpp (limited to 'dom/console/Console.cpp') diff --git a/dom/console/Console.cpp b/dom/console/Console.cpp new file mode 100644 index 000000000..9ede26501 --- /dev/null +++ b/dom/console/Console.cpp @@ -0,0 +1,2440 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/Console.h" +#include "mozilla/dom/ConsoleBinding.h" + +#include "mozilla/dom/BlobBinding.h" +#include "mozilla/dom/Exceptions.h" +#include "mozilla/dom/File.h" +#include "mozilla/dom/FunctionBinding.h" +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/StructuredCloneHolder.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/dom/WorkletGlobalScope.h" +#include "mozilla/Maybe.h" +#include "nsCycleCollectionParticipant.h" +#include "nsDocument.h" +#include "nsDOMNavigationTiming.h" +#include "nsGlobalWindow.h" +#include "nsJSUtils.h" +#include "nsNetUtil.h" +#include "ScriptSettings.h" +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" +#include "xpcpublic.h" +#include "nsContentUtils.h" +#include "nsDocShell.h" +#include "nsProxyRelease.h" +#include "mozilla/ConsoleTimelineMarker.h" +#include "mozilla/TimestampTimelineMarker.h" + +#include "nsIConsoleAPIStorage.h" +#include "nsIDOMWindowUtils.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsILoadContext.h" +#include "nsIProgrammingLanguage.h" +#include "nsISensitiveInfoHiddenURI.h" +#include "nsIServiceManager.h" +#include "nsISupportsPrimitives.h" +#include "nsIWebNavigation.h" +#include "nsIXPConnect.h" + +// The maximum allowed number of concurrent timers per page. +#define MAX_PAGE_TIMERS 10000 + +// The maximum allowed number of concurrent counters per page. +#define MAX_PAGE_COUNTERS 10000 + +// The maximum stacktrace depth when populating the stacktrace array used for +// console.trace(). +#define DEFAULT_MAX_STACKTRACE_DEPTH 200 + +// This tags are used in the Structured Clone Algorithm to move js values from +// worker thread to main thread +#define CONSOLE_TAG_BLOB JS_SCTAG_USER_MIN + +// This value is taken from ConsoleAPIStorage.js +#define STORAGE_MAX_EVENTS 1000 + +using namespace mozilla::dom::exceptions; +using namespace mozilla::dom::workers; + +namespace mozilla { +namespace dom { + +struct +ConsoleStructuredCloneData +{ + nsCOMPtr mParent; + nsTArray> mBlobs; +}; + +/** + * Console API in workers uses the Structured Clone Algorithm to move any value + * from the worker thread to the main-thread. Some object cannot be moved and, + * in these cases, we convert them to strings. + * It's not the best, but at least we are able to show something. + */ + +class ConsoleCallData final +{ +public: + NS_INLINE_DECL_REFCOUNTING(ConsoleCallData) + + ConsoleCallData() + : mMethodName(Console::MethodLog) + , mPrivate(false) + , mTimeStamp(JS_Now() / PR_USEC_PER_MSEC) + , mStartTimerValue(0) + , mStartTimerStatus(false) + , mStopTimerDuration(0) + , mStopTimerStatus(false) + , mCountValue(MAX_PAGE_COUNTERS) + , mIDType(eUnknown) + , mOuterIDNumber(0) + , mInnerIDNumber(0) + , mStatus(eUnused) +#ifdef DEBUG + , mOwningThread(PR_GetCurrentThread()) +#endif + {} + + bool + Initialize(JSContext* aCx, Console::MethodName aName, + const nsAString& aString, + const Sequence& aArguments, + Console* aConsole) + { + AssertIsOnOwningThread(); + MOZ_ASSERT(aConsole); + + // We must be registered before doing any JS operation otherwise it can + // happen that mCopiedArguments are not correctly traced. + aConsole->StoreCallData(this); + + mMethodName = aName; + mMethodString = aString; + + mGlobal = JS::CurrentGlobalOrNull(aCx); + + for (uint32_t i = 0; i < aArguments.Length(); ++i) { + if (NS_WARN_IF(!mCopiedArguments.AppendElement(aArguments[i]))) { + aConsole->UnstoreCallData(this); + return false; + } + } + + return true; + } + + void + SetIDs(uint64_t aOuterID, uint64_t aInnerID) + { + MOZ_ASSERT(mIDType == eUnknown); + + mOuterIDNumber = aOuterID; + mInnerIDNumber = aInnerID; + mIDType = eNumber; + } + + void + SetIDs(const nsAString& aOuterID, const nsAString& aInnerID) + { + MOZ_ASSERT(mIDType == eUnknown); + + mOuterIDString = aOuterID; + mInnerIDString = aInnerID; + mIDType = eString; + } + + void + SetOriginAttributes(const PrincipalOriginAttributes& aOriginAttributes) + { + mOriginAttributes = aOriginAttributes; + } + + bool + PopulateArgumentsSequence(Sequence& aSequence) const + { + AssertIsOnOwningThread(); + + for (uint32_t i = 0; i < mCopiedArguments.Length(); ++i) { + if (NS_WARN_IF(!aSequence.AppendElement(mCopiedArguments[i], + fallible))) { + return false; + } + } + + return true; + } + + void + Trace(const TraceCallbacks& aCallbacks, void* aClosure) + { + AssertIsOnOwningThread(); + + ConsoleCallData* tmp = this; + for (uint32_t i = 0; i < mCopiedArguments.Length(); ++i) { + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mCopiedArguments[i]) + } + + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mGlobal); + } + + void + AssertIsOnOwningThread() const + { + MOZ_ASSERT(mOwningThread); + MOZ_ASSERT(PR_GetCurrentThread() == mOwningThread); + } + + JS::Heap mGlobal; + + // This is a copy of the arguments we received from the DOM bindings. Console + // object traces them because this ConsoleCallData calls + // RegisterConsoleCallData() in the Initialize(). + nsTArray> mCopiedArguments; + + Console::MethodName mMethodName; + bool mPrivate; + int64_t mTimeStamp; + + // These values are set in the owning thread and they contain the timestamp of + // when the new timer has started, the name of it and the status of the + // creation of it. If status is false, something went wrong. User + // DOMHighResTimeStamp instead mozilla::TimeStamp because we use + // monotonicTimer from Performance.now(); + // They will be set on the owning thread and never touched again on that + // thread. They will be used in order to create a ConsoleTimerStart dictionary + // when console.time() is used. + DOMHighResTimeStamp mStartTimerValue; + nsString mStartTimerLabel; + bool mStartTimerStatus; + + // These values are set in the owning thread and they contain the duration, + // the name and the status of the StopTimer method. If status is false, + // something went wrong. They will be set on the owning thread and never + // touched again on that thread. They will be used in order to create a + // ConsoleTimerEnd dictionary. This members are set when + // console.timeEnd() is called. + double mStopTimerDuration; + nsString mStopTimerLabel; + bool mStopTimerStatus; + + // These 2 values are set by IncreaseCounter on the owning thread and they are + // used CreateCounterValue. These members are set when console.count() is + // called. + nsString mCountLabel; + uint32_t mCountValue; + + // The concept of outerID and innerID is misleading because when a + // ConsoleCallData is created from a window, these are the window IDs, but + // when the object is created from a SharedWorker, a ServiceWorker or a + // subworker of a ChromeWorker these IDs are the type of worker and the + // filename of the callee. + // In Console.jsm the ID is 'jsm'. + enum { + eString, + eNumber, + eUnknown + } mIDType; + + uint64_t mOuterIDNumber; + nsString mOuterIDString; + + uint64_t mInnerIDNumber; + nsString mInnerIDString; + + PrincipalOriginAttributes mOriginAttributes; + + nsString mMethodString; + + // Stack management is complicated, because we want to do it as + // lazily as possible. Therefore, we have the following behavior: + // 1) mTopStackFrame is initialized whenever we have any JS on the stack + // 2) mReifiedStack is initialized if we're created in a worker. + // 3) mStack is set (possibly to null if there is no JS on the stack) if + // we're created on main thread. + Maybe mTopStackFrame; + Maybe> mReifiedStack; + nsCOMPtr mStack; + + // mStatus is about the lifetime of this object. Console must take care of + // keep it alive or not following this enumeration. + enum { + // If the object is created but it is owned by some runnable, this is its + // status. It can be deleted at any time. + eUnused, + + // When a runnable takes ownership of a ConsoleCallData and send it to + // different thread, this is its status. Console cannot delete it at this + // time. + eInUse, + + // When a runnable owns this ConsoleCallData, we can't delete it directly. + // instead, we mark it with this new status and we move it in + // mCallDataStoragePending list in order to keep it alive an trace it + // correctly. Once the runnable finishs its task, it will delete this object + // calling ReleaseCallData(). + eToBeDeleted + } mStatus; + +#ifdef DEBUG + PRThread* mOwningThread; +#endif + +private: + ~ConsoleCallData() + { + AssertIsOnOwningThread(); + MOZ_ASSERT(mStatus != eInUse); + } +}; + +// This class is used to clear any exception at the end of this method. +class ClearException +{ +public: + explicit ClearException(JSContext* aCx) + : mCx(aCx) + { + } + + ~ClearException() + { + JS_ClearPendingException(mCx); + } + +private: + JSContext* mCx; +}; + +class ConsoleRunnable : public WorkerProxyToMainThreadRunnable + , public StructuredCloneHolderBase +{ +public: + explicit ConsoleRunnable(Console* aConsole) + : WorkerProxyToMainThreadRunnable(GetCurrentThreadWorkerPrivate()) + , mConsole(aConsole) + {} + + virtual + ~ConsoleRunnable() + { + // Clear the StructuredCloneHolderBase class. + Clear(); + } + + bool + Dispatch(JSContext* aCx) + { + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (NS_WARN_IF(!PreDispatch(aCx))) { + RunBackOnWorkerThread(); + return false; + } + + if (NS_WARN_IF(!WorkerProxyToMainThreadRunnable::Dispatch())) { + // RunBackOnWorkerThread() will be called by + // WorkerProxyToMainThreadRunnable::Dispatch(). + return false; + } + + return true; + } + +protected: + void + RunOnMainThread() override + { + AssertIsOnMainThread(); + + // Walk up to our containing page + WorkerPrivate* wp = mWorkerPrivate; + while (wp->GetParent()) { + wp = wp->GetParent(); + } + + nsPIDOMWindowInner* window = wp->GetWindow(); + if (!window) { + RunWindowless(); + } else { + RunWithWindow(window); + } + } + + void + RunWithWindow(nsPIDOMWindowInner* aWindow) + { + AssertIsOnMainThread(); + + AutoJSAPI jsapi; + MOZ_ASSERT(aWindow); + + RefPtr win = nsGlobalWindow::Cast(aWindow); + if (NS_WARN_IF(!jsapi.Init(win))) { + return; + } + + MOZ_ASSERT(aWindow->IsInnerWindow()); + nsPIDOMWindowOuter* outerWindow = aWindow->GetOuterWindow(); + if (NS_WARN_IF(!outerWindow)) { + return; + } + + RunConsole(jsapi.cx(), outerWindow, aWindow); + } + + void + RunWindowless() + { + AssertIsOnMainThread(); + + WorkerPrivate* wp = mWorkerPrivate; + while (wp->GetParent()) { + wp = wp->GetParent(); + } + + MOZ_ASSERT(!wp->GetWindow()); + + AutoSafeJSContext cx; + + JS::Rooted global(cx, mConsole->GetOrCreateSandbox(cx, wp->GetPrincipal())); + if (NS_WARN_IF(!global)) { + return; + } + + // The CreateSandbox call returns a proxy to the actual sandbox object. We + // don't need a proxy here. + global = js::UncheckedUnwrap(global); + + JSAutoCompartment ac(cx, global); + + RunConsole(cx, nullptr, nullptr); + } + + void + RunBackOnWorkerThread() override + { + mWorkerPrivate->AssertIsOnWorkerThread(); + ReleaseData(); + mConsole = nullptr; + } + + // This method is called in the owning thread of the Console object. + virtual bool + PreDispatch(JSContext* aCx) = 0; + + // This method is called in the main-thread. + virtual void + RunConsole(JSContext* aCx, nsPIDOMWindowOuter* aOuterWindow, + nsPIDOMWindowInner* aInnerWindow) = 0; + + // This method is called in the owning thread of the Console object. + virtual void + ReleaseData() = 0; + + virtual JSObject* CustomReadHandler(JSContext* aCx, + JSStructuredCloneReader* aReader, + uint32_t aTag, + uint32_t aIndex) override + { + AssertIsOnMainThread(); + + if (aTag == CONSOLE_TAG_BLOB) { + MOZ_ASSERT(mClonedData.mBlobs.Length() > aIndex); + + JS::Rooted val(aCx); + { + RefPtr blob = + Blob::Create(mClonedData.mParent, mClonedData.mBlobs.ElementAt(aIndex)); + if (!ToJSValue(aCx, blob, &val)) { + return nullptr; + } + } + + return &val.toObject(); + } + + MOZ_CRASH("No other tags are supported."); + return nullptr; + } + + virtual bool CustomWriteHandler(JSContext* aCx, + JSStructuredCloneWriter* aWriter, + JS::Handle aObj) override + { + RefPtr blob; + if (NS_SUCCEEDED(UNWRAP_OBJECT(Blob, aObj, blob)) && + blob->Impl()->MayBeClonedToOtherThreads()) { + if (NS_WARN_IF(!JS_WriteUint32Pair(aWriter, CONSOLE_TAG_BLOB, + mClonedData.mBlobs.Length()))) { + return false; + } + + mClonedData.mBlobs.AppendElement(blob->Impl()); + return true; + } + + if (!JS_ObjectNotWritten(aWriter, aObj)) { + return false; + } + + JS::Rooted value(aCx, JS::ObjectOrNullValue(aObj)); + JS::Rooted jsString(aCx, JS::ToString(aCx, value)); + if (NS_WARN_IF(!jsString)) { + return false; + } + + if (NS_WARN_IF(!JS_WriteString(aWriter, jsString))) { + return false; + } + + return true; + } + + // This must be released on the worker thread. + RefPtr mConsole; + + ConsoleStructuredCloneData mClonedData; +}; + +// This runnable appends a CallData object into the Console queue running on +// the main-thread. +class ConsoleCallDataRunnable final : public ConsoleRunnable +{ +public: + ConsoleCallDataRunnable(Console* aConsole, + ConsoleCallData* aCallData) + : ConsoleRunnable(aConsole) + , mCallData(aCallData) + { + MOZ_ASSERT(aCallData); + mWorkerPrivate->AssertIsOnWorkerThread(); + mCallData->AssertIsOnOwningThread(); + } + +private: + ~ConsoleCallDataRunnable() + { + MOZ_ASSERT(!mCallData); + } + + bool + PreDispatch(JSContext* aCx) override + { + mWorkerPrivate->AssertIsOnWorkerThread(); + mCallData->AssertIsOnOwningThread(); + + ClearException ce(aCx); + + JS::Rooted arguments(aCx, + JS_NewArrayObject(aCx, mCallData->mCopiedArguments.Length())); + if (NS_WARN_IF(!arguments)) { + return false; + } + + JS::Rooted arg(aCx); + for (uint32_t i = 0; i < mCallData->mCopiedArguments.Length(); ++i) { + arg = mCallData->mCopiedArguments[i]; + if (NS_WARN_IF(!JS_DefineElement(aCx, arguments, i, arg, + JSPROP_ENUMERATE))) { + return false; + } + } + + JS::Rooted value(aCx, JS::ObjectValue(*arguments)); + + if (NS_WARN_IF(!Write(aCx, value))) { + return false; + } + + mCallData->mStatus = ConsoleCallData::eInUse; + return true; + } + + void + RunConsole(JSContext* aCx, nsPIDOMWindowOuter* aOuterWindow, + nsPIDOMWindowInner* aInnerWindow) override + { + AssertIsOnMainThread(); + + // The windows have to run in parallel. + MOZ_ASSERT(!!aOuterWindow == !!aInnerWindow); + + if (aOuterWindow) { + mCallData->SetIDs(aOuterWindow->WindowID(), aInnerWindow->WindowID()); + + // Save the principal's OriginAttributes in the console event data + // so that we will be able to filter messages by origin attributes. + nsCOMPtr sop = do_QueryInterface(aInnerWindow); + if (NS_WARN_IF(!sop)) { + return; + } + + nsCOMPtr principal = sop->GetPrincipal(); + if (NS_WARN_IF(!principal)) { + return; + } + + mCallData->SetOriginAttributes(BasePrincipal::Cast(principal)->OriginAttributesRef()); + } else { + ConsoleStackEntry frame; + if (mCallData->mTopStackFrame) { + frame = *mCallData->mTopStackFrame; + } + + nsString id = frame.mFilename; + nsString innerID; + if (mWorkerPrivate->IsSharedWorker()) { + innerID = NS_LITERAL_STRING("SharedWorker"); + } else if (mWorkerPrivate->IsServiceWorker()) { + innerID = NS_LITERAL_STRING("ServiceWorker"); + // Use scope as ID so the webconsole can decide if the message should + // show up per tab + id.AssignWithConversion(mWorkerPrivate->WorkerName()); + } else { + innerID = NS_LITERAL_STRING("Worker"); + } + + mCallData->SetIDs(id, innerID); + + // Save the principal's OriginAttributes in the console event data + // so that we will be able to filter messages by origin attributes. + nsCOMPtr principal = mWorkerPrivate->GetPrincipal(); + if (NS_WARN_IF(!principal)) { + return; + } + + mCallData->SetOriginAttributes(BasePrincipal::Cast(principal)->OriginAttributesRef()); + } + + // Now we could have the correct window (if we are not window-less). + mClonedData.mParent = aInnerWindow; + + ProcessCallData(aCx); + + mClonedData.mParent = nullptr; + } + + virtual void + ReleaseData() override + { + mConsole->AssertIsOnOwningThread(); + + if (mCallData->mStatus == ConsoleCallData::eToBeDeleted) { + mConsole->ReleaseCallData(mCallData); + } else { + MOZ_ASSERT(mCallData->mStatus == ConsoleCallData::eInUse); + mCallData->mStatus = ConsoleCallData::eUnused; + } + + mCallData = nullptr; + } + + void + ProcessCallData(JSContext* aCx) + { + AssertIsOnMainThread(); + + ClearException ce(aCx); + + JS::Rooted argumentsValue(aCx); + if (!Read(aCx, &argumentsValue)) { + return; + } + + MOZ_ASSERT(argumentsValue.isObject()); + + JS::Rooted argumentsObj(aCx, &argumentsValue.toObject()); + + uint32_t length; + if (!JS_GetArrayLength(aCx, argumentsObj, &length)) { + return; + } + + Sequence values; + SequenceRooter arguments(aCx, &values); + + for (uint32_t i = 0; i < length; ++i) { + JS::Rooted value(aCx); + + if (!JS_GetElement(aCx, argumentsObj, i, &value)) { + return; + } + + if (!values.AppendElement(value, fallible)) { + return; + } + } + + MOZ_ASSERT(values.Length() == length); + + mConsole->ProcessCallData(aCx, mCallData, values); + } + + RefPtr mCallData; +}; + +// This runnable calls ProfileMethod() on the console on the main-thread. +class ConsoleProfileRunnable final : public ConsoleRunnable +{ +public: + ConsoleProfileRunnable(Console* aConsole, const nsAString& aAction, + const Sequence& aArguments) + : ConsoleRunnable(aConsole) + , mAction(aAction) + , mArguments(aArguments) + { + MOZ_ASSERT(aConsole); + } + +private: + bool + PreDispatch(JSContext* aCx) override + { + ClearException ce(aCx); + + JS::Rooted arguments(aCx, + JS_NewArrayObject(aCx, mArguments.Length())); + if (NS_WARN_IF(!arguments)) { + return false; + } + + JS::Rooted arg(aCx); + for (uint32_t i = 0; i < mArguments.Length(); ++i) { + arg = mArguments[i]; + if (NS_WARN_IF(!JS_DefineElement(aCx, arguments, i, arg, + JSPROP_ENUMERATE))) { + return false; + } + } + + JS::Rooted value(aCx, JS::ObjectValue(*arguments)); + + if (NS_WARN_IF(!Write(aCx, value))) { + return false; + } + + return true; + } + + void + RunConsole(JSContext* aCx, nsPIDOMWindowOuter* aOuterWindow, + nsPIDOMWindowInner* aInnerWindow) override + { + AssertIsOnMainThread(); + + ClearException ce(aCx); + + // Now we could have the correct window (if we are not window-less). + mClonedData.mParent = aInnerWindow; + + JS::Rooted argumentsValue(aCx); + bool ok = Read(aCx, &argumentsValue); + mClonedData.mParent = nullptr; + + if (!ok) { + return; + } + + MOZ_ASSERT(argumentsValue.isObject()); + JS::Rooted argumentsObj(aCx, &argumentsValue.toObject()); + + uint32_t length; + if (!JS_GetArrayLength(aCx, argumentsObj, &length)) { + return; + } + + Sequence arguments; + + for (uint32_t i = 0; i < length; ++i) { + JS::Rooted value(aCx); + + if (!JS_GetElement(aCx, argumentsObj, i, &value)) { + return; + } + + if (!arguments.AppendElement(value, fallible)) { + return; + } + } + + mConsole->ProfileMethodInternal(aCx, mAction, arguments); + } + + virtual void + ReleaseData() override + {} + + nsString mAction; + + // This is a reference of the sequence of arguments we receive from the DOM + // bindings and it's rooted by them. It's only used on the owning thread in + // PreDispatch(). + const Sequence& mArguments; +}; + +NS_IMPL_CYCLE_COLLECTION_CLASS(Console) + +// We don't need to traverse/unlink mStorage and mSandbox because they are not +// CCed objects and they are only used on the main thread, even when this +// Console object is used on workers. + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Console) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsoleEventNotifier) + tmp->Shutdown(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Console) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsoleEventNotifier) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Console) + for (uint32_t i = 0; i < tmp->mCallDataStorage.Length(); ++i) { + tmp->mCallDataStorage[i]->Trace(aCallbacks, aClosure); + } + + for (uint32_t i = 0; i < tmp->mCallDataStoragePending.Length(); ++i) { + tmp->mCallDataStoragePending[i]->Trace(aCallbacks, aClosure); + } + +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(Console) +NS_IMPL_CYCLE_COLLECTING_RELEASE(Console) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Console) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_END + +/* static */ already_AddRefed +Console::Create(nsPIDOMWindowInner* aWindow, ErrorResult& aRv) +{ + MOZ_ASSERT_IF(NS_IsMainThread(), aWindow); + + RefPtr console = new Console(aWindow); + console->Initialize(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + return console.forget(); +} + +Console::Console(nsPIDOMWindowInner* aWindow) + : mWindow(aWindow) +#ifdef DEBUG + , mOwningThread(PR_GetCurrentThread()) +#endif + , mOuterID(0) + , mInnerID(0) + , mStatus(eUnknown) +{ + MOZ_ASSERT_IF(NS_IsMainThread(), aWindow); + + if (mWindow) { + MOZ_ASSERT(mWindow->IsInnerWindow()); + mInnerID = mWindow->WindowID(); + + // Without outerwindow any console message coming from this object will not + // shown in the devtools webconsole. But this should be fine because + // probably we are shutting down, or the window is CCed/GCed. + nsPIDOMWindowOuter* outerWindow = mWindow->GetOuterWindow(); + if (outerWindow) { + mOuterID = outerWindow->WindowID(); + } + } + + mozilla::HoldJSObjects(this); +} + +Console::~Console() +{ + AssertIsOnOwningThread(); + Shutdown(); + mozilla::DropJSObjects(this); +} + +void +Console::Initialize(ErrorResult& aRv) +{ + AssertIsOnOwningThread(); + MOZ_ASSERT(mStatus == eUnknown); + + if (NS_IsMainThread()) { + nsCOMPtr obs = mozilla::services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + aRv = obs->AddObserver(this, "inner-window-destroyed", true); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + aRv = obs->AddObserver(this, "memory-pressure", true); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + } + + mStatus = eInitialized; +} + +void +Console::Shutdown() +{ + AssertIsOnOwningThread(); + + if (mStatus == eUnknown || mStatus == eShuttingDown) { + return; + } + + if (NS_IsMainThread()) { + nsCOMPtr obs = mozilla::services::GetObserverService(); + if (obs) { + obs->RemoveObserver(this, "inner-window-destroyed"); + obs->RemoveObserver(this, "memory-pressure"); + } + } + + NS_ReleaseOnMainThread(mStorage.forget()); + NS_ReleaseOnMainThread(mSandbox.forget()); + + mTimerRegistry.Clear(); + mCounterRegistry.Clear(); + + mCallDataStorage.Clear(); + mCallDataStoragePending.Clear(); + + mStatus = eShuttingDown; +} + +NS_IMETHODIMP +Console::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + AssertIsOnMainThread(); + + if (!strcmp(aTopic, "inner-window-destroyed")) { + nsCOMPtr wrapper = do_QueryInterface(aSubject); + NS_ENSURE_TRUE(wrapper, NS_ERROR_FAILURE); + + uint64_t innerID; + nsresult rv = wrapper->GetData(&innerID); + NS_ENSURE_SUCCESS(rv, rv); + + if (innerID == mInnerID) { + Shutdown(); + } + + return NS_OK; + } + + if (!strcmp(aTopic, "memory-pressure")) { + ClearStorage(); + return NS_OK; + } + + return NS_OK; +} + +void +Console::ClearStorage() +{ + mCallDataStorage.Clear(); +} + +#define METHOD(name, string) \ + /* static */ void \ + Console::name(const GlobalObject& aGlobal, const Sequence& aData) \ + { \ + Method(aGlobal, Method##name, NS_LITERAL_STRING(string), aData); \ + } + +METHOD(Log, "log") +METHOD(Info, "info") +METHOD(Warn, "warn") +METHOD(Error, "error") +METHOD(Exception, "exception") +METHOD(Debug, "debug") +METHOD(Table, "table") +METHOD(Clear, "clear") + +/* static */ void +Console::Trace(const GlobalObject& aGlobal) +{ + const Sequence data; + Method(aGlobal, MethodTrace, NS_LITERAL_STRING("trace"), data); +} + +// Displays an interactive listing of all the properties of an object. +METHOD(Dir, "dir"); +METHOD(Dirxml, "dirxml"); + +METHOD(Group, "group") +METHOD(GroupCollapsed, "groupCollapsed") +METHOD(GroupEnd, "groupEnd") + +/* static */ void +Console::Time(const GlobalObject& aGlobal, const JS::Handle aTime) +{ + JSContext* cx = aGlobal.Context(); + + Sequence data; + SequenceRooter rooter(cx, &data); + + if (!aTime.isUndefined() && !data.AppendElement(aTime, fallible)) { + return; + } + + Method(aGlobal, MethodTime, NS_LITERAL_STRING("time"), data); +} + +/* static */ void +Console::TimeEnd(const GlobalObject& aGlobal, const JS::Handle aTime) +{ + JSContext* cx = aGlobal.Context(); + + Sequence data; + SequenceRooter rooter(cx, &data); + + if (!aTime.isUndefined() && !data.AppendElement(aTime, fallible)) { + return; + } + + Method(aGlobal, MethodTimeEnd, NS_LITERAL_STRING("timeEnd"), data); +} + +/* static */ void +Console::TimeStamp(const GlobalObject& aGlobal, + const JS::Handle aData) +{ + JSContext* cx = aGlobal.Context(); + + Sequence data; + SequenceRooter rooter(cx, &data); + + if (aData.isString() && !data.AppendElement(aData, fallible)) { + return; + } + + Method(aGlobal, MethodTimeStamp, NS_LITERAL_STRING("timeStamp"), data); +} + +/* static */ void +Console::Profile(const GlobalObject& aGlobal, const Sequence& aData) +{ + ProfileMethod(aGlobal, NS_LITERAL_STRING("profile"), aData); +} + +/* static */ void +Console::ProfileEnd(const GlobalObject& aGlobal, + const Sequence& aData) +{ + ProfileMethod(aGlobal, NS_LITERAL_STRING("profileEnd"), aData); +} + +/* static */ void +Console::ProfileMethod(const GlobalObject& aGlobal, const nsAString& aAction, + const Sequence& aData) +{ + RefPtr console = GetConsole(aGlobal); + if (!console) { + return; + } + + JSContext* cx = aGlobal.Context(); + console->ProfileMethodInternal(cx, aAction, aData); +} + +void +Console::ProfileMethodInternal(JSContext* aCx, const nsAString& aAction, + const Sequence& aData) +{ + if (!NS_IsMainThread()) { + // Here we are in a worker thread. + RefPtr runnable = + new ConsoleProfileRunnable(this, aAction, aData); + + runnable->Dispatch(aCx); + return; + } + + ClearException ce(aCx); + + RootedDictionary event(aCx); + event.mAction = aAction; + + event.mArguments.Construct(); + Sequence& sequence = event.mArguments.Value(); + + for (uint32_t i = 0; i < aData.Length(); ++i) { + if (!sequence.AppendElement(aData[i], fallible)) { + return; + } + } + + JS::Rooted eventValue(aCx); + if (!ToJSValue(aCx, event, &eventValue)) { + return; + } + + JS::Rooted eventObj(aCx, &eventValue.toObject()); + MOZ_ASSERT(eventObj); + + if (!JS_DefineProperty(aCx, eventObj, "wrappedJSObject", eventValue, + JSPROP_ENUMERATE)) { + return; + } + + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + nsCOMPtr wrapper; + const nsIID& iid = NS_GET_IID(nsISupports); + + if (NS_FAILED(xpc->WrapJS(aCx, eventObj, iid, getter_AddRefs(wrapper)))) { + return; + } + + nsCOMPtr obs = mozilla::services::GetObserverService(); + if (obs) { + obs->NotifyObservers(wrapper, "console-api-profiler", nullptr); + } +} + +/* static */ void +Console::Assert(const GlobalObject& aGlobal, bool aCondition, + const Sequence& aData) +{ + if (!aCondition) { + Method(aGlobal, MethodAssert, NS_LITERAL_STRING("assert"), aData); + } +} + +METHOD(Count, "count") + +/* static */ void +Console::NoopMethod(const GlobalObject& aGlobal) +{ + // Nothing to do. +} + +namespace { + +nsresult +StackFrameToStackEntry(JSContext* aCx, nsIStackFrame* aStackFrame, + ConsoleStackEntry& aStackEntry) +{ + MOZ_ASSERT(aStackFrame); + + nsresult rv = aStackFrame->GetFilename(aCx, aStackEntry.mFilename); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t lineNumber; + rv = aStackFrame->GetLineNumber(aCx, &lineNumber); + NS_ENSURE_SUCCESS(rv, rv); + + aStackEntry.mLineNumber = lineNumber; + + int32_t columnNumber; + rv = aStackFrame->GetColumnNumber(aCx, &columnNumber); + NS_ENSURE_SUCCESS(rv, rv); + + aStackEntry.mColumnNumber = columnNumber; + + rv = aStackFrame->GetName(aCx, aStackEntry.mFunctionName); + NS_ENSURE_SUCCESS(rv, rv); + + nsString cause; + rv = aStackFrame->GetAsyncCause(aCx, cause); + NS_ENSURE_SUCCESS(rv, rv); + if (!cause.IsEmpty()) { + aStackEntry.mAsyncCause.Construct(cause); + } + + aStackEntry.mLanguage = nsIProgrammingLanguage::JAVASCRIPT; + return NS_OK; +} + +nsresult +ReifyStack(JSContext* aCx, nsIStackFrame* aStack, + nsTArray& aRefiedStack) +{ + nsCOMPtr stack(aStack); + + while (stack) { + ConsoleStackEntry& data = *aRefiedStack.AppendElement(); + nsresult rv = StackFrameToStackEntry(aCx, stack, data); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr caller; + rv = stack->GetCaller(aCx, getter_AddRefs(caller)); + NS_ENSURE_SUCCESS(rv, rv); + + if (!caller) { + rv = stack->GetAsyncCaller(aCx, getter_AddRefs(caller)); + NS_ENSURE_SUCCESS(rv, rv); + } + stack.swap(caller); + } + + return NS_OK; +} + +} // anonymous namespace + +// Queue a call to a console method. See the CALL_DELAY constant. +/* static */ void +Console::Method(const GlobalObject& aGlobal, MethodName aMethodName, + const nsAString& aMethodString, + const Sequence& aData) +{ + RefPtr console = GetConsole(aGlobal); + if (!console) { + return; + } + + console->MethodInternal(aGlobal.Context(), aMethodName, aMethodString, + aData); +} + +void +Console::MethodInternal(JSContext* aCx, MethodName aMethodName, + const nsAString& aMethodString, + const Sequence& aData) +{ + AssertIsOnOwningThread(); + + RefPtr callData(new ConsoleCallData()); + + ClearException ce(aCx); + + if (NS_WARN_IF(!callData->Initialize(aCx, aMethodName, aMethodString, + aData, this))) { + return; + } + + if (mWindow) { + nsCOMPtr webNav = do_GetInterface(mWindow); + if (!webNav) { + return; + } + + nsCOMPtr loadContext = do_QueryInterface(webNav); + MOZ_ASSERT(loadContext); + + loadContext->GetUsePrivateBrowsing(&callData->mPrivate); + + // Save the principal's OriginAttributes in the console event data + // so that we will be able to filter messages by origin attributes. + nsCOMPtr sop = do_QueryInterface(mWindow); + if (NS_WARN_IF(!sop)) { + return; + } + + nsCOMPtr principal = sop->GetPrincipal(); + if (NS_WARN_IF(!principal)) { + return; + } + + callData->SetOriginAttributes(BasePrincipal::Cast(principal)->OriginAttributesRef()); + } + + JS::StackCapture captureMode = ShouldIncludeStackTrace(aMethodName) ? + JS::StackCapture(JS::MaxFrames(DEFAULT_MAX_STACKTRACE_DEPTH)) : + JS::StackCapture(JS::FirstSubsumedFrame(aCx)); + nsCOMPtr stack = CreateStack(aCx, mozilla::Move(captureMode)); + + if (stack) { + callData->mTopStackFrame.emplace(); + nsresult rv = StackFrameToStackEntry(aCx, stack, + *callData->mTopStackFrame); + if (NS_FAILED(rv)) { + return; + } + } + + if (NS_IsMainThread()) { + callData->mStack = stack; + } else { + // nsIStackFrame is not threadsafe, so we need to snapshot it now, + // before we post our runnable to the main thread. + callData->mReifiedStack.emplace(); + nsresult rv = ReifyStack(aCx, stack, *callData->mReifiedStack); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } + + DOMHighResTimeStamp monotonicTimer; + + // Monotonic timer for 'time' and 'timeEnd' + if (aMethodName == MethodTime || + aMethodName == MethodTimeEnd || + aMethodName == MethodTimeStamp) { + if (mWindow) { + nsGlobalWindow *win = nsGlobalWindow::Cast(mWindow); + MOZ_ASSERT(win); + + RefPtr performance = win->GetPerformance(); + if (!performance) { + return; + } + + monotonicTimer = performance->Now(); + + nsDocShell* docShell = static_cast(mWindow->GetDocShell()); + RefPtr timelines = TimelineConsumers::Get(); + bool isTimelineRecording = timelines && timelines->HasConsumer(docShell); + + // The 'timeStamp' recordings do not need an argument; use empty string + // if no arguments passed in. + if (isTimelineRecording && aMethodName == MethodTimeStamp) { + JS::Rooted value(aCx, aData.Length() == 0 + ? JS_GetEmptyStringValue(aCx) + : aData[0]); + JS::Rooted jsString(aCx, JS::ToString(aCx, value)); + + nsAutoJSString key; + if (jsString) { + key.init(aCx, jsString); + } + + timelines->AddMarkerForDocShell(docShell, Move( + MakeUnique(key))); + } + // For `console.time(foo)` and `console.timeEnd(foo)`. + else if (isTimelineRecording && aData.Length() == 1) { + JS::Rooted value(aCx, aData[0]); + JS::Rooted jsString(aCx, JS::ToString(aCx, value)); + + if (jsString) { + nsAutoJSString key; + if (key.init(aCx, jsString)) { + timelines->AddMarkerForDocShell(docShell, Move( + MakeUnique( + key, aMethodName == MethodTime ? MarkerTracingType::START + : MarkerTracingType::END))); + } + } + } + } else { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + TimeDuration duration = + mozilla::TimeStamp::Now() - workerPrivate->NowBaseTimeStamp(); + + monotonicTimer = duration.ToMilliseconds(); + } + } + + if (aMethodName == MethodTime && !aData.IsEmpty()) { + callData->mStartTimerStatus = StartTimer(aCx, aData[0], + monotonicTimer, + callData->mStartTimerLabel, + &callData->mStartTimerValue); + } + + else if (aMethodName == MethodTimeEnd && !aData.IsEmpty()) { + callData->mStopTimerStatus = StopTimer(aCx, aData[0], + monotonicTimer, + callData->mStopTimerLabel, + &callData->mStopTimerDuration); + } + + else if (aMethodName == MethodCount) { + ConsoleStackEntry frame; + if (callData->mTopStackFrame) { + frame = *callData->mTopStackFrame; + } + + callData->mCountValue = IncreaseCounter(aCx, frame, aData, + callData->mCountLabel); + } + + if (NS_IsMainThread()) { + callData->SetIDs(mOuterID, mInnerID); + ProcessCallData(aCx, callData, aData); + + // Just because we don't want to expose + // retrieveConsoleEvents/setConsoleEventHandler to main-thread, we can + // cleanup the mCallDataStorage: + UnstoreCallData(callData); + return; + } + + // We do this only in workers for now. + NotifyHandler(aCx, aData, callData); + + RefPtr runnable = + new ConsoleCallDataRunnable(this, callData); + Unused << NS_WARN_IF(!runnable->Dispatch(aCx)); +} + +// We store information to lazily compute the stack in the reserved slots of +// LazyStackGetter. The first slot always stores a JS object: it's either the +// JS wrapper of the nsIStackFrame or the actual reified stack representation. +// The second slot is a PrivateValue() holding an nsIStackFrame* when we haven't +// reified the stack yet, or an UndefinedValue() otherwise. +enum { + SLOT_STACKOBJ, + SLOT_RAW_STACK +}; + +bool +LazyStackGetter(JSContext* aCx, unsigned aArgc, JS::Value* aVp) +{ + JS::CallArgs args = CallArgsFromVp(aArgc, aVp); + JS::Rooted callee(aCx, &args.callee()); + + JS::Value v = js::GetFunctionNativeReserved(&args.callee(), SLOT_RAW_STACK); + if (v.isUndefined()) { + // Already reified. + args.rval().set(js::GetFunctionNativeReserved(callee, SLOT_STACKOBJ)); + return true; + } + + nsIStackFrame* stack = reinterpret_cast(v.toPrivate()); + nsTArray reifiedStack; + nsresult rv = ReifyStack(aCx, stack, reifiedStack); + if (NS_WARN_IF(NS_FAILED(rv))) { + Throw(aCx, rv); + return false; + } + + JS::Rooted stackVal(aCx); + if (NS_WARN_IF(!ToJSValue(aCx, reifiedStack, &stackVal))) { + return false; + } + + MOZ_ASSERT(stackVal.isObject()); + + js::SetFunctionNativeReserved(callee, SLOT_STACKOBJ, stackVal); + js::SetFunctionNativeReserved(callee, SLOT_RAW_STACK, JS::UndefinedValue()); + + args.rval().set(stackVal); + return true; +} + +void +Console::ProcessCallData(JSContext* aCx, ConsoleCallData* aData, + const Sequence& aArguments) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aData); + + JS::Rooted eventValue(aCx); + + // We want to create a console event object and pass it to our + // nsIConsoleAPIStorage implementation. We want to define some accessor + // properties on this object, and those will need to keep an nsIStackFrame + // alive. But nsIStackFrame cannot be wrapped in an untrusted scope. And + // further, passing untrusted objects to system code is likely to run afoul of + // Object Xrays. So we want to wrap in a system-principal scope here. But + // which one? We could cheat and try to get the underlying JSObject* of + // mStorage, but that's a bit fragile. Instead, we just use the junk scope, + // with explicit permission from the XPConnect module owner. If you're + // tempted to do that anywhere else, talk to said module owner first. + + // aCx and aArguments are in the same compartment. + if (NS_WARN_IF(!PopulateConsoleNotificationInTheTargetScope(aCx, aArguments, + xpc::PrivilegedJunkScope(), + &eventValue, aData))) { + return; + } + + if (!mStorage) { + mStorage = do_GetService("@mozilla.org/consoleAPI-storage;1"); + } + + if (!mStorage) { + NS_WARNING("Failed to get the ConsoleAPIStorage service."); + return; + } + + nsAutoString innerID, outerID; + + MOZ_ASSERT(aData->mIDType != ConsoleCallData::eUnknown); + if (aData->mIDType == ConsoleCallData::eString) { + outerID = aData->mOuterIDString; + innerID = aData->mInnerIDString; + } else { + MOZ_ASSERT(aData->mIDType == ConsoleCallData::eNumber); + outerID.AppendInt(aData->mOuterIDNumber); + innerID.AppendInt(aData->mInnerIDNumber); + } + + if (aData->mMethodName == MethodClear) { + DebugOnly rv = mStorage->ClearEvents(innerID); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "ClearEvents failed"); + } + + if (NS_FAILED(mStorage->RecordEvent(innerID, outerID, eventValue))) { + NS_WARNING("Failed to record a console event."); + } +} + +bool +Console::PopulateConsoleNotificationInTheTargetScope(JSContext* aCx, + const Sequence& aArguments, + JSObject* aTargetScope, + JS::MutableHandle aEventValue, + ConsoleCallData* aData) const +{ + MOZ_ASSERT(aCx); + MOZ_ASSERT(aData); + MOZ_ASSERT(aTargetScope); + + JS::Rooted targetScope(aCx, aTargetScope); + + ConsoleStackEntry frame; + if (aData->mTopStackFrame) { + frame = *aData->mTopStackFrame; + } + + ClearException ce(aCx); + RootedDictionary event(aCx); + + // Save the principal's OriginAttributes in the console event data + // so that we will be able to filter messages by origin attributes. + JS::Rooted originAttributesValue(aCx); + if (ToJSValue(aCx, aData->mOriginAttributes, &originAttributesValue)) { + event.mOriginAttributes = originAttributesValue; + } + + event.mID.Construct(); + event.mInnerID.Construct(); + + if (aData->mIDType == ConsoleCallData::eString) { + event.mID.Value().SetAsString() = aData->mOuterIDString; + event.mInnerID.Value().SetAsString() = aData->mInnerIDString; + } else if (aData->mIDType == ConsoleCallData::eNumber) { + event.mID.Value().SetAsUnsignedLongLong() = aData->mOuterIDNumber; + event.mInnerID.Value().SetAsUnsignedLongLong() = aData->mInnerIDNumber; + } else { + // aData->mIDType can be eUnknown when we dispatch notifications via + // mConsoleEventNotifier. + event.mID.Value().SetAsUnsignedLongLong() = 0; + event.mInnerID.Value().SetAsUnsignedLongLong() = 0; + } + + event.mLevel = aData->mMethodString; + event.mFilename = frame.mFilename; + + nsCOMPtr filenameURI; + nsAutoCString pass; + if (NS_IsMainThread() && + NS_SUCCEEDED(NS_NewURI(getter_AddRefs(filenameURI), frame.mFilename)) && + NS_SUCCEEDED(filenameURI->GetPassword(pass)) && !pass.IsEmpty()) { + nsCOMPtr safeURI = do_QueryInterface(filenameURI); + nsAutoCString spec; + if (safeURI && + NS_SUCCEEDED(safeURI->GetSensitiveInfoHiddenSpec(spec))) { + CopyUTF8toUTF16(spec, event.mFilename); + } + } + + event.mLineNumber = frame.mLineNumber; + event.mColumnNumber = frame.mColumnNumber; + event.mFunctionName = frame.mFunctionName; + event.mTimeStamp = aData->mTimeStamp; + event.mPrivate = aData->mPrivate; + + switch (aData->mMethodName) { + case MethodLog: + case MethodInfo: + case MethodWarn: + case MethodError: + case MethodException: + case MethodDebug: + case MethodAssert: + event.mArguments.Construct(); + event.mStyles.Construct(); + if (NS_WARN_IF(!ProcessArguments(aCx, aArguments, + event.mArguments.Value(), + event.mStyles.Value()))) { + return false; + } + + break; + + default: + event.mArguments.Construct(); + if (NS_WARN_IF(!ArgumentsToValueList(aArguments, + event.mArguments.Value()))) { + return false; + } + } + + if (aData->mMethodName == MethodGroup || + aData->mMethodName == MethodGroupCollapsed || + aData->mMethodName == MethodGroupEnd) { + ComposeGroupName(aCx, aArguments, event.mGroupName); + } + + else if (aData->mMethodName == MethodTime && !aArguments.IsEmpty()) { + event.mTimer = CreateStartTimerValue(aCx, aData->mStartTimerLabel, + aData->mStartTimerValue, + aData->mStartTimerStatus); + } + + else if (aData->mMethodName == MethodTimeEnd && !aArguments.IsEmpty()) { + event.mTimer = CreateStopTimerValue(aCx, aData->mStopTimerLabel, + aData->mStopTimerDuration, + aData->mStopTimerStatus); + } + + else if (aData->mMethodName == MethodCount) { + event.mCounter = CreateCounterValue(aCx, aData->mCountLabel, + aData->mCountValue); + } + + JSAutoCompartment ac2(aCx, targetScope); + + if (NS_WARN_IF(!ToJSValue(aCx, event, aEventValue))) { + return false; + } + + JS::Rooted eventObj(aCx, &aEventValue.toObject()); + if (NS_WARN_IF(!JS_DefineProperty(aCx, eventObj, "wrappedJSObject", eventObj, + JSPROP_ENUMERATE))) { + return false; + } + + if (ShouldIncludeStackTrace(aData->mMethodName)) { + // Now define the "stacktrace" property on eventObj. There are two cases + // here. Either we came from a worker and have a reified stack, or we want + // to define a getter that will lazily reify the stack. + if (aData->mReifiedStack) { + JS::Rooted stacktrace(aCx); + if (NS_WARN_IF(!ToJSValue(aCx, *aData->mReifiedStack, &stacktrace)) || + NS_WARN_IF(!JS_DefineProperty(aCx, eventObj, "stacktrace", stacktrace, + JSPROP_ENUMERATE))) { + return false; + } + } else { + JSFunction* fun = js::NewFunctionWithReserved(aCx, LazyStackGetter, 0, 0, + "stacktrace"); + if (NS_WARN_IF(!fun)) { + return false; + } + + JS::Rooted funObj(aCx, JS_GetFunctionObject(fun)); + + // We want to store our stack in the function and have it stay alive. But + // we also need sane access to the C++ nsIStackFrame. So store both a JS + // wrapper and the raw pointer: the former will keep the latter alive. + JS::Rooted stackVal(aCx); + nsresult rv = nsContentUtils::WrapNative(aCx, aData->mStack, + &stackVal); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + js::SetFunctionNativeReserved(funObj, SLOT_STACKOBJ, stackVal); + js::SetFunctionNativeReserved(funObj, SLOT_RAW_STACK, + JS::PrivateValue(aData->mStack.get())); + + if (NS_WARN_IF(!JS_DefineProperty(aCx, eventObj, "stacktrace", + JS::UndefinedHandleValue, + JSPROP_ENUMERATE | JSPROP_SHARED | + JSPROP_GETTER | JSPROP_SETTER, + JS_DATA_TO_FUNC_PTR(JSNative, funObj.get()), + nullptr))) { + return false; + } + } + } + + return true; +} + +namespace { + +// Helper method for ProcessArguments. Flushes output, if non-empty, to aSequence. +bool +FlushOutput(JSContext* aCx, Sequence& aSequence, nsString &aOutput) +{ + if (!aOutput.IsEmpty()) { + JS::Rooted str(aCx, JS_NewUCStringCopyN(aCx, + aOutput.get(), + aOutput.Length())); + if (NS_WARN_IF(!str)) { + return false; + } + + if (NS_WARN_IF(!aSequence.AppendElement(JS::StringValue(str), fallible))) { + return false; + } + + aOutput.Truncate(); + } + + return true; +} + +} // namespace + +bool +Console::ProcessArguments(JSContext* aCx, + const Sequence& aData, + Sequence& aSequence, + Sequence& aStyles) const +{ + if (aData.IsEmpty()) { + return true; + } + + if (aData.Length() == 1 || !aData[0].isString()) { + return ArgumentsToValueList(aData, aSequence); + } + + JS::Rooted format(aCx, aData[0]); + JS::Rooted jsString(aCx, JS::ToString(aCx, format)); + if (NS_WARN_IF(!jsString)) { + return false; + } + + nsAutoJSString string; + if (NS_WARN_IF(!string.init(aCx, jsString))) { + return false; + } + + nsString::const_iterator start, end; + string.BeginReading(start); + string.EndReading(end); + + nsString output; + uint32_t index = 1; + + while (start != end) { + if (*start != '%') { + output.Append(*start); + ++start; + continue; + } + + ++start; + if (start == end) { + output.Append('%'); + break; + } + + if (*start == '%') { + output.Append(*start); + ++start; + continue; + } + + nsAutoString tmp; + tmp.Append('%'); + + int32_t integer = -1; + int32_t mantissa = -1; + + // Let's parse %. for %d and %f + if (*start >= '0' && *start <= '9') { + integer = 0; + + do { + integer = integer * 10 + *start - '0'; + tmp.Append(*start); + ++start; + } while (*start >= '0' && *start <= '9' && start != end); + } + + if (start == end) { + output.Append(tmp); + break; + } + + if (*start == '.') { + tmp.Append(*start); + ++start; + + if (start == end) { + output.Append(tmp); + break; + } + + // '.' must be followed by a number. + if (*start < '0' || *start > '9') { + output.Append(tmp); + continue; + } + + mantissa = 0; + + do { + mantissa = mantissa * 10 + *start - '0'; + tmp.Append(*start); + ++start; + } while (*start >= '0' && *start <= '9' && start != end); + + if (start == end) { + output.Append(tmp); + break; + } + } + + char ch = *start; + tmp.Append(ch); + ++start; + + switch (ch) { + case 'o': + case 'O': + { + if (NS_WARN_IF(!FlushOutput(aCx, aSequence, output))) { + return false; + } + + JS::Rooted v(aCx); + if (index < aData.Length()) { + v = aData[index++]; + } + + if (NS_WARN_IF(!aSequence.AppendElement(v, fallible))) { + return false; + } + + break; + } + + case 'c': + { + // If there isn't any output but there's already a style, then + // discard the previous style and use the next one instead. + if (output.IsEmpty() && !aStyles.IsEmpty()) { + aStyles.TruncateLength(aStyles.Length() - 1); + } + + if (NS_WARN_IF(!FlushOutput(aCx, aSequence, output))) { + return false; + } + + if (index < aData.Length()) { + JS::Rooted v(aCx, aData[index++]); + JS::Rooted jsString(aCx, JS::ToString(aCx, v)); + if (NS_WARN_IF(!jsString)) { + return false; + } + + int32_t diff = aSequence.Length() - aStyles.Length(); + if (diff > 0) { + for (int32_t i = 0; i < diff; i++) { + if (NS_WARN_IF(!aStyles.AppendElement(NullString(), fallible))) { + return false; + } + } + } + + nsAutoJSString string; + if (NS_WARN_IF(!string.init(aCx, jsString))) { + return false; + } + + if (NS_WARN_IF(!aStyles.AppendElement(string, fallible))) { + return false; + } + } + break; + } + + case 's': + if (index < aData.Length()) { + JS::Rooted value(aCx, aData[index++]); + JS::Rooted jsString(aCx, JS::ToString(aCx, value)); + if (NS_WARN_IF(!jsString)) { + return false; + } + + nsAutoJSString v; + if (NS_WARN_IF(!v.init(aCx, jsString))) { + return false; + } + + output.Append(v); + } + break; + + case 'd': + case 'i': + if (index < aData.Length()) { + JS::Rooted value(aCx, aData[index++]); + + int32_t v; + if (NS_WARN_IF(!JS::ToInt32(aCx, value, &v))) { + return false; + } + + nsCString format; + MakeFormatString(format, integer, mantissa, 'd'); + output.AppendPrintf(format.get(), v); + } + break; + + case 'f': + if (index < aData.Length()) { + JS::Rooted value(aCx, aData[index++]); + + double v; + if (NS_WARN_IF(!JS::ToNumber(aCx, value, &v))) { + return false; + } + + // nspr returns "nan", but we want to expose it as "NaN" + if (std::isnan(v)) { + output.AppendFloat(v); + } else { + nsCString format; + MakeFormatString(format, integer, mantissa, 'f'); + output.AppendPrintf(format.get(), v); + } + } + break; + + default: + output.Append(tmp); + break; + } + } + + if (NS_WARN_IF(!FlushOutput(aCx, aSequence, output))) { + return false; + } + + // Discard trailing style element if there is no output to apply it to. + if (aStyles.Length() > aSequence.Length()) { + aStyles.TruncateLength(aSequence.Length()); + } + + // The rest of the array, if unused by the format string. + for (; index < aData.Length(); ++index) { + if (NS_WARN_IF(!aSequence.AppendElement(aData[index], fallible))) { + return false; + } + } + + return true; +} + +void +Console::MakeFormatString(nsCString& aFormat, int32_t aInteger, + int32_t aMantissa, char aCh) const +{ + aFormat.Append('%'); + if (aInteger >= 0) { + aFormat.AppendInt(aInteger); + } + + if (aMantissa >= 0) { + aFormat.Append('.'); + aFormat.AppendInt(aMantissa); + } + + aFormat.Append(aCh); +} + +void +Console::ComposeGroupName(JSContext* aCx, + const Sequence& aData, + nsAString& aName) const +{ + for (uint32_t i = 0; i < aData.Length(); ++i) { + if (i != 0) { + aName.AppendASCII(" "); + } + + JS::Rooted value(aCx, aData[i]); + JS::Rooted jsString(aCx, JS::ToString(aCx, value)); + if (!jsString) { + return; + } + + nsAutoJSString string; + if (!string.init(aCx, jsString)) { + return; + } + + aName.Append(string); + } +} + +bool +Console::StartTimer(JSContext* aCx, const JS::Value& aName, + DOMHighResTimeStamp aTimestamp, + nsAString& aTimerLabel, + DOMHighResTimeStamp* aTimerValue) +{ + AssertIsOnOwningThread(); + MOZ_ASSERT(aTimerValue); + + *aTimerValue = 0; + + if (NS_WARN_IF(mTimerRegistry.Count() >= MAX_PAGE_TIMERS)) { + return false; + } + + JS::Rooted name(aCx, aName); + JS::Rooted jsString(aCx, JS::ToString(aCx, name)); + if (NS_WARN_IF(!jsString)) { + return false; + } + + nsAutoJSString label; + if (NS_WARN_IF(!label.init(aCx, jsString))) { + return false; + } + + DOMHighResTimeStamp entry = 0; + if (!mTimerRegistry.Get(label, &entry)) { + mTimerRegistry.Put(label, aTimestamp); + } else { + aTimestamp = entry; + } + + aTimerLabel = label; + *aTimerValue = aTimestamp; + return true; +} + +JS::Value +Console::CreateStartTimerValue(JSContext* aCx, const nsAString& aTimerLabel, + DOMHighResTimeStamp aTimerValue, + bool aTimerStatus) const +{ + if (!aTimerStatus) { + RootedDictionary error(aCx); + + JS::Rooted value(aCx); + if (!ToJSValue(aCx, error, &value)) { + return JS::UndefinedValue(); + } + + return value; + } + + RootedDictionary timer(aCx); + + timer.mName = aTimerLabel; + timer.mStarted = aTimerValue; + + JS::Rooted value(aCx); + if (!ToJSValue(aCx, timer, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +bool +Console::StopTimer(JSContext* aCx, const JS::Value& aName, + DOMHighResTimeStamp aTimestamp, + nsAString& aTimerLabel, + double* aTimerDuration) +{ + AssertIsOnOwningThread(); + MOZ_ASSERT(aTimerDuration); + + *aTimerDuration = 0; + + JS::Rooted name(aCx, aName); + JS::Rooted jsString(aCx, JS::ToString(aCx, name)); + if (NS_WARN_IF(!jsString)) { + return false; + } + + nsAutoJSString key; + if (NS_WARN_IF(!key.init(aCx, jsString))) { + return false; + } + + DOMHighResTimeStamp entry = 0; + if (NS_WARN_IF(!mTimerRegistry.Get(key, &entry))) { + return false; + } + + mTimerRegistry.Remove(key); + + aTimerLabel = key; + *aTimerDuration = aTimestamp - entry; + return true; +} + +JS::Value +Console::CreateStopTimerValue(JSContext* aCx, const nsAString& aLabel, + double aDuration, bool aStatus) const +{ + if (!aStatus) { + return JS::UndefinedValue(); + } + + RootedDictionary timer(aCx); + timer.mName = aLabel; + timer.mDuration = aDuration; + + JS::Rooted value(aCx); + if (!ToJSValue(aCx, timer, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +bool +Console::ArgumentsToValueList(const Sequence& aData, + Sequence& aSequence) const +{ + for (uint32_t i = 0; i < aData.Length(); ++i) { + if (NS_WARN_IF(!aSequence.AppendElement(aData[i], fallible))) { + return false; + } + } + + return true; +} + +uint32_t +Console::IncreaseCounter(JSContext* aCx, const ConsoleStackEntry& aFrame, + const Sequence& aArguments, + nsAString& aCountLabel) +{ + AssertIsOnOwningThread(); + + ClearException ce(aCx); + + nsAutoString key; + nsAutoString label; + + if (!aArguments.IsEmpty()) { + JS::Rooted labelValue(aCx, aArguments[0]); + JS::Rooted jsString(aCx, JS::ToString(aCx, labelValue)); + + nsAutoJSString string; + if (jsString && string.init(aCx, jsString)) { + label = string; + key = string; + } + } + + if (key.IsEmpty()) { + key.Append(aFrame.mFilename); + key.Append(':'); + key.AppendInt(aFrame.mLineNumber); + } + + uint32_t count = 0; + if (!mCounterRegistry.Get(key, &count) && + mCounterRegistry.Count() >= MAX_PAGE_COUNTERS) { + return MAX_PAGE_COUNTERS; + } + + ++count; + mCounterRegistry.Put(key, count); + + aCountLabel = label; + return count; +} + +JS::Value +Console::CreateCounterValue(JSContext* aCx, const nsAString& aCountLabel, + uint32_t aCountValue) const +{ + ClearException ce(aCx); + + if (aCountValue == MAX_PAGE_COUNTERS) { + RootedDictionary error(aCx); + + JS::Rooted value(aCx); + if (!ToJSValue(aCx, error, &value)) { + return JS::UndefinedValue(); + } + + return value; + } + + RootedDictionary data(aCx); + data.mLabel = aCountLabel; + data.mCount = aCountValue; + + JS::Rooted value(aCx); + if (!ToJSValue(aCx, data, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +bool +Console::ShouldIncludeStackTrace(MethodName aMethodName) const +{ + switch (aMethodName) { + case MethodError: + case MethodException: + case MethodAssert: + case MethodTrace: + return true; + default: + return false; + } +} + +JSObject* +Console::GetOrCreateSandbox(JSContext* aCx, nsIPrincipal* aPrincipal) +{ + AssertIsOnMainThread(); + + if (!mSandbox) { + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + MOZ_ASSERT(xpc, "This should never be null!"); + + JS::Rooted sandbox(aCx); + nsresult rv = xpc->CreateSandbox(aCx, aPrincipal, sandbox.address()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + mSandbox = new JSObjectHolder(aCx, sandbox); + } + + return mSandbox->GetJSObject(); +} + +void +Console::StoreCallData(ConsoleCallData* aCallData) +{ + AssertIsOnOwningThread(); + + MOZ_ASSERT(aCallData); + MOZ_ASSERT(!mCallDataStorage.Contains(aCallData)); + MOZ_ASSERT(!mCallDataStoragePending.Contains(aCallData)); + + mCallDataStorage.AppendElement(aCallData); + + if (mCallDataStorage.Length() > STORAGE_MAX_EVENTS) { + RefPtr callData = mCallDataStorage[0]; + mCallDataStorage.RemoveElementAt(0); + + MOZ_ASSERT(callData->mStatus != ConsoleCallData::eToBeDeleted); + + // We cannot delete this object now because we have to trace its JSValues + // until the pending operation (ConsoleCallDataRunnable) is completed. + if (callData->mStatus == ConsoleCallData::eInUse) { + callData->mStatus = ConsoleCallData::eToBeDeleted; + mCallDataStoragePending.AppendElement(callData); + } + } +} + +void +Console::UnstoreCallData(ConsoleCallData* aCallData) +{ + AssertIsOnOwningThread(); + + MOZ_ASSERT(aCallData); + + MOZ_ASSERT(!mCallDataStoragePending.Contains(aCallData)); + + // It can be that mCallDataStorage has been already cleaned in case the + // processing of the argument of some Console methods triggers the + // window.close(). + + mCallDataStorage.RemoveElement(aCallData); +} + +void +Console::ReleaseCallData(ConsoleCallData* aCallData) +{ + AssertIsOnOwningThread(); + MOZ_ASSERT(aCallData); + MOZ_ASSERT(aCallData->mStatus == ConsoleCallData::eToBeDeleted); + MOZ_ASSERT(mCallDataStoragePending.Contains(aCallData)); + + mCallDataStoragePending.RemoveElement(aCallData); +} + +void +Console::NotifyHandler(JSContext* aCx, const Sequence& aArguments, + ConsoleCallData* aCallData) const +{ + AssertIsOnOwningThread(); + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(aCallData); + + if (!mConsoleEventNotifier) { + return; + } + + JS::Rooted value(aCx); + + // aCx and aArguments are in the same compartment because this method is + // called directly when a Console.something() runs. + // mConsoleEventNotifier->Callable() is the scope where value will be sent to. + if (NS_WARN_IF(!PopulateConsoleNotificationInTheTargetScope(aCx, aArguments, + mConsoleEventNotifier->Callable(), + &value, + aCallData))) { + return; + } + + JS::Rooted ignored(aCx); + mConsoleEventNotifier->Call(value, &ignored); +} + +void +Console::RetrieveConsoleEvents(JSContext* aCx, nsTArray& aEvents, + ErrorResult& aRv) +{ + AssertIsOnOwningThread(); + + // We don't want to expose this functionality to main-thread yet. + MOZ_ASSERT(!NS_IsMainThread()); + + JS::Rooted targetScope(aCx, JS::CurrentGlobalOrNull(aCx)); + + for (uint32_t i = 0; i < mCallDataStorage.Length(); ++i) { + JS::Rooted value(aCx); + + JS::Rooted sequenceScope(aCx, mCallDataStorage[i]->mGlobal); + JSAutoCompartment ac(aCx, sequenceScope); + + Sequence sequence; + SequenceRooter arguments(aCx, &sequence); + + if (!mCallDataStorage[i]->PopulateArgumentsSequence(sequence)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + // Here we have aCx and sequence in the same compartment. + // targetScope is the destination scope and value will be populated in its + // compartment. + if (NS_WARN_IF(!PopulateConsoleNotificationInTheTargetScope(aCx, sequence, + targetScope, + &value, + mCallDataStorage[i]))) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + aEvents.AppendElement(value); + } +} + +void +Console::SetConsoleEventHandler(AnyCallback* aHandler) +{ + AssertIsOnOwningThread(); + + // We don't want to expose this functionality to main-thread yet. + MOZ_ASSERT(!NS_IsMainThread()); + + mConsoleEventNotifier = aHandler; +} + +void +Console::AssertIsOnOwningThread() const +{ + MOZ_ASSERT(mOwningThread); + MOZ_ASSERT(PR_GetCurrentThread() == mOwningThread); +} + +bool +Console::IsShuttingDown() const +{ + MOZ_ASSERT(mStatus != eUnknown); + return mStatus == eShuttingDown; +} + +/* static */ already_AddRefed +Console::GetConsole(const GlobalObject& aGlobal) +{ + ErrorResult rv; + RefPtr console = GetConsoleInternal(aGlobal, rv); + if (NS_WARN_IF(rv.Failed()) || !console) { + rv.SuppressException(); + return nullptr; + } + + console->AssertIsOnOwningThread(); + + if (console->IsShuttingDown()) { + return nullptr; + } + + return console.forget(); +} + +/* static */ Console* +Console::GetConsoleInternal(const GlobalObject& aGlobal, ErrorResult& aRv) +{ + // Worklet + if (NS_IsMainThread()) { + nsCOMPtr workletScope = + do_QueryInterface(aGlobal.GetAsSupports()); + if (workletScope) { + return workletScope->GetConsole(aRv); + } + } + + // Window + if (NS_IsMainThread()) { + nsCOMPtr innerWindow = + do_QueryInterface(aGlobal.GetAsSupports()); + if (NS_WARN_IF(!innerWindow)) { + return nullptr; + } + + nsGlobalWindow* window = nsGlobalWindow::Cast(innerWindow); + return window->GetConsole(aRv); + } + + // Workers + MOZ_ASSERT(!NS_IsMainThread()); + + JSContext* cx = aGlobal.Context(); + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx); + MOZ_ASSERT(workerPrivate); + + nsCOMPtr global = + do_QueryInterface(aGlobal.GetAsSupports()); + if (NS_WARN_IF(!global)) { + return nullptr; + } + + WorkerGlobalScope* scope = workerPrivate->GlobalScope(); + MOZ_ASSERT(scope); + + // Normal worker scope. + if (scope == global) { + return scope->GetConsole(aRv); + } + + // Debugger worker scope + else { + WorkerDebuggerGlobalScope* debuggerScope = + workerPrivate->DebuggerGlobalScope(); + MOZ_ASSERT(debuggerScope); + MOZ_ASSERT(debuggerScope == global, "Which kind of global do we have?"); + + return debuggerScope->GetConsole(aRv); + } +} + +} // namespace dom +} // namespace mozilla -- cgit v1.2.3