diff options
Diffstat (limited to 'dom/console')
37 files changed, 5814 insertions, 0 deletions
diff --git a/dom/console/Console.cpp b/dom/console/Console.cpp new file mode 100644 index 0000000000..252ddcd08f --- /dev/null +++ b/dom/console/Console.cpp @@ -0,0 +1,2972 @@ +/* -*- 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/ConsoleInstance.h" +#include "mozilla/dom/ConsoleBinding.h" +#include "ConsoleCommon.h" + +#include "js/Array.h" // JS::GetArrayLength, JS::NewArrayObject +#include "js/PropertyAndElement.h" // JS_DefineElement, JS_DefineProperty, JS_GetElement +#include "mozilla/dom/BlobBinding.h" +#include "mozilla/dom/BlobImpl.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/ElementBinding.h" +#include "mozilla/dom/Exceptions.h" +#include "mozilla/dom/File.h" +#include "mozilla/dom/FunctionBinding.h" +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/PromiseBinding.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/StructuredCloneHolder.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/dom/WorkerRunnable.h" +#include "mozilla/dom/WorkerScope.h" +#include "mozilla/dom/WorkletGlobalScope.h" +#include "mozilla/dom/WorkletImpl.h" +#include "mozilla/dom/WorkletThread.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/HoldDropJSObjects.h" +#include "mozilla/JSObjectHolder.h" +#include "mozilla/Maybe.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_devtools.h" +#include "mozilla/StaticPrefs_dom.h" +#include "nsCycleCollectionParticipant.h" +#include "nsDOMNavigationTiming.h" +#include "nsGlobalWindowInner.h" +#include "nsJSUtils.h" +#include "nsNetUtil.h" +#include "xpcpublic.h" +#include "nsContentUtils.h" +#include "nsDocShell.h" +#include "nsProxyRelease.h" +#include "nsReadableUtils.h" + +#include "nsIConsoleAPIStorage.h" +#include "nsIException.h" // for nsIStackFrame +#include "nsIInterfaceRequestorUtils.h" +#include "nsILoadContext.h" +#include "nsISensitiveInfoHiddenURI.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; + +namespace mozilla::dom { + +struct ConsoleStructuredCloneData { + nsCOMPtr<nsIGlobalObject> mGlobal; + nsTArray<RefPtr<BlobImpl>> mBlobs; +}; + +static void ComposeAndStoreGroupName(JSContext* aCx, + const Sequence<JS::Value>& aData, + nsAString& aName, + nsTArray<nsString>* aGroupStack); +static bool UnstoreGroupName(nsAString& aName, nsTArray<nsString>* aGroupStack); + +static bool ProcessArguments(JSContext* aCx, const Sequence<JS::Value>& aData, + Sequence<JS::Value>& aSequence, + Sequence<nsString>& aStyles); + +static JS::Value CreateCounterOrResetCounterValue(JSContext* aCx, + const nsAString& aCountLabel, + uint32_t aCountValue); + +/** + * 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_THREADSAFE_REFCOUNTING(ConsoleCallData) + + ConsoleCallData(Console::MethodName aName, const nsAString& aString, + Console* aConsole) + : mConsoleID(aConsole->mConsoleID), + mPrefix(aConsole->mPrefix), + mMethodName(aName), + mMicroSecondTimeStamp(JS_Now()), + mStartTimerValue(0), + mStartTimerStatus(Console::eTimerUnknown), + mLogTimerDuration(0), + mLogTimerStatus(Console::eTimerUnknown), + mCountValue(MAX_PAGE_COUNTERS), + mIDType(eUnknown), + mOuterIDNumber(0), + mInnerIDNumber(0), + mMethodString(aString) {} + + 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 OriginAttributes& aOriginAttributes) { + mOriginAttributes = aOriginAttributes; + } + + void SetAddonId(nsIPrincipal* aPrincipal) { + nsAutoString addonId; + aPrincipal->GetAddonId(addonId); + + mAddonId = addonId; + } + + void AssertIsOnOwningThread() const { + NS_ASSERT_OWNINGTHREAD(ConsoleCallData); + } + + const nsString mConsoleID; + const nsString mPrefix; + + const Console::MethodName mMethodName; + int64_t mMicroSecondTimeStamp; + + // 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; + Console::TimerStatus mStartTimerStatus; + + // These values are set in the owning thread and they contain the duration, + // the name and the status of the LogTimer 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 + // ConsoleTimerLogOrEnd dictionary. This members are set when + // console.timeEnd() or console.timeLog() are called. + double mLogTimerDuration; + nsString mLogTimerLabel; + Console::TimerStatus mLogTimerStatus; + + // These 2 values are set by IncreaseCounter or ResetCounter on the owning + // thread and they are used by CreateCounterOrResetCounterValue. + // These members are set when console.count() or console.countReset() are + // 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.sys.mjs the ID is 'jsm'. + enum { eString, eNumber, eUnknown } mIDType; + + uint64_t mOuterIDNumber; + nsString mOuterIDString; + + uint64_t mInnerIDNumber; + nsString mInnerIDString; + + OriginAttributes mOriginAttributes; + + nsString mAddonId; + + const 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<ConsoleStackEntry> mTopStackFrame; + Maybe<nsTArray<ConsoleStackEntry>> mReifiedStack; + nsCOMPtr<nsIStackFrame> mStack; + + private: + ~ConsoleCallData() = default; + + NS_DECL_OWNINGTHREAD; +}; + +// MainThreadConsoleData instances are created on the Console thread and +// referenced from both main and Console threads in order to provide the same +// object for any ConsoleRunnables relating to the same Console. A Console +// owns a MainThreadConsoleData; MainThreadConsoleData does not keep its +// Console alive. +class MainThreadConsoleData final { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MainThreadConsoleData); + + JSObject* GetOrCreateSandbox(JSContext* aCx, nsIPrincipal* aPrincipal); + // This method must receive aCx and aArguments in the same JS::Compartment. + void ProcessCallData(JSContext* aCx, ConsoleCallData* aData, + const Sequence<JS::Value>& aArguments); + + private: + ~MainThreadConsoleData() { + NS_ReleaseOnMainThread("MainThreadConsoleData::mStorage", + mStorage.forget()); + NS_ReleaseOnMainThread("MainThreadConsoleData::mSandbox", + mSandbox.forget()); + } + + // All members, except for mRefCnt, are accessed only on the main thread, + // except in MainThreadConsoleData destruction, at which point there are no + // other references. + nsCOMPtr<nsIConsoleAPIStorage> mStorage; + RefPtr<JSObjectHolder> mSandbox; + nsTArray<nsString> mGroupStack; +}; + +// This base class must be extended for Worker and for Worklet. +class ConsoleRunnable : public StructuredCloneHolderBase { + public: + ~ConsoleRunnable() override { + MOZ_ASSERT(!mClonedData.mGlobal, + "mClonedData.mGlobal is set and cleared in a main thread scope"); + // Clear the StructuredCloneHolderBase class. + Clear(); + } + + protected: + JSObject* CustomReadHandler(JSContext* aCx, JSStructuredCloneReader* aReader, + const JS::CloneDataPolicy& aCloneDataPolicy, + uint32_t aTag, uint32_t aIndex) override { + AssertIsOnMainThread(); + + if (aTag == CONSOLE_TAG_BLOB) { + MOZ_ASSERT(mClonedData.mBlobs.Length() > aIndex); + + JS::Rooted<JS::Value> val(aCx); + { + nsCOMPtr<nsIGlobalObject> global = mClonedData.mGlobal; + RefPtr<Blob> blob = + Blob::Create(global, mClonedData.mBlobs.ElementAt(aIndex)); + if (!ToJSValue(aCx, blob, &val)) { + return nullptr; + } + } + + return &val.toObject(); + } + + MOZ_CRASH("No other tags are supported."); + return nullptr; + } + + bool CustomWriteHandler(JSContext* aCx, JSStructuredCloneWriter* aWriter, + JS::Handle<JSObject*> aObj, + bool* aSameProcessScopeRequired) override { + RefPtr<Blob> blob; + if (NS_SUCCEEDED(UNWRAP_OBJECT(Blob, aObj, blob))) { + 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<JS::Value> value(aCx, JS::ObjectOrNullValue(aObj)); + JS::Rooted<JSString*> 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; + } + + // Helper method for CallData + void ProcessCallData(JSContext* aCx, MainThreadConsoleData* aConsoleData, + ConsoleCallData* aCallData) { + AssertIsOnMainThread(); + + ConsoleCommon::ClearException ce(aCx); + + // This is the same policy as when writing from the other side, in + // WriteData. + JS::CloneDataPolicy cloneDataPolicy; + cloneDataPolicy.allowIntraClusterClonableSharedObjects(); + cloneDataPolicy.allowSharedMemoryObjects(); + + JS::Rooted<JS::Value> argumentsValue(aCx); + if (!Read(aCx, &argumentsValue, cloneDataPolicy)) { + return; + } + + MOZ_ASSERT(argumentsValue.isObject()); + + JS::Rooted<JSObject*> argumentsObj(aCx, &argumentsValue.toObject()); + + uint32_t length; + if (!JS::GetArrayLength(aCx, argumentsObj, &length)) { + return; + } + + Sequence<JS::Value> values; + SequenceRooter<JS::Value> arguments(aCx, &values); + + for (uint32_t i = 0; i < length; ++i) { + JS::Rooted<JS::Value> value(aCx); + + if (!JS_GetElement(aCx, argumentsObj, i, &value)) { + return; + } + + if (!values.AppendElement(value, fallible)) { + return; + } + } + + MOZ_ASSERT(values.Length() == length); + + aConsoleData->ProcessCallData(aCx, aCallData, values); + } + + // Generic + bool WriteArguments(JSContext* aCx, const Sequence<JS::Value>& aArguments) { + ConsoleCommon::ClearException ce(aCx); + + JS::Rooted<JSObject*> arguments( + aCx, JS::NewArrayObject(aCx, aArguments.Length())); + if (NS_WARN_IF(!arguments)) { + return false; + } + + JS::Rooted<JS::Value> arg(aCx); + for (uint32_t i = 0; i < aArguments.Length(); ++i) { + arg = aArguments[i]; + if (NS_WARN_IF( + !JS_DefineElement(aCx, arguments, i, arg, JSPROP_ENUMERATE))) { + return false; + } + } + + JS::Rooted<JS::Value> value(aCx, JS::ObjectValue(*arguments)); + return WriteData(aCx, value); + } + + // Helper method for Profile calls + void ProcessProfileData(JSContext* aCx, Console::MethodName aMethodName, + const nsAString& aAction) { + AssertIsOnMainThread(); + + ConsoleCommon::ClearException ce(aCx); + + JS::Rooted<JS::Value> argumentsValue(aCx); + bool ok = Read(aCx, &argumentsValue); + mClonedData.mGlobal = nullptr; + + if (!ok) { + return; + } + + MOZ_ASSERT(argumentsValue.isObject()); + JS::Rooted<JSObject*> argumentsObj(aCx, &argumentsValue.toObject()); + if (NS_WARN_IF(!argumentsObj)) { + return; + } + + uint32_t length; + if (!JS::GetArrayLength(aCx, argumentsObj, &length)) { + return; + } + + Sequence<JS::Value> arguments; + + for (uint32_t i = 0; i < length; ++i) { + JS::Rooted<JS::Value> value(aCx); + + if (!JS_GetElement(aCx, argumentsObj, i, &value)) { + return; + } + + if (!arguments.AppendElement(value, fallible)) { + return; + } + } + + Console::ProfileMethodMainthread(aCx, aAction, arguments); + } + + bool WriteData(JSContext* aCx, JS::Handle<JS::Value> aValue) { + // We use structuredClone to send the JSValue to the main-thread, in order + // to store it into the Console API Service. The consumer will be the + // console panel in the devtools and, because of this, we want to allow the + // cloning of sharedArrayBuffers and WASM modules. + JS::CloneDataPolicy cloneDataPolicy; + cloneDataPolicy.allowIntraClusterClonableSharedObjects(); + cloneDataPolicy.allowSharedMemoryObjects(); + + if (NS_WARN_IF( + !Write(aCx, aValue, JS::UndefinedHandleValue, cloneDataPolicy))) { + // Ignore the message. + return false; + } + + return true; + } + + ConsoleStructuredCloneData mClonedData; +}; + +class ConsoleWorkletRunnable : public Runnable, public ConsoleRunnable { + protected: + explicit ConsoleWorkletRunnable(Console* aConsole) + : Runnable("dom::console::ConsoleWorkletRunnable"), + mConsoleData(aConsole->GetOrCreateMainThreadData()) { + WorkletThread::AssertIsOnWorkletThread(); + nsCOMPtr<WorkletGlobalScope> global = do_QueryInterface(aConsole->mGlobal); + MOZ_ASSERT(global); + mWorkletImpl = global->Impl(); + MOZ_ASSERT(mWorkletImpl); + } + + ~ConsoleWorkletRunnable() override = default; + + protected: + RefPtr<MainThreadConsoleData> mConsoleData; + + RefPtr<WorkletImpl> mWorkletImpl; +}; + +// This runnable appends a CallData object into the Console queue running on +// the main-thread. +class ConsoleCallDataWorkletRunnable final : public ConsoleWorkletRunnable { + public: + static already_AddRefed<ConsoleCallDataWorkletRunnable> Create( + JSContext* aCx, Console* aConsole, ConsoleCallData* aConsoleData, + const Sequence<JS::Value>& aArguments) { + WorkletThread::AssertIsOnWorkletThread(); + + RefPtr<ConsoleCallDataWorkletRunnable> runnable = + new ConsoleCallDataWorkletRunnable(aConsole, aConsoleData); + + if (!runnable->WriteArguments(aCx, aArguments)) { + return nullptr; + } + + return runnable.forget(); + } + + private: + ConsoleCallDataWorkletRunnable(Console* aConsole, ConsoleCallData* aCallData) + : ConsoleWorkletRunnable(aConsole), mCallData(aCallData) { + WorkletThread::AssertIsOnWorkletThread(); + MOZ_ASSERT(aCallData); + aCallData->AssertIsOnOwningThread(); + + const WorkletLoadInfo& loadInfo = mWorkletImpl->LoadInfo(); + mCallData->SetIDs(loadInfo.OuterWindowID(), loadInfo.InnerWindowID()); + } + + ~ConsoleCallDataWorkletRunnable() override = default; + + NS_IMETHOD Run() override { + AssertIsOnMainThread(); + AutoJSAPI jsapi; + jsapi.Init(); + JSContext* cx = jsapi.cx(); + + JSObject* sandbox = + mConsoleData->GetOrCreateSandbox(cx, mWorkletImpl->Principal()); + JS::Rooted<JSObject*> global(cx, sandbox); + if (NS_WARN_IF(!global)) { + return NS_ERROR_FAILURE; + } + + // The CreateSandbox call returns a proxy to the actual sandbox object. We + // don't need a proxy here. + global = js::UncheckedUnwrap(global); + + JSAutoRealm ar(cx, global); + + // We don't need to set a parent object in mCallData bacause there are not + // DOM objects exposed to worklet. + + ProcessCallData(cx, mConsoleData, mCallData); + + return NS_OK; + } + + RefPtr<ConsoleCallData> mCallData; +}; + +class ConsoleWorkerRunnable : public WorkerProxyToMainThreadRunnable, + public ConsoleRunnable { + public: + explicit ConsoleWorkerRunnable(Console* aConsole) + : mConsoleData(aConsole->GetOrCreateMainThreadData()) {} + + ~ConsoleWorkerRunnable() override = default; + + bool Dispatch(JSContext* aCx, const Sequence<JS::Value>& aArguments) { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + if (NS_WARN_IF(!WriteArguments(aCx, aArguments))) { + RunBackOnWorkerThreadForCleanup(workerPrivate); + return false; + } + + if (NS_WARN_IF(!WorkerProxyToMainThreadRunnable::Dispatch(workerPrivate))) { + // RunBackOnWorkerThreadForCleanup() will be called by + // WorkerProxyToMainThreadRunnable::Dispatch(). + return false; + } + + return true; + } + + protected: + void RunOnMainThread(WorkerPrivate* aWorkerPrivate) override { + MOZ_ASSERT(aWorkerPrivate); + AssertIsOnMainThread(); + + // Walk up to our containing page + WorkerPrivate* wp = aWorkerPrivate; + while (wp->GetParent()) { + wp = wp->GetParent(); + } + + nsCOMPtr<nsPIDOMWindowInner> window = wp->GetWindow(); + if (!window) { + RunWindowless(aWorkerPrivate); + } else { + RunWithWindow(aWorkerPrivate, window); + } + } + + void RunWithWindow(WorkerPrivate* aWorkerPrivate, + nsPIDOMWindowInner* aWindow) { + MOZ_ASSERT(aWorkerPrivate); + AssertIsOnMainThread(); + + AutoJSAPI jsapi; + MOZ_ASSERT(aWindow); + + RefPtr<nsGlobalWindowInner> win = nsGlobalWindowInner::Cast(aWindow); + if (NS_WARN_IF(!jsapi.Init(win))) { + return; + } + + nsCOMPtr<nsPIDOMWindowOuter> outerWindow = aWindow->GetOuterWindow(); + if (NS_WARN_IF(!outerWindow)) { + return; + } + + RunConsole(jsapi.cx(), aWindow->AsGlobal(), aWorkerPrivate, outerWindow, + aWindow); + } + + void RunWindowless(WorkerPrivate* aWorkerPrivate) { + MOZ_ASSERT(aWorkerPrivate); + AssertIsOnMainThread(); + + WorkerPrivate* wp = aWorkerPrivate; + while (wp->GetParent()) { + wp = wp->GetParent(); + } + + MOZ_ASSERT(!wp->GetWindow()); + + AutoJSAPI jsapi; + jsapi.Init(); + + JSContext* cx = jsapi.cx(); + + JS::Rooted<JSObject*> global( + cx, mConsoleData->GetOrCreateSandbox(cx, wp->GetPrincipal())); + if (NS_WARN_IF(!global)) { + return; + } + + // The GetOrCreateSandbox call returns a proxy to the actual sandbox object. + // We don't need a proxy here. + global = js::UncheckedUnwrap(global); + + JSAutoRealm ar(cx, global); + + nsCOMPtr<nsIGlobalObject> globalObject = xpc::NativeGlobal(global); + if (NS_WARN_IF(!globalObject)) { + return; + } + + RunConsole(cx, globalObject, aWorkerPrivate, nullptr, nullptr); + } + + void RunBackOnWorkerThreadForCleanup(WorkerPrivate* aWorkerPrivate) override { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + } + + // This method is called in the main-thread. + virtual void RunConsole(JSContext* aCx, nsIGlobalObject* aGlobal, + WorkerPrivate* aWorkerPrivate, + nsPIDOMWindowOuter* aOuterWindow, + nsPIDOMWindowInner* aInnerWindow) = 0; + + bool ForMessaging() const override { return true; } + + RefPtr<MainThreadConsoleData> mConsoleData; +}; + +// This runnable appends a CallData object into the Console queue running on +// the main-thread. +class ConsoleCallDataWorkerRunnable final : public ConsoleWorkerRunnable { + public: + ConsoleCallDataWorkerRunnable(Console* aConsole, ConsoleCallData* aCallData) + : ConsoleWorkerRunnable(aConsole), mCallData(aCallData) { + MOZ_ASSERT(aCallData); + mCallData->AssertIsOnOwningThread(); + } + + private: + ~ConsoleCallDataWorkerRunnable() override = default; + + void RunConsole(JSContext* aCx, nsIGlobalObject* aGlobal, + WorkerPrivate* aWorkerPrivate, + nsPIDOMWindowOuter* aOuterWindow, + nsPIDOMWindowInner* aInnerWindow) override { + MOZ_ASSERT(aGlobal); + MOZ_ASSERT(aWorkerPrivate); + AssertIsOnMainThread(); + + // The windows have to run in parallel. + MOZ_ASSERT(!!aOuterWindow == !!aInnerWindow); + + if (aOuterWindow) { + mCallData->SetIDs(aOuterWindow->WindowID(), aInnerWindow->WindowID()); + } else { + ConsoleStackEntry frame; + if (mCallData->mTopStackFrame) { + frame = *mCallData->mTopStackFrame; + } + + nsString id = frame.mFilename; + nsString innerID; + if (aWorkerPrivate->IsSharedWorker()) { + innerID = u"SharedWorker"_ns; + } else if (aWorkerPrivate->IsServiceWorker()) { + innerID = u"ServiceWorker"_ns; + // Use scope as ID so the webconsole can decide if the message should + // show up per tab + CopyASCIItoUTF16(aWorkerPrivate->ServiceWorkerScope(), id); + } else { + innerID = u"Worker"_ns; + } + + mCallData->SetIDs(id, innerID); + } + + mClonedData.mGlobal = aGlobal; + + ProcessCallData(aCx, mConsoleData, mCallData); + + mClonedData.mGlobal = nullptr; + } + + RefPtr<ConsoleCallData> mCallData; +}; + +// This runnable calls ProfileMethod() on the console on the main-thread. +class ConsoleProfileWorkletRunnable final : public ConsoleWorkletRunnable { + public: + static already_AddRefed<ConsoleProfileWorkletRunnable> Create( + JSContext* aCx, Console* aConsole, Console::MethodName aName, + const nsAString& aAction, const Sequence<JS::Value>& aArguments) { + WorkletThread::AssertIsOnWorkletThread(); + + RefPtr<ConsoleProfileWorkletRunnable> runnable = + new ConsoleProfileWorkletRunnable(aConsole, aName, aAction); + + if (!runnable->WriteArguments(aCx, aArguments)) { + return nullptr; + } + + return runnable.forget(); + } + + private: + ConsoleProfileWorkletRunnable(Console* aConsole, Console::MethodName aName, + const nsAString& aAction) + : ConsoleWorkletRunnable(aConsole), mName(aName), mAction(aAction) { + MOZ_ASSERT(aConsole); + } + + NS_IMETHOD Run() override { + AssertIsOnMainThread(); + + AutoJSAPI jsapi; + jsapi.Init(); + JSContext* cx = jsapi.cx(); + + JSObject* sandbox = + mConsoleData->GetOrCreateSandbox(cx, mWorkletImpl->Principal()); + JS::Rooted<JSObject*> global(cx, sandbox); + if (NS_WARN_IF(!global)) { + return NS_ERROR_FAILURE; + } + + // The CreateSandbox call returns a proxy to the actual sandbox object. We + // don't need a proxy here. + global = js::UncheckedUnwrap(global); + + JSAutoRealm ar(cx, global); + + // We don't need to set a parent object in mCallData bacause there are not + // DOM objects exposed to worklet. + ProcessProfileData(cx, mName, mAction); + + return NS_OK; + } + + Console::MethodName mName; + nsString mAction; +}; + +// This runnable calls ProfileMethod() on the console on the main-thread. +class ConsoleProfileWorkerRunnable final : public ConsoleWorkerRunnable { + public: + ConsoleProfileWorkerRunnable(Console* aConsole, Console::MethodName aName, + const nsAString& aAction) + : ConsoleWorkerRunnable(aConsole), mName(aName), mAction(aAction) { + MOZ_ASSERT(aConsole); + } + + private: + void RunConsole(JSContext* aCx, nsIGlobalObject* aGlobal, + WorkerPrivate* aWorkerPrivate, + nsPIDOMWindowOuter* aOuterWindow, + nsPIDOMWindowInner* aInnerWindow) override { + AssertIsOnMainThread(); + MOZ_ASSERT(aGlobal); + + mClonedData.mGlobal = aGlobal; + + ProcessProfileData(aCx, mName, mAction); + + mClonedData.mGlobal = nullptr; + } + + Console::MethodName mName; + nsString mAction; +}; + +NS_IMPL_CYCLE_COLLECTION_CLASS(Console) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Console) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsoleEventNotifier) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mDumpFunction) + NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE + tmp->Shutdown(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Console) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsoleEventNotifier) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDumpFunction) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Console) + for (uint32_t i = 0; i < tmp->mArgumentStorage.length(); ++i) { + tmp->mArgumentStorage[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> Console::Create(JSContext* aCx, + nsPIDOMWindowInner* aWindow, + ErrorResult& aRv) { + MOZ_ASSERT_IF(NS_IsMainThread(), aWindow); + + uint64_t outerWindowID = 0; + uint64_t innerWindowID = 0; + + if (aWindow) { + innerWindowID = aWindow->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 = aWindow->GetOuterWindow(); + if (outerWindow) { + outerWindowID = outerWindow->WindowID(); + } + } + + RefPtr<Console> console = new Console(aCx, nsGlobalWindowInner::Cast(aWindow), + outerWindowID, innerWindowID); + console->Initialize(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + return console.forget(); +} + +/* static */ +already_AddRefed<Console> Console::CreateForWorklet(JSContext* aCx, + nsIGlobalObject* aGlobal, + uint64_t aOuterWindowID, + uint64_t aInnerWindowID, + ErrorResult& aRv) { + WorkletThread::AssertIsOnWorkletThread(); + + RefPtr<Console> console = + new Console(aCx, aGlobal, aOuterWindowID, aInnerWindowID); + console->Initialize(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + return console.forget(); +} + +Console::Console(JSContext* aCx, nsIGlobalObject* aGlobal, + uint64_t aOuterWindowID, uint64_t aInnerWindowID) + : mGlobal(aGlobal), + mOuterID(aOuterWindowID), + mInnerID(aInnerWindowID), + mDumpToStdout(false), + mChromeInstance(false), + mCurrentLogLevel(WebIDLLogLevelToInteger(ConsoleLogLevel::All)), + mStatus(eUnknown), + mCreationTimeStamp(TimeStamp::Now()) { + // Let's enable the dumping to stdout by default for chrome. + if (nsContentUtils::ThreadsafeIsSystemCaller(aCx)) { + mDumpToStdout = StaticPrefs::devtools_console_stdout_chrome(); + } else { + mDumpToStdout = StaticPrefs::devtools_console_stdout_content(); + } + + mozilla::HoldJSObjects(this); +} + +Console::~Console() { + AssertIsOnOwningThread(); + Shutdown(); + mozilla::DropJSObjects(this); +} + +void Console::Initialize(ErrorResult& aRv) { + AssertIsOnOwningThread(); + MOZ_ASSERT(mStatus == eUnknown); + + if (NS_IsMainThread()) { + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + if (mInnerID) { + 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<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + obs->RemoveObserver(this, "inner-window-destroyed"); + obs->RemoveObserver(this, "memory-pressure"); + } + } + + mTimerRegistry.Clear(); + mCounterRegistry.Clear(); + + ClearStorage(); + mCallDataStorage.Clear(); + + mStatus = eShuttingDown; +} + +NS_IMETHODIMP +Console::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + AssertIsOnMainThread(); + + if (!strcmp(aTopic, "inner-window-destroyed")) { + nsCOMPtr<nsISupportsPRUint64> 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(); + mArgumentStorage.clearAndFree(); +} + +#define METHOD(name, string) \ + /* static */ void Console::name(const GlobalObject& aGlobal, \ + const Sequence<JS::Value>& aData) { \ + Method(aGlobal, Method##name, nsLiteralString(string), aData); \ + } + +METHOD(Log, u"log") +METHOD(Info, u"info") +METHOD(Warn, u"warn") +METHOD(Error, u"error") +METHOD(Exception, u"exception") +METHOD(Debug, u"debug") +METHOD(Table, u"table") +METHOD(Trace, u"trace") + +// Displays an interactive listing of all the properties of an object. +METHOD(Dir, u"dir"); +METHOD(Dirxml, u"dirxml"); + +METHOD(Group, u"group") +METHOD(GroupCollapsed, u"groupCollapsed") + +#undef METHOD + +/* static */ +void Console::Clear(const GlobalObject& aGlobal) { + const Sequence<JS::Value> data; + Method(aGlobal, MethodClear, u"clear"_ns, data); +} + +/* static */ +void Console::GroupEnd(const GlobalObject& aGlobal) { + const Sequence<JS::Value> data; + Method(aGlobal, MethodGroupEnd, u"groupEnd"_ns, data); +} + +/* static */ +void Console::Time(const GlobalObject& aGlobal, const nsAString& aLabel) { + StringMethod(aGlobal, aLabel, Sequence<JS::Value>(), MethodTime, u"time"_ns); +} + +/* static */ +void Console::TimeEnd(const GlobalObject& aGlobal, const nsAString& aLabel) { + StringMethod(aGlobal, aLabel, Sequence<JS::Value>(), MethodTimeEnd, + u"timeEnd"_ns); +} + +/* static */ +void Console::TimeLog(const GlobalObject& aGlobal, const nsAString& aLabel, + const Sequence<JS::Value>& aData) { + StringMethod(aGlobal, aLabel, aData, MethodTimeLog, u"timeLog"_ns); +} + +/* static */ +void Console::StringMethod(const GlobalObject& aGlobal, const nsAString& aLabel, + const Sequence<JS::Value>& aData, + MethodName aMethodName, + const nsAString& aMethodString) { + RefPtr<Console> console = GetConsole(aGlobal); + if (!console) { + return; + } + + console->StringMethodInternal(aGlobal.Context(), aLabel, aData, aMethodName, + aMethodString); +} + +void Console::StringMethodInternal(JSContext* aCx, const nsAString& aLabel, + const Sequence<JS::Value>& aData, + MethodName aMethodName, + const nsAString& aMethodString) { + ConsoleCommon::ClearException ce(aCx); + + Sequence<JS::Value> data; + SequenceRooter<JS::Value> rooter(aCx, &data); + + JS::Rooted<JS::Value> value(aCx); + if (!dom::ToJSValue(aCx, aLabel, &value)) { + return; + } + + if (!data.AppendElement(value, fallible)) { + return; + } + + for (uint32_t i = 0; i < aData.Length(); ++i) { + if (!data.AppendElement(aData[i], fallible)) { + return; + } + } + + MethodInternal(aCx, aMethodName, aMethodString, data); +} + +/* static */ +void Console::TimeStamp(const GlobalObject& aGlobal, + const JS::Handle<JS::Value> aData) { + JSContext* cx = aGlobal.Context(); + + ConsoleCommon::ClearException ce(cx); + + Sequence<JS::Value> data; + SequenceRooter<JS::Value> rooter(cx, &data); + + if (aData.isString() && !data.AppendElement(aData, fallible)) { + return; + } + + Method(aGlobal, MethodTimeStamp, u"timeStamp"_ns, data); +} + +/* static */ +void Console::Profile(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData) { + ProfileMethod(aGlobal, MethodProfile, u"profile"_ns, aData); +} + +/* static */ +void Console::ProfileEnd(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData) { + ProfileMethod(aGlobal, MethodProfileEnd, u"profileEnd"_ns, aData); +} + +/* static */ +void Console::ProfileMethod(const GlobalObject& aGlobal, MethodName aName, + const nsAString& aAction, + const Sequence<JS::Value>& aData) { + RefPtr<Console> console = GetConsole(aGlobal); + if (!console) { + return; + } + + JSContext* cx = aGlobal.Context(); + console->ProfileMethodInternal(cx, aName, aAction, aData); +} + +void Console::ProfileMethodInternal(JSContext* aCx, MethodName aMethodName, + const nsAString& aAction, + const Sequence<JS::Value>& aData) { + if (!ShouldProceed(aMethodName)) { + return; + } + + MaybeExecuteDumpFunction(aCx, aAction, aData, nullptr); + + if (WorkletThread::IsOnWorkletThread()) { + RefPtr<ConsoleProfileWorkletRunnable> runnable = + ConsoleProfileWorkletRunnable::Create(aCx, this, aMethodName, aAction, + aData); + if (!runnable) { + return; + } + + NS_DispatchToMainThread(runnable.forget()); + return; + } + + if (!NS_IsMainThread()) { + // Here we are in a worker thread. + RefPtr<ConsoleProfileWorkerRunnable> runnable = + new ConsoleProfileWorkerRunnable(this, aMethodName, aAction); + + runnable->Dispatch(aCx, aData); + return; + } + + ProfileMethodMainthread(aCx, aAction, aData); +} + +// static +void Console::ProfileMethodMainthread(JSContext* aCx, const nsAString& aAction, + const Sequence<JS::Value>& aData) { + MOZ_ASSERT(NS_IsMainThread()); + ConsoleCommon::ClearException ce(aCx); + + RootedDictionary<ConsoleProfileEvent> event(aCx); + event.mAction = aAction; + event.mChromeContext = nsContentUtils::ThreadsafeIsSystemCaller(aCx); + + event.mArguments.Construct(); + Sequence<JS::Value>& sequence = event.mArguments.Value(); + + for (uint32_t i = 0; i < aData.Length(); ++i) { + if (!sequence.AppendElement(aData[i], fallible)) { + return; + } + } + + JS::Rooted<JS::Value> eventValue(aCx); + if (!ToJSValue(aCx, event, &eventValue)) { + return; + } + + JS::Rooted<JSObject*> eventObj(aCx, &eventValue.toObject()); + MOZ_ASSERT(eventObj); + + if (!JS_DefineProperty(aCx, eventObj, "wrappedJSObject", eventValue, + JSPROP_ENUMERATE)) { + return; + } + + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + nsCOMPtr<nsISupports> wrapper; + const nsIID& iid = NS_GET_IID(nsISupports); + + if (NS_FAILED(xpc->WrapJS(aCx, eventObj, iid, getter_AddRefs(wrapper)))) { + return; + } + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + obs->NotifyObservers(wrapper, "console-api-profiler", nullptr); + } +} + +/* static */ +void Console::Assert(const GlobalObject& aGlobal, bool aCondition, + const Sequence<JS::Value>& aData) { + if (!aCondition) { + Method(aGlobal, MethodAssert, u"assert"_ns, aData); + } +} + +/* static */ +void Console::Count(const GlobalObject& aGlobal, const nsAString& aLabel) { + StringMethod(aGlobal, aLabel, Sequence<JS::Value>(), MethodCount, + u"count"_ns); +} + +/* static */ +void Console::CountReset(const GlobalObject& aGlobal, const nsAString& aLabel) { + StringMethod(aGlobal, aLabel, Sequence<JS::Value>(), MethodCountReset, + u"countReset"_ns); +} + +namespace { + +void StackFrameToStackEntry(JSContext* aCx, nsIStackFrame* aStackFrame, + ConsoleStackEntry& aStackEntry) { + MOZ_ASSERT(aStackFrame); + + aStackFrame->GetFilename(aCx, aStackEntry.mFilename); + + aStackEntry.mSourceId = aStackFrame->GetSourceId(aCx); + aStackEntry.mLineNumber = aStackFrame->GetLineNumber(aCx); + aStackEntry.mColumnNumber = aStackFrame->GetColumnNumber(aCx); + + aStackFrame->GetName(aCx, aStackEntry.mFunctionName); + + nsString cause; + aStackFrame->GetAsyncCause(aCx, cause); + if (!cause.IsEmpty()) { + aStackEntry.mAsyncCause.Construct(cause); + } +} + +void ReifyStack(JSContext* aCx, nsIStackFrame* aStack, + nsTArray<ConsoleStackEntry>& aRefiedStack) { + nsCOMPtr<nsIStackFrame> stack(aStack); + + while (stack) { + ConsoleStackEntry& data = *aRefiedStack.AppendElement(); + StackFrameToStackEntry(aCx, stack, data); + + nsCOMPtr<nsIStackFrame> caller = stack->GetCaller(aCx); + + if (!caller) { + caller = stack->GetAsyncCaller(aCx); + } + stack.swap(caller); + } +} + +} // 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<JS::Value>& aData) { + RefPtr<Console> 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<JS::Value>& aData) { + if (!ShouldProceed(aMethodName)) { + return; + } + + AssertIsOnOwningThread(); + + ConsoleCommon::ClearException ce(aCx); + + RefPtr<ConsoleCallData> callData = + new ConsoleCallData(aMethodName, aMethodString, this); + if (!StoreCallData(aCx, callData, aData)) { + return; + } + + OriginAttributes oa; + + if (NS_IsMainThread()) { + if (mGlobal) { + // Save the principal's OriginAttributes in the console event data + // so that we will be able to filter messages by origin attributes. + nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(mGlobal); + if (NS_WARN_IF(!sop)) { + return; + } + + nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal(); + if (NS_WARN_IF(!principal)) { + return; + } + + oa = principal->OriginAttributesRef(); + callData->SetAddonId(principal); + +#ifdef DEBUG + if (!principal->IsSystemPrincipal()) { + nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(mGlobal); + if (webNav) { + nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(webNav); + MOZ_ASSERT(loadContext); + + bool pb; + if (NS_SUCCEEDED(loadContext->GetUsePrivateBrowsing(&pb))) { + MOZ_ASSERT(pb == !!oa.mPrivateBrowsingId); + } + } + } +#endif + } + } else if (WorkletThread::IsOnWorkletThread()) { + nsCOMPtr<WorkletGlobalScope> global = do_QueryInterface(mGlobal); + MOZ_ASSERT(global); + oa = global->Impl()->OriginAttributesRef(); + } else { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + oa = workerPrivate->GetOriginAttributes(); + } + + callData->SetOriginAttributes(oa); + + JS::StackCapture captureMode = + ShouldIncludeStackTrace(aMethodName) + ? JS::StackCapture(JS::MaxFrames(DEFAULT_MAX_STACKTRACE_DEPTH)) + : JS::StackCapture(JS::FirstSubsumedFrame(aCx)); + nsCOMPtr<nsIStackFrame> stack = CreateStack(aCx, std::move(captureMode)); + + if (stack) { + callData->mTopStackFrame.emplace(); + StackFrameToStackEntry(aCx, stack, *callData->mTopStackFrame); + } + + 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(); + ReifyStack(aCx, stack, *callData->mReifiedStack); + } + + DOMHighResTimeStamp monotonicTimer; + + // Monotonic timer for 'time', 'timeLog' and 'timeEnd' + if ((aMethodName == MethodTime || aMethodName == MethodTimeLog || + aMethodName == MethodTimeEnd || aMethodName == MethodTimeStamp) && + !MonotonicTimer(aCx, aMethodName, aData, &monotonicTimer)) { + return; + } + + if (aMethodName == MethodTime && !aData.IsEmpty()) { + callData->mStartTimerStatus = + StartTimer(aCx, aData[0], monotonicTimer, callData->mStartTimerLabel, + &callData->mStartTimerValue); + } + + else if (aMethodName == MethodTimeEnd && !aData.IsEmpty()) { + callData->mLogTimerStatus = + LogTimer(aCx, aData[0], monotonicTimer, callData->mLogTimerLabel, + &callData->mLogTimerDuration, true /* Cancel timer */); + } + + else if (aMethodName == MethodTimeLog && !aData.IsEmpty()) { + callData->mLogTimerStatus = + LogTimer(aCx, aData[0], monotonicTimer, callData->mLogTimerLabel, + &callData->mLogTimerDuration, false /* Cancel timer */); + } + + else if (aMethodName == MethodCount) { + callData->mCountValue = IncreaseCounter(aCx, aData, callData->mCountLabel); + if (!callData->mCountValue) { + return; + } + } + + else if (aMethodName == MethodCountReset) { + callData->mCountValue = ResetCounter(aCx, aData, callData->mCountLabel); + if (callData->mCountLabel.IsEmpty()) { + return; + } + } + + // Before processing this CallData differently, it's time to call the dump + // function. + if (aMethodName == MethodTrace || aMethodName == MethodAssert) { + MaybeExecuteDumpFunction(aCx, aMethodString, aData, stack); + } else if ((aMethodName == MethodTime || aMethodName == MethodTimeEnd) && + !aData.IsEmpty()) { + MaybeExecuteDumpFunctionForTime(aCx, aMethodName, aMethodString, + monotonicTimer, aData[0]); + } else { + MaybeExecuteDumpFunction(aCx, aMethodString, aData, nullptr); + } + + if (NS_IsMainThread()) { + if (mInnerID) { + callData->SetIDs(mOuterID, mInnerID); + } else if (!mPassedInnerID.IsEmpty()) { + callData->SetIDs(u"jsm"_ns, mPassedInnerID); + } else { + nsAutoString filename; + if (callData->mTopStackFrame.isSome()) { + filename = callData->mTopStackFrame->mFilename; + } + + callData->SetIDs(u"jsm"_ns, filename); + } + + GetOrCreateMainThreadData()->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; + } + + if (WorkletThread::IsOnWorkletThread()) { + RefPtr<ConsoleCallDataWorkletRunnable> runnable = + ConsoleCallDataWorkletRunnable::Create(aCx, this, callData, aData); + if (!runnable) { + return; + } + + NS_DispatchToMainThread(runnable); + return; + } + + // We do this only in workers for now. + NotifyHandler(aCx, aData, callData); + + if (StaticPrefs::dom_worker_console_dispatch_events_to_main_thread()) { + RefPtr<ConsoleCallDataWorkerRunnable> runnable = + new ConsoleCallDataWorkerRunnable(this, callData); + Unused << NS_WARN_IF(!runnable->Dispatch(aCx, aData)); + } +} + +MainThreadConsoleData* Console::GetOrCreateMainThreadData() { + AssertIsOnOwningThread(); + + if (!mMainThreadData) { + mMainThreadData = new MainThreadConsoleData(); + } + + return mMainThreadData; +} + +// 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<JSObject*> 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<nsIStackFrame*>(v.toPrivate()); + nsTArray<ConsoleStackEntry> reifiedStack; + ReifyStack(aCx, stack, reifiedStack); + + JS::Rooted<JS::Value> 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 MainThreadConsoleData::ProcessCallData( + JSContext* aCx, ConsoleCallData* aData, + const Sequence<JS::Value>& aArguments) { + AssertIsOnMainThread(); + MOZ_ASSERT(aData); + + JS::Rooted<JS::Value> 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. + JS::Rooted<JSObject*> targetScope(aCx, xpc::PrivilegedJunkScope()); + if (NS_WARN_IF(!Console::PopulateConsoleNotificationInTheTargetScope( + aCx, aArguments, targetScope, &eventValue, aData, &mGroupStack))) { + return; + } + + if (!mStorage) { + mStorage = do_GetService("@mozilla.org/consoleAPI-storage;1"); + } + + if (!mStorage) { + NS_WARNING("Failed to get the ConsoleAPIStorage service."); + return; + } + + nsAutoString innerID; + + MOZ_ASSERT(aData->mIDType != ConsoleCallData::eUnknown); + if (aData->mIDType == ConsoleCallData::eString) { + innerID = aData->mInnerIDString; + } else { + MOZ_ASSERT(aData->mIDType == ConsoleCallData::eNumber); + innerID.AppendInt(aData->mInnerIDNumber); + } + + if (aData->mMethodName == Console::MethodClear) { + DebugOnly<nsresult> rv = mStorage->ClearEvents(innerID); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "ClearEvents failed"); + } + + if (NS_FAILED(mStorage->RecordEvent(innerID, eventValue))) { + NS_WARNING("Failed to record a console event."); + } +} + +/* static */ +bool Console::PopulateConsoleNotificationInTheTargetScope( + JSContext* aCx, const Sequence<JS::Value>& aArguments, + JS::Handle<JSObject*> aTargetScope, + JS::MutableHandle<JS::Value> aEventValue, ConsoleCallData* aData, + nsTArray<nsString>* aGroupStack) { + MOZ_ASSERT(aCx); + MOZ_ASSERT(aData); + MOZ_ASSERT(aTargetScope); + MOZ_ASSERT(JS_IsGlobalObject(aTargetScope)); + + ConsoleStackEntry frame; + if (aData->mTopStackFrame) { + frame = *aData->mTopStackFrame; + } + + ConsoleCommon::ClearException ce(aCx); + RootedDictionary<ConsoleEvent> event(aCx); + + event.mAddonId = aData->mAddonId; + + event.mID.Construct(); + event.mInnerID.Construct(); + + event.mChromeContext = nsContentUtils::ThreadsafeIsSystemCaller(aCx); + + 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.mConsoleID = aData->mConsoleID; + event.mLevel = aData->mMethodString; + event.mFilename = frame.mFilename; + event.mPrefix = aData->mPrefix; + + nsCOMPtr<nsIURI> filenameURI; + nsAutoCString pass; + if (NS_IsMainThread() && + NS_SUCCEEDED(NS_NewURI(getter_AddRefs(filenameURI), frame.mFilename)) && + NS_SUCCEEDED(filenameURI->GetPassword(pass)) && !pass.IsEmpty()) { + nsCOMPtr<nsISensitiveInfoHiddenURI> safeURI = + do_QueryInterface(filenameURI); + nsAutoCString spec; + if (safeURI && NS_SUCCEEDED(safeURI->GetSensitiveInfoHiddenSpec(spec))) { + CopyUTF8toUTF16(spec, event.mFilename); + } + } + + event.mSourceId = frame.mSourceId; + event.mLineNumber = frame.mLineNumber; + event.mColumnNumber = frame.mColumnNumber; + event.mFunctionName = frame.mFunctionName; + event.mTimeStamp = aData->mMicroSecondTimeStamp / PR_USEC_PER_MSEC; + event.mMicroSecondTimeStamp = aData->mMicroSecondTimeStamp; + event.mPrivate = !!aData->mOriginAttributes.mPrivateBrowsingId; + + switch (aData->mMethodName) { + case MethodLog: + case MethodInfo: + case MethodWarn: + case MethodError: + case MethodException: + case MethodDebug: + case MethodAssert: + case MethodGroup: + case MethodGroupCollapsed: + case MethodTrace: + 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( + !event.mArguments.Value().AppendElements(aArguments, fallible))) { + return false; + } + } + + if (aData->mMethodName == MethodGroup || + aData->mMethodName == MethodGroupCollapsed) { + ComposeAndStoreGroupName(aCx, event.mArguments.Value(), event.mGroupName, + aGroupStack); + } + + else if (aData->mMethodName == MethodGroupEnd) { + if (!UnstoreGroupName(event.mGroupName, aGroupStack)) { + return false; + } + } + + else if (aData->mMethodName == MethodTime && !aArguments.IsEmpty()) { + event.mTimer = CreateStartTimerValue(aCx, aData->mStartTimerLabel, + aData->mStartTimerStatus); + } + + else if ((aData->mMethodName == MethodTimeEnd || + aData->mMethodName == MethodTimeLog) && + !aArguments.IsEmpty()) { + event.mTimer = CreateLogOrEndTimerValue(aCx, aData->mLogTimerLabel, + aData->mLogTimerDuration, + aData->mLogTimerStatus); + } + + else if (aData->mMethodName == MethodCount || + aData->mMethodName == MethodCountReset) { + event.mCounter = CreateCounterOrResetCounterValue(aCx, aData->mCountLabel, + aData->mCountValue); + } + + JSAutoRealm ar2(aCx, aTargetScope); + + if (NS_WARN_IF(!ToJSValue(aCx, event, aEventValue))) { + return false; + } + + JS::Rooted<JSObject*> 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<JS::Value> 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<JSObject*> 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<JS::Value> 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", funObj, + nullptr, JSPROP_ENUMERATE))) { + return false; + } + } + } + + return true; +} + +namespace { + +// Helper method for ProcessArguments. Flushes output, if non-empty, to +// aSequence. +bool FlushOutput(JSContext* aCx, Sequence<JS::Value>& aSequence, + nsString& aOutput) { + if (!aOutput.IsEmpty()) { + JS::Rooted<JSString*> 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 + +static void MakeFormatString(nsCString& aFormat, int32_t aInteger, + int32_t aMantissa, char aCh) { + aFormat.Append('%'); + if (aInteger >= 0) { + aFormat.AppendInt(aInteger); + } + + if (aMantissa >= 0) { + aFormat.Append('.'); + aFormat.AppendInt(aMantissa); + } + + aFormat.Append(aCh); +} + +// If the first JS::Value of the array is a string, this method uses it to +// format a string. The supported sequences are: +// %s - string +// %d,%i - integer +// %f - double +// %o,%O - a JS object. +// %c - style string. +// The output is an array where any object is a separated item, the rest is +// unified in a format string. +// Example if the input is: +// "string: %s, integer: %d, object: %o, double: %f", 's', 1, window, 0.9 +// The output will be: +// [ "string: s, integer: 1, object: ", window, ", double: 0.9" ] +// +// The aStyles array is populated with the style strings that the function +// finds based the format string. The index of the styles matches the indexes +// of elements that need the custom styling from aSequence. For elements with +// no custom styling the array is padded with null elements. +static bool ProcessArguments(JSContext* aCx, const Sequence<JS::Value>& aData, + Sequence<JS::Value>& aSequence, + Sequence<nsString>& aStyles) { + // This method processes the arguments as format strings (%d, %i, %s...) + // only if the first element of them is a valid and not-empty string. + + if (aData.IsEmpty()) { + return true; + } + + if (aData.Length() == 1 || !aData[0].isString()) { + return aSequence.AppendElements(aData, fallible); + } + + JS::Rooted<JS::Value> format(aCx, aData[0]); + JS::Rooted<JSString*> 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; + } + + if (string.IsEmpty()) { + return aSequence.AppendElements(aData, fallible); + } + + 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 %<number>.<number> 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<JS::Value> 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.RemoveLastElement(); + } + + if (NS_WARN_IF(!FlushOutput(aCx, aSequence, output))) { + return false; + } + + if (index < aData.Length()) { + JS::Rooted<JS::Value> v(aCx, aData[index++]); + JS::Rooted<JSString*> 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(VoidString(), 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<JS::Value> value(aCx, aData[index++]); + JS::Rooted<JSString*> 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<JS::Value> value(aCx, aData[index++]); + + if (value.isBigInt()) { + JS::Rooted<JSString*> 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; + } + + 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<JS::Value> 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; +} + +// Stringify and Concat all the JS::Value in a single string using ' ' as +// separator. The new group name will be stored in aGroupStack array. +static void ComposeAndStoreGroupName(JSContext* aCx, + const Sequence<JS::Value>& aData, + nsAString& aName, + nsTArray<nsString>* aGroupStack) { + StringJoinAppend( + aName, u" "_ns, aData, [aCx](nsAString& dest, const JS::Value& valueRef) { + JS::Rooted<JS::Value> value(aCx, valueRef); + JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, value)); + if (!jsString) { + return; + } + + nsAutoJSString string; + if (!string.init(aCx, jsString)) { + return; + } + + dest.Append(string); + }); + + aGroupStack->AppendElement(aName); +} + +// Remove the last group name and return that name. It returns false if +// aGroupStack is empty. +static bool UnstoreGroupName(nsAString& aName, + nsTArray<nsString>* aGroupStack) { + if (aGroupStack->IsEmpty()) { + return false; + } + + aName = aGroupStack->PopLastElement(); + return true; +} + +Console::TimerStatus 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 eTimerMaxReached; + } + + JS::Rooted<JS::Value> name(aCx, aName); + JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, name)); + if (NS_WARN_IF(!jsString)) { + return eTimerJSException; + } + + nsAutoJSString label; + if (NS_WARN_IF(!label.init(aCx, jsString))) { + return eTimerJSException; + } + + aTimerLabel = label; + + if (mTimerRegistry.WithEntryHandle(label, [&](auto&& entry) { + if (entry) { + return true; + } + entry.Insert(aTimestamp); + return false; + })) { + return eTimerAlreadyExists; + } + + *aTimerValue = aTimestamp; + return eTimerDone; +} + +/* static */ +JS::Value Console::CreateStartTimerValue(JSContext* aCx, + const nsAString& aTimerLabel, + TimerStatus aTimerStatus) { + MOZ_ASSERT(aTimerStatus != eTimerUnknown); + + if (aTimerStatus != eTimerDone) { + return CreateTimerError(aCx, aTimerLabel, aTimerStatus); + } + + RootedDictionary<ConsoleTimerStart> timer(aCx); + + timer.mName = aTimerLabel; + + JS::Rooted<JS::Value> value(aCx); + if (!ToJSValue(aCx, timer, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +Console::TimerStatus Console::LogTimer(JSContext* aCx, const JS::Value& aName, + DOMHighResTimeStamp aTimestamp, + nsAString& aTimerLabel, + double* aTimerDuration, + bool aCancelTimer) { + AssertIsOnOwningThread(); + MOZ_ASSERT(aTimerDuration); + + *aTimerDuration = 0; + + JS::Rooted<JS::Value> name(aCx, aName); + JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, name)); + if (NS_WARN_IF(!jsString)) { + return eTimerJSException; + } + + nsAutoJSString key; + if (NS_WARN_IF(!key.init(aCx, jsString))) { + return eTimerJSException; + } + + aTimerLabel = key; + + DOMHighResTimeStamp value = 0; + + if (aCancelTimer) { + if (!mTimerRegistry.Remove(key, &value)) { + NS_WARNING("mTimerRegistry entry not found"); + return eTimerDoesntExist; + } + } else { + if (!mTimerRegistry.Get(key, &value)) { + NS_WARNING("mTimerRegistry entry not found"); + return eTimerDoesntExist; + } + } + + *aTimerDuration = aTimestamp - value; + return eTimerDone; +} + +/* static */ +JS::Value Console::CreateLogOrEndTimerValue(JSContext* aCx, + const nsAString& aLabel, + double aDuration, + TimerStatus aStatus) { + if (aStatus != eTimerDone) { + return CreateTimerError(aCx, aLabel, aStatus); + } + + RootedDictionary<ConsoleTimerLogOrEnd> timer(aCx); + timer.mName = aLabel; + timer.mDuration = aDuration; + + JS::Rooted<JS::Value> value(aCx); + if (!ToJSValue(aCx, timer, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +/* static */ +JS::Value Console::CreateTimerError(JSContext* aCx, const nsAString& aLabel, + TimerStatus aStatus) { + MOZ_ASSERT(aStatus != eTimerUnknown && aStatus != eTimerDone); + + RootedDictionary<ConsoleTimerError> error(aCx); + + error.mName = aLabel; + + switch (aStatus) { + case eTimerAlreadyExists: + error.mError.AssignLiteral("timerAlreadyExists"); + break; + + case eTimerDoesntExist: + error.mError.AssignLiteral("timerDoesntExist"); + break; + + case eTimerJSException: + error.mError.AssignLiteral("timerJSError"); + break; + + case eTimerMaxReached: + error.mError.AssignLiteral("maxTimersExceeded"); + break; + + default: + MOZ_CRASH("Unsupported status"); + break; + } + + JS::Rooted<JS::Value> value(aCx); + if (!ToJSValue(aCx, error, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +uint32_t Console::IncreaseCounter(JSContext* aCx, + const Sequence<JS::Value>& aArguments, + nsAString& aCountLabel) { + AssertIsOnOwningThread(); + + ConsoleCommon::ClearException ce(aCx); + + MOZ_ASSERT(!aArguments.IsEmpty()); + + JS::Rooted<JS::Value> labelValue(aCx, aArguments[0]); + JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, labelValue)); + if (!jsString) { + return 0; // We cannot continue. + } + + nsAutoJSString string; + if (!string.init(aCx, jsString)) { + return 0; // We cannot continue. + } + + aCountLabel = string; + + const bool maxCountersReached = mCounterRegistry.Count() >= MAX_PAGE_COUNTERS; + return mCounterRegistry.WithEntryHandle( + aCountLabel, [maxCountersReached](auto&& entry) -> uint32_t { + if (entry) { + ++entry.Data(); + } else { + if (maxCountersReached) { + return MAX_PAGE_COUNTERS; + } + entry.Insert(1); + } + return entry.Data(); + }); +} + +uint32_t Console::ResetCounter(JSContext* aCx, + const Sequence<JS::Value>& aArguments, + nsAString& aCountLabel) { + AssertIsOnOwningThread(); + + ConsoleCommon::ClearException ce(aCx); + + MOZ_ASSERT(!aArguments.IsEmpty()); + + JS::Rooted<JS::Value> labelValue(aCx, aArguments[0]); + JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, labelValue)); + if (!jsString) { + return 0; // We cannot continue. + } + + nsAutoJSString string; + if (!string.init(aCx, jsString)) { + return 0; // We cannot continue. + } + + aCountLabel = string; + + if (mCounterRegistry.Remove(aCountLabel)) { + return 0; + } + + // Let's return something different than 0 if the key doesn't exist. + return MAX_PAGE_COUNTERS; +} + +// This method generates a ConsoleCounter dictionary as JS::Value. If +// aCountValue is == MAX_PAGE_COUNTERS it generates a ConsoleCounterError +// instead. See IncreaseCounter. +// * aCx - this is the context that will root the returned value. +// * aCountLabel - this label must be what IncreaseCounter received as +// aTimerLabel. +// * aCountValue - the return value of IncreaseCounter. +static JS::Value CreateCounterOrResetCounterValue(JSContext* aCx, + const nsAString& aCountLabel, + uint32_t aCountValue) { + ConsoleCommon::ClearException ce(aCx); + + if (aCountValue == MAX_PAGE_COUNTERS) { + RootedDictionary<ConsoleCounterError> error(aCx); + error.mLabel = aCountLabel; + error.mError.AssignLiteral("counterDoesntExist"); + + JS::Rooted<JS::Value> value(aCx); + if (!ToJSValue(aCx, error, &value)) { + return JS::UndefinedValue(); + } + + return value; + } + + RootedDictionary<ConsoleCounter> data(aCx); + data.mLabel = aCountLabel; + data.mCount = aCountValue; + + JS::Rooted<JS::Value> value(aCx); + if (!ToJSValue(aCx, data, &value)) { + return JS::UndefinedValue(); + } + + return value; +} + +/* static */ +bool Console::ShouldIncludeStackTrace(MethodName aMethodName) { + switch (aMethodName) { + case MethodError: + case MethodException: + case MethodAssert: + case MethodTrace: + return true; + default: + return false; + } +} + +JSObject* MainThreadConsoleData::GetOrCreateSandbox(JSContext* aCx, + nsIPrincipal* aPrincipal) { + AssertIsOnMainThread(); + + if (!mSandbox) { + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + MOZ_ASSERT(xpc, "This should never be null!"); + + JS::Rooted<JSObject*> 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(); +} + +bool Console::StoreCallData(JSContext* aCx, ConsoleCallData* aCallData, + const Sequence<JS::Value>& aArguments) { + AssertIsOnOwningThread(); + + if (NS_WARN_IF(!mArgumentStorage.growBy(1))) { + return false; + } + if (!mArgumentStorage.end()[-1].Initialize(aCx, aArguments)) { + mArgumentStorage.shrinkBy(1); + return false; + } + + MOZ_ASSERT(aCallData); + MOZ_ASSERT(!mCallDataStorage.Contains(aCallData)); + + mCallDataStorage.AppendElement(aCallData); + + MOZ_ASSERT(mCallDataStorage.Length() == mArgumentStorage.length()); + + if (mCallDataStorage.Length() > STORAGE_MAX_EVENTS) { + mCallDataStorage.RemoveElementAt(0); + mArgumentStorage.erase(&mArgumentStorage[0]); + } + return true; +} + +void Console::UnstoreCallData(ConsoleCallData* aCallData) { + AssertIsOnOwningThread(); + + MOZ_ASSERT(aCallData); + MOZ_ASSERT(mCallDataStorage.Length() == mArgumentStorage.length()); + + size_t index = mCallDataStorage.IndexOf(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(). + if (index == mCallDataStorage.NoIndex) { + return; + } + + mCallDataStorage.RemoveElementAt(index); + mArgumentStorage.erase(&mArgumentStorage[index]); +} + +void Console::NotifyHandler(JSContext* aCx, + const Sequence<JS::Value>& aArguments, + ConsoleCallData* aCallData) { + AssertIsOnOwningThread(); + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(aCallData); + + if (!mConsoleEventNotifier) { + return; + } + + JS::Rooted<JS::Value> value(aCx); + + JS::Rooted<JSObject*> callableGlobal( + aCx, mConsoleEventNotifier->CallbackGlobalOrNull()); + if (NS_WARN_IF(!callableGlobal)) { + return; + } + + // aCx and aArguments are in the same compartment because this method is + // called directly when a Console.something() runs. + // mConsoleEventNotifier->CallbackGlobal() is the scope where value will be + // sent to. + if (NS_WARN_IF(!PopulateConsoleNotificationInTheTargetScope( + aCx, aArguments, callableGlobal, &value, aCallData, &mGroupStack))) { + return; + } + + JS::Rooted<JS::Value> ignored(aCx); + RefPtr<AnyCallback> notifier(mConsoleEventNotifier); + notifier->Call(value, &ignored); +} + +void Console::RetrieveConsoleEvents(JSContext* aCx, + nsTArray<JS::Value>& aEvents, + ErrorResult& aRv) { + AssertIsOnOwningThread(); + + // We don't want to expose this functionality to main-thread yet. + MOZ_ASSERT(!NS_IsMainThread()); + + JS::Rooted<JSObject*> targetScope(aCx, JS::CurrentGlobalOrNull(aCx)); + + for (uint32_t i = 0; i < mArgumentStorage.length(); ++i) { + JS::Rooted<JS::Value> value(aCx); + + JS::Rooted<JSObject*> sequenceScope(aCx, mArgumentStorage[i].Global()); + JSAutoRealm ar(aCx, sequenceScope); + + Sequence<JS::Value> sequence; + SequenceRooter<JS::Value> arguments(aCx, &sequence); + + if (!mArgumentStorage[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], + &mGroupStack))) { + 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 { + NS_ASSERT_OWNINGTHREAD(Console); +} + +bool Console::IsShuttingDown() const { + MOZ_ASSERT(mStatus != eUnknown); + return mStatus == eShuttingDown; +} + +/* static */ +already_AddRefed<Console> Console::GetConsole(const GlobalObject& aGlobal) { + ErrorResult rv; + RefPtr<Console> 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 */ +already_AddRefed<Console> Console::GetConsoleInternal( + const GlobalObject& aGlobal, ErrorResult& aRv) { + // Window + if (NS_IsMainThread()) { + nsCOMPtr<nsPIDOMWindowInner> innerWindow = + do_QueryInterface(aGlobal.GetAsSupports()); + + // we are probably running a chrome script. + if (!innerWindow) { + RefPtr<Console> console = new Console(aGlobal.Context(), nullptr, 0, 0); + console->Initialize(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + return console.forget(); + } + + nsGlobalWindowInner* window = nsGlobalWindowInner::Cast(innerWindow); + return window->GetConsole(aGlobal.Context(), aRv); + } + + // Worklet + nsCOMPtr<WorkletGlobalScope> workletScope = + do_QueryInterface(aGlobal.GetAsSupports()); + if (workletScope) { + WorkletThread::AssertIsOnWorkletThread(); + return workletScope->GetConsole(aGlobal.Context(), aRv); + } + + // Workers + MOZ_ASSERT(!NS_IsMainThread()); + + JSContext* cx = aGlobal.Context(); + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx); + MOZ_ASSERT(workerPrivate); + + nsCOMPtr<nsIGlobalObject> 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 + + WorkerDebuggerGlobalScope* debuggerScope = + workerPrivate->DebuggerGlobalScope(); + MOZ_ASSERT(debuggerScope); + MOZ_ASSERT(debuggerScope == global, "Which kind of global do we have?"); + + return debuggerScope->GetConsole(aRv); +} + +bool Console::MonotonicTimer(JSContext* aCx, MethodName aMethodName, + const Sequence<JS::Value>& aData, + DOMHighResTimeStamp* aTimeStamp) { + if (nsCOMPtr<nsPIDOMWindowInner> innerWindow = do_QueryInterface(mGlobal)) { + nsGlobalWindowInner* win = nsGlobalWindowInner::Cast(innerWindow); + MOZ_ASSERT(win); + + RefPtr<Performance> performance = win->GetPerformance(); + if (!performance) { + return false; + } + + *aTimeStamp = performance->Now(); + return true; + } + + if (NS_IsMainThread()) { + *aTimeStamp = (TimeStamp::Now() - mCreationTimeStamp).ToMilliseconds(); + return true; + } + + if (nsCOMPtr<WorkletGlobalScope> workletGlobal = do_QueryInterface(mGlobal)) { + *aTimeStamp = workletGlobal->TimeStampToDOMHighRes(TimeStamp::Now()); + return true; + } + + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + *aTimeStamp = workerPrivate->TimeStampToDOMHighRes(TimeStamp::Now()); + return true; +} + +/* static */ +already_AddRefed<ConsoleInstance> Console::CreateInstance( + const GlobalObject& aGlobal, const ConsoleInstanceOptions& aOptions) { + RefPtr<ConsoleInstance> console = + new ConsoleInstance(aGlobal.Context(), aOptions); + return console.forget(); +} + +void Console::StringifyElement(Element* aElement, nsAString& aOut) { + aOut.AppendLiteral("<"); + aOut.Append(aElement->LocalName()); + uint32_t attrCount = aElement->GetAttrCount(); + nsAutoString idAttr; + nsAutoString classAttr; + nsAutoString nameAttr; + nsAutoString otherAttrs; + for (uint32_t i = 0; i < attrCount; i++) { + BorrowedAttrInfo attrInfo = aElement->GetAttrInfoAt(i); + nsAutoString attrValue; + attrInfo.mValue->ToString(attrValue); + + const nsAttrName* attrName = attrInfo.mName; + if (attrName->Equals(nsGkAtoms::id)) { + idAttr.AppendLiteral(" id=\""); + idAttr.Append(attrValue); + idAttr.AppendLiteral("\""); + } else if (attrName->Equals(nsGkAtoms::_class)) { + classAttr.AppendLiteral(" class=\""); + classAttr.Append(attrValue); + classAttr.AppendLiteral("\""); + } else if (attrName->Equals(nsGkAtoms::name)) { + nameAttr.AppendLiteral(" name=\""); + nameAttr.Append(attrValue); + nameAttr.AppendLiteral("\""); + } else { + nsAutoString attrNameStr; + attrName->GetQualifiedName(attrNameStr); + otherAttrs.AppendLiteral(" "); + otherAttrs.Append(attrNameStr); + otherAttrs.AppendLiteral("=\""); + otherAttrs.Append(attrValue); + otherAttrs.AppendLiteral("\""); + } + } + if (!idAttr.IsEmpty()) { + aOut.Append(idAttr); + } + if (!classAttr.IsEmpty()) { + aOut.Append(classAttr); + } + if (!nameAttr.IsEmpty()) { + aOut.Append(nameAttr); + } + if (!otherAttrs.IsEmpty()) { + aOut.Append(otherAttrs); + } + aOut.AppendLiteral(">"); +} + +void Console::MaybeExecuteDumpFunction(JSContext* aCx, + const nsAString& aMethodName, + const Sequence<JS::Value>& aData, + nsIStackFrame* aStack) { + if (!mDumpFunction && !mDumpToStdout) { + return; + } + + nsAutoString message; + message.AssignLiteral("console."); + message.Append(aMethodName); + message.AppendLiteral(": "); + + if (!mPrefix.IsEmpty()) { + message.Append(mPrefix); + message.AppendLiteral(": "); + } + + for (uint32_t i = 0; i < aData.Length(); ++i) { + JS::Rooted<JS::Value> v(aCx, aData[i]); + if (v.isObject()) { + Element* element = nullptr; + if (NS_SUCCEEDED(UNWRAP_OBJECT(Element, &v, element))) { + if (i != 0) { + message.AppendLiteral(" "); + } + StringifyElement(element, message); + continue; + } + } + + JS::Rooted<JSString*> jsString(aCx, JS_ValueToSource(aCx, v)); + if (!jsString) { + continue; + } + + nsAutoJSString string; + if (NS_WARN_IF(!string.init(aCx, jsString))) { + return; + } + + if (i != 0) { + message.AppendLiteral(" "); + } + + message.Append(string); + } + + message.AppendLiteral("\n"); + + // aStack can be null. + + nsCOMPtr<nsIStackFrame> stack(aStack); + + while (stack) { + nsAutoString filename; + stack->GetFilename(aCx, filename); + + message.Append(filename); + message.AppendLiteral(" "); + + message.AppendInt(stack->GetLineNumber(aCx)); + message.AppendLiteral(" "); + + nsAutoString functionName; + stack->GetName(aCx, functionName); + + message.Append(functionName); + message.AppendLiteral("\n"); + + nsCOMPtr<nsIStackFrame> caller = stack->GetCaller(aCx); + + if (!caller) { + caller = stack->GetAsyncCaller(aCx); + } + + stack.swap(caller); + } + + ExecuteDumpFunction(message); +} + +void Console::MaybeExecuteDumpFunctionForTime(JSContext* aCx, + MethodName aMethodName, + const nsAString& aMethodString, + uint64_t aMonotonicTimer, + const JS::Value& aData) { + if (!mDumpFunction && !mDumpToStdout) { + return; + } + + nsAutoString message; + message.AssignLiteral("console."); + message.Append(aMethodString); + message.AppendLiteral(": "); + + if (!mPrefix.IsEmpty()) { + message.Append(mPrefix); + message.AppendLiteral(": "); + } + + JS::Rooted<JS::Value> v(aCx, aData); + JS::Rooted<JSString*> jsString(aCx, JS_ValueToSource(aCx, v)); + if (!jsString) { + return; + } + + nsAutoJSString string; + if (NS_WARN_IF(!string.init(aCx, jsString))) { + return; + } + + message.Append(string); + message.AppendLiteral(" @ "); + message.AppendInt(aMonotonicTimer); + + message.AppendLiteral("\n"); + ExecuteDumpFunction(message); +} + +void Console::ExecuteDumpFunction(const nsAString& aMessage) { + if (mDumpFunction) { + RefPtr<ConsoleInstanceDumpCallback> dumpFunction(mDumpFunction); + dumpFunction->Call(aMessage); + return; + } + + NS_ConvertUTF16toUTF8 str(aMessage); + MOZ_LOG(nsContentUtils::DOMDumpLog(), LogLevel::Debug, ("%s", str.get())); +#ifdef ANDROID + __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get()); +#endif + fputs(str.get(), stdout); + fflush(stdout); +} + +bool Console::ShouldProceed(MethodName aName) const { + return mCurrentLogLevel <= InternalLogLevelToInteger(aName); +} + +uint32_t Console::WebIDLLogLevelToInteger(ConsoleLogLevel aLevel) const { + switch (aLevel) { + case ConsoleLogLevel::All: + return 0; + case ConsoleLogLevel::Debug: + return 2; + case ConsoleLogLevel::Log: + return 3; + case ConsoleLogLevel::Info: + return 3; + case ConsoleLogLevel::Clear: + return 3; + case ConsoleLogLevel::Trace: + return 3; + case ConsoleLogLevel::TimeLog: + return 3; + case ConsoleLogLevel::TimeEnd: + return 3; + case ConsoleLogLevel::Time: + return 3; + case ConsoleLogLevel::Group: + return 3; + case ConsoleLogLevel::GroupEnd: + return 3; + case ConsoleLogLevel::Profile: + return 3; + case ConsoleLogLevel::ProfileEnd: + return 3; + case ConsoleLogLevel::Dir: + return 3; + case ConsoleLogLevel::Dirxml: + return 3; + case ConsoleLogLevel::Warn: + return 4; + case ConsoleLogLevel::Error: + return 5; + case ConsoleLogLevel::Off: + return UINT32_MAX; + default: + MOZ_CRASH( + "ConsoleLogLevel is out of sync with the Console implementation!"); + return 0; + } +} + +uint32_t Console::InternalLogLevelToInteger(MethodName aName) const { + switch (aName) { + case MethodLog: + return 3; + case MethodInfo: + return 3; + case MethodWarn: + return 4; + case MethodError: + return 5; + case MethodException: + return 5; + case MethodDebug: + return 2; + case MethodTable: + return 3; + case MethodTrace: + return 3; + case MethodDir: + return 3; + case MethodDirxml: + return 3; + case MethodGroup: + return 3; + case MethodGroupCollapsed: + return 3; + case MethodGroupEnd: + return 3; + case MethodTime: + return 3; + case MethodTimeLog: + return 3; + case MethodTimeEnd: + return 3; + case MethodTimeStamp: + return 3; + case MethodAssert: + return 3; + case MethodCount: + return 3; + case MethodCountReset: + return 3; + case MethodClear: + return 3; + case MethodProfile: + return 3; + case MethodProfileEnd: + return 3; + default: + MOZ_CRASH("MethodName is out of sync with the Console implementation!"); + return 0; + } +} + +bool Console::ArgumentData::Initialize(JSContext* aCx, + const Sequence<JS::Value>& aArguments) { + mGlobal = JS::CurrentGlobalOrNull(aCx); + + if (NS_WARN_IF(!mArguments.AppendElements(aArguments, fallible))) { + return false; + } + + return true; +} + +void Console::ArgumentData::Trace(const TraceCallbacks& aCallbacks, + void* aClosure) { + ArgumentData* tmp = this; + for (uint32_t i = 0; i < mArguments.Length(); ++i) { + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mArguments[i]) + } + + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mGlobal) +} + +bool Console::ArgumentData::PopulateArgumentsSequence( + Sequence<JS::Value>& aSequence) const { + AssertIsOnOwningThread(); + + for (uint32_t i = 0; i < mArguments.Length(); ++i) { + if (NS_WARN_IF(!aSequence.AppendElement(mArguments[i], fallible))) { + return false; + } + } + + return true; +} + +} // namespace mozilla::dom diff --git a/dom/console/Console.h b/dom/console/Console.h new file mode 100644 index 0000000000..410cc8ba46 --- /dev/null +++ b/dom/console/Console.h @@ -0,0 +1,449 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_Console_h +#define mozilla_dom_Console_h + +#include "domstubs.h" +#include "mozilla/dom/ConsoleBinding.h" +#include "mozilla/TimeStamp.h" +#include "nsCycleCollectionParticipant.h" +#include "nsTHashMap.h" +#include "nsHashKeys.h" +#include "nsIObserver.h" +#include "nsWeakReference.h" + +class nsIConsoleAPIStorage; +class nsIGlobalObject; +class nsPIDOMWindowInner; +class nsIStackFrame; + +namespace mozilla::dom { + +class AnyCallback; +class ConsoleCallData; +class ConsoleInstance; +class ConsoleRunnable; +class ConsoleCallDataRunnable; +class ConsoleProfileRunnable; +class MainThreadConsoleData; + +class Console final : public nsIObserver, public nsSupportsWeakReference { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(Console, nsIObserver) + NS_DECL_NSIOBSERVER + + static already_AddRefed<Console> Create(JSContext* aCx, + nsPIDOMWindowInner* aWindow, + ErrorResult& aRv); + + static already_AddRefed<Console> CreateForWorklet(JSContext* aCx, + nsIGlobalObject* aGlobal, + uint64_t aOuterWindowID, + uint64_t aInnerWindowID, + ErrorResult& aRv); + + MOZ_CAN_RUN_SCRIPT + static void Log(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Info(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Warn(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Error(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Exception(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Debug(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Table(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Trace(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Dir(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Dirxml(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Group(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void GroupCollapsed(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void GroupEnd(const GlobalObject& aGlobal); + + MOZ_CAN_RUN_SCRIPT + static void Time(const GlobalObject& aGlobal, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + static void TimeLog(const GlobalObject& aGlobal, const nsAString& aLabel, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void TimeEnd(const GlobalObject& aGlobal, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + static void TimeStamp(const GlobalObject& aGlobal, + const JS::Handle<JS::Value> aData); + + MOZ_CAN_RUN_SCRIPT + static void Profile(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void ProfileEnd(const GlobalObject& aGlobal, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Assert(const GlobalObject& aGlobal, bool aCondition, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Count(const GlobalObject& aGlobal, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + static void CountReset(const GlobalObject& aGlobal, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + static void Clear(const GlobalObject& aGlobal); + + static already_AddRefed<ConsoleInstance> CreateInstance( + const GlobalObject& aGlobal, const ConsoleInstanceOptions& aOptions); + + void ClearStorage(); + + void RetrieveConsoleEvents(JSContext* aCx, nsTArray<JS::Value>& aEvents, + ErrorResult& aRv); + + void SetConsoleEventHandler(AnyCallback* aHandler); + + private: + Console(JSContext* aCx, nsIGlobalObject* aGlobal, uint64_t aOuterWindowID, + uint64_t aInnerWIndowID); + ~Console(); + + void Initialize(ErrorResult& aRv); + + void Shutdown(); + + enum MethodName { + MethodLog, + MethodInfo, + MethodWarn, + MethodError, + MethodException, + MethodDebug, + MethodTable, + MethodTrace, + MethodDir, + MethodDirxml, + MethodGroup, + MethodGroupCollapsed, + MethodGroupEnd, + MethodTime, + MethodTimeLog, + MethodTimeEnd, + MethodTimeStamp, + MethodAssert, + MethodCount, + MethodCountReset, + MethodClear, + MethodProfile, + MethodProfileEnd, + }; + + static already_AddRefed<Console> GetConsole(const GlobalObject& aGlobal); + + static already_AddRefed<Console> GetConsoleInternal( + const GlobalObject& aGlobal, ErrorResult& aRv); + + MOZ_CAN_RUN_SCRIPT + static void ProfileMethod(const GlobalObject& aGlobal, MethodName aName, + const nsAString& aAction, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void ProfileMethodInternal(JSContext* aCx, MethodName aName, + const nsAString& aAction, + const Sequence<JS::Value>& aData); + + // Implementation of the mainthread-only parts of ProfileMethod. + // This is indepedent of console instance state. + static void ProfileMethodMainthread(JSContext* aCx, const nsAString& aAction, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void Method(const GlobalObject& aGlobal, MethodName aName, + const nsAString& aString, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void MethodInternal(JSContext* aCx, MethodName aName, + const nsAString& aString, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + static void StringMethod(const GlobalObject& aGlobal, const nsAString& aLabel, + const Sequence<JS::Value>& aData, + MethodName aMethodName, + const nsAString& aMethodString); + + MOZ_CAN_RUN_SCRIPT + void StringMethodInternal(JSContext* aCx, const nsAString& aLabel, + const Sequence<JS::Value>& aData, + MethodName aMethodName, + const nsAString& aMethodString); + + MainThreadConsoleData* GetOrCreateMainThreadData(); + + // Returns true on success; otherwise false. + bool StoreCallData(JSContext* aCx, ConsoleCallData* aCallData, + const Sequence<JS::Value>& aArguments); + + void UnstoreCallData(ConsoleCallData* aData); + + // aCx and aArguments must be in the same JS compartment. + MOZ_CAN_RUN_SCRIPT + void NotifyHandler(JSContext* aCx, const Sequence<JS::Value>& aArguments, + ConsoleCallData* aData); + + // PopulateConsoleNotificationInTheTargetScope receives aCx and aArguments in + // the same JS compartment and populates the ConsoleEvent object + // (aEventValue) in the aTargetScope. + // aTargetScope can be: + // - the system-principal scope when we want to dispatch the ConsoleEvent to + // nsIConsoleAPIStorage (See the comment in Console.cpp about the use of + // xpc::PrivilegedJunkScope() + // - the mConsoleEventNotifier->CallableGlobal() when we want to notify this + // handler about a new ConsoleEvent. + // - It can be the global from the JSContext when RetrieveConsoleEvents is + // called. + static bool PopulateConsoleNotificationInTheTargetScope( + JSContext* aCx, const Sequence<JS::Value>& aArguments, + JS::Handle<JSObject*> aTargetScope, + JS::MutableHandle<JS::Value> aEventValue, ConsoleCallData* aData, + nsTArray<nsString>* aGroupStack); + + enum TimerStatus { + eTimerUnknown, + eTimerDone, + eTimerAlreadyExists, + eTimerDoesntExist, + eTimerJSException, + eTimerMaxReached, + }; + + static JS::Value CreateTimerError(JSContext* aCx, const nsAString& aLabel, + TimerStatus aStatus); + + // StartTimer is called on the owning thread and populates aTimerLabel and + // aTimerValue. + // * aCx - the JSContext rooting aName. + // * aName - this is (should be) the name of the timer as JS::Value. + // * aTimestamp - the monotonicTimer for this context taken from + // performance.now(). + // * aTimerLabel - This label will be populated with the aName converted to a + // string. + // * aTimerValue - the StartTimer value stored into (or taken from) + // mTimerRegistry. + TimerStatus StartTimer(JSContext* aCx, const JS::Value& aName, + DOMHighResTimeStamp aTimestamp, nsAString& aTimerLabel, + DOMHighResTimeStamp* aTimerValue); + + // CreateStartTimerValue generates a ConsoleTimerStart dictionary exposed as + // JS::Value. If aTimerStatus is false, it generates a ConsoleTimerError + // instead. It's called only after the execution StartTimer on the owning + // thread. + // * aCx - this is the context that will root the returned value. + // * aTimerLabel - this label must be what StartTimer received as aTimerLabel. + // * aTimerStatus - the return value of StartTimer. + static JS::Value CreateStartTimerValue(JSContext* aCx, + const nsAString& aTimerLabel, + TimerStatus aTimerStatus); + + // LogTimer follows the same pattern as StartTimer: it runs on the + // owning thread and populates aTimerLabel and aTimerDuration, used by + // CreateLogOrEndTimerValue. + // * aCx - the JSContext rooting aName. + // * aName - this is (should be) the name of the timer as JS::Value. + // * aTimestamp - the monotonicTimer for this context taken from + // performance.now(). + // * aTimerLabel - This label will be populated with the aName converted to a + // string. + // * aTimerDuration - the difference between aTimestamp and when the timer + // started (see StartTimer). + // * aCancelTimer - if true, the timer is removed from the table. + TimerStatus LogTimer(JSContext* aCx, const JS::Value& aName, + DOMHighResTimeStamp aTimestamp, nsAString& aTimerLabel, + double* aTimerDuration, bool aCancelTimer); + + // This method generates a ConsoleTimerEnd dictionary exposed as JS::Value, or + // a ConsoleTimerError dictionary if aTimerStatus is false. See LogTimer. + // * aCx - this is the context that will root the returned value. + // * aTimerLabel - this label must be what LogTimer received as aTimerLabel. + // * aTimerDuration - this is what LogTimer received as aTimerDuration + // * aTimerStatus - the return value of LogTimer. + static JS::Value CreateLogOrEndTimerValue(JSContext* aCx, + const nsAString& aLabel, + double aDuration, + TimerStatus aStatus); + + // The method populates a Sequence from an array of JS::Value. + bool ArgumentsToValueList(const Sequence<JS::Value>& aData, + Sequence<JS::Value>& aSequence) const; + + // This method follows the same pattern as StartTimer: its runs on the owning + // thread and populate aCountLabel, used by CreateCounterOrResetCounterValue. + // Returns 3 possible values: + // * MAX_PAGE_COUNTERS in case of error that has to be reported; + // * 0 in case of a CX exception. The operation cannot continue; + // * the incremented counter value. + // Params: + // * aCx - the JSContext rooting aData. + // * aData - the arguments received by the console.count() method. + // * aCountLabel - the label that will be populated by this method. + uint32_t IncreaseCounter(JSContext* aCx, const Sequence<JS::Value>& aData, + nsAString& aCountLabel); + + // This method follows the same pattern as StartTimer: its runs on the owning + // thread and populate aCountLabel, used by CreateCounterResetValue. Returns + // 3 possible values: + // * MAX_PAGE_COUNTERS in case of error that has to be reported; + // * 0 elsewhere. In case of a CX exception, aCountLabel will be an empty + // string. + // Params: + // * aCx - the JSContext rooting aData. + // * aData - the arguments received by the console.count() method. + // * aCountLabel - the label that will be populated by this method. + uint32_t ResetCounter(JSContext* aCx, const Sequence<JS::Value>& aData, + nsAString& aCountLabel); + + static bool ShouldIncludeStackTrace(MethodName aMethodName); + + void AssertIsOnOwningThread() const; + + bool IsShuttingDown() const; + + bool MonotonicTimer(JSContext* aCx, MethodName aMethodName, + const Sequence<JS::Value>& aData, + DOMHighResTimeStamp* aTimeStamp); + + void StringifyElement(Element* aElement, nsAString& aOut); + + MOZ_CAN_RUN_SCRIPT + void MaybeExecuteDumpFunction(JSContext* aCx, const nsAString& aMethodName, + const Sequence<JS::Value>& aData, + nsIStackFrame* aStack); + + MOZ_CAN_RUN_SCRIPT + void MaybeExecuteDumpFunctionForTime(JSContext* aCx, MethodName aMethodName, + const nsAString& aMethodString, + uint64_t aMonotonicTimer, + const JS::Value& aData); + + MOZ_CAN_RUN_SCRIPT + void ExecuteDumpFunction(const nsAString& aMessage); + + bool ShouldProceed(MethodName aName) const; + + uint32_t WebIDLLogLevelToInteger(ConsoleLogLevel aLevel) const; + + uint32_t InternalLogLevelToInteger(MethodName aName) const; + + class ArgumentData { + public: + bool Initialize(JSContext* aCx, const Sequence<JS::Value>& aArguments); + void Trace(const TraceCallbacks& aCallbacks, void* aClosure); + bool PopulateArgumentsSequence(Sequence<JS::Value>& aSequence) const; + JSObject* Global() const { return mGlobal; } + + private: + void AssertIsOnOwningThread() const { + NS_ASSERT_OWNINGTHREAD(ArgumentData); + } + + NS_DECL_OWNINGTHREAD; + JS::Heap<JSObject*> mGlobal; + nsTArray<JS::Heap<JS::Value>> mArguments; + }; + + // Owning/CC thread only + nsCOMPtr<nsIGlobalObject> mGlobal; + + // Touched on the owner thread. + nsTHashMap<nsStringHashKey, DOMHighResTimeStamp> mTimerRegistry; + nsTHashMap<nsStringHashKey, uint32_t> mCounterRegistry; + + nsTArray<RefPtr<ConsoleCallData>> mCallDataStorage; + // These are references to the arguments we received in each call + // from the DOM bindings. + // Vector<T> supports non-memmovable types such as ArgumentData + // (without any need to jump through hoops like + // MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE for nsTArray). + Vector<ArgumentData> mArgumentStorage; + + RefPtr<AnyCallback> mConsoleEventNotifier; + + RefPtr<MainThreadConsoleData> mMainThreadData; + // This is the stack for grouping relating to Console-thread events, when + // the Console thread is not the main thread. + nsTArray<nsString> mGroupStack; + + uint64_t mOuterID; + uint64_t mInnerID; + + // Set only by ConsoleInstance: + nsString mConsoleID; + nsString mPassedInnerID; + RefPtr<ConsoleInstanceDumpCallback> mDumpFunction; + bool mDumpToStdout; + nsString mPrefix; + bool mChromeInstance; + uint32_t mCurrentLogLevel; + + enum { eUnknown, eInitialized, eShuttingDown } mStatus; + + // This is used when Console is created and it's used only for JSM custom + // console instance. + mozilla::TimeStamp mCreationTimeStamp; + + friend class ConsoleCallData; + friend class ConsoleCallDataWorkletRunnable; + friend class ConsoleInstance; + friend class ConsoleProfileWorkerRunnable; + friend class ConsoleProfileWorkletRunnable; + friend class ConsoleRunnable; + friend class ConsoleWorkerRunnable; + friend class ConsoleWorkletRunnable; + friend class MainThreadConsoleData; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_Console_h */ diff --git a/dom/console/ConsoleAPIStorage.sys.mjs b/dom/console/ConsoleAPIStorage.sys.mjs new file mode 100644 index 0000000000..f920d0d5e0 --- /dev/null +++ b/dom/console/ConsoleAPIStorage.sys.mjs @@ -0,0 +1,195 @@ +/* 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/. */ + +const STORAGE_MAX_EVENTS = 1000; + +var _consoleStorage = new Map(); + +// NOTE: these listeners used to just be added as observers and notified via +// Services.obs.notifyObservers. However, that has enough overhead to be a +// problem for this. Using an explicit global array is much cheaper, and +// should be equivalent. +var _logEventListeners = []; + +const CONSOLEAPISTORAGE_CID = Components.ID( + "{96cf7855-dfa9-4c6d-8276-f9705b4890f2}" +); + +/** + * The ConsoleAPIStorage is meant to cache window.console API calls for later + * reuse by other components when needed. For example, the Web Console code can + * display the cached messages when it opens for the active tab. + * + * ConsoleAPI messages are stored as they come from the ConsoleAPI code, with + * all their properties. They are kept around until the inner window object that + * created the messages is destroyed. Messages are indexed by the inner window + * ID. + * + * Usage: + * let ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"] + * .getService(Ci.nsIConsoleAPIStorage); + * + * // Get the cached events array for the window you want (use the inner + * // window ID). + * let events = ConsoleAPIStorage.getEvents(innerWindowID); + * events.forEach(function(event) { ... }); + * + * // Clear the events for the given inner window ID. + * ConsoleAPIStorage.clearEvents(innerWindowID); + */ +export function ConsoleAPIStorageService() { + this.init(); +} + +ConsoleAPIStorageService.prototype = { + classID: CONSOLEAPISTORAGE_CID, + QueryInterface: ChromeUtils.generateQI([ + "nsIConsoleAPIStorage", + "nsIObserver", + ]), + + observe: function CS_observe(aSubject, aTopic, aData) { + if (aTopic == "xpcom-shutdown") { + Services.obs.removeObserver(this, "xpcom-shutdown"); + Services.obs.removeObserver(this, "inner-window-destroyed"); + Services.obs.removeObserver(this, "memory-pressure"); + } else if (aTopic == "inner-window-destroyed") { + let innerWindowID = aSubject.QueryInterface(Ci.nsISupportsPRUint64).data; + this.clearEvents(innerWindowID + ""); + } else if (aTopic == "memory-pressure") { + this.clearEvents(); + } + }, + + /** @private */ + init: function CS_init() { + Services.obs.addObserver(this, "xpcom-shutdown"); + Services.obs.addObserver(this, "inner-window-destroyed"); + Services.obs.addObserver(this, "memory-pressure"); + }, + + /** + * Get the events array by inner window ID or all events from all windows. + * + * @param string [aId] + * Optional, the inner window ID for which you want to get the array of + * cached events. + * @returns array + * The array of cached events for the given window. If no |aId| is + * given this function returns all of the cached events, from any + * window. + */ + getEvents: function CS_getEvents(aId) { + if (aId != null) { + return (_consoleStorage.get(aId) || []).slice(0); + } + + let result = []; + + for (let [, events] of _consoleStorage) { + result.push.apply(result, events); + } + + return result.sort(function (a, b) { + return a.timeStamp - b.timeStamp; + }); + }, + + /** + * Adds a listener to be notified of log events. + * + * @param jsval [aListener] + * A JS listener which will be notified with the message object when + * a log event occurs. + * @param nsIPrincipal [aPrincipal] + * The principal of the listener - used to determine if we need to + * clone the message before forwarding it. + */ + addLogEventListener: function CS_addLogEventListener(aListener, aPrincipal) { + // If our listener has a less-privileged principal than us, then they won't + // be able to access the log event object which was populated for our + // scope. Accordingly we need to clone it for these listeners. + // + // XXX: AFAICT these listeners which we need to clone messages for are all + // tests. Alternative solutions are welcome. + const clone = !aPrincipal.subsumes( + Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal) + ); + _logEventListeners.push({ + callback: aListener, + clone, + }); + }, + + /** + * Removes a listener added with `addLogEventListener`. + * + * @param jsval [aListener] + * A JS listener which was added with `addLogEventListener`. + */ + removeLogEventListener: function CS_removeLogEventListener(aListener) { + const index = _logEventListeners.findIndex(l => l.callback === aListener); + if (index != -1) { + _logEventListeners.splice(index, 1); + } else { + console.error( + "Attempted to remove a log event listener that does not exist." + ); + } + }, + + /** + * Record an event associated with the given window ID. + * + * @param string aId + * The ID of the inner window for which the event occurred or "jsm" for + * messages logged from JavaScript modules.. + * @param object aEvent + * A JavaScript object you want to store. + */ + recordEvent: function CS_recordEvent(aId, aEvent) { + if (!_consoleStorage.has(aId)) { + _consoleStorage.set(aId, []); + } + + let storage = _consoleStorage.get(aId); + + storage.push(aEvent); + + // truncate + if (storage.length > STORAGE_MAX_EVENTS) { + storage.shift(); + } + + for (let { callback, clone } of _logEventListeners) { + try { + if (clone) { + callback(Cu.cloneInto(aEvent, callback)); + } else { + callback(aEvent); + } + } catch (e) { + // A failing listener should not prevent from calling other listeners. + console.error(e); + } + } + }, + + /** + * Clear storage data for the given window. + * + * @param string [aId] + * Optional, the inner window ID for which you want to clear the + * messages. If this is not specified all of the cached messages are + * cleared, from all window objects. + */ + clearEvents: function CS_clearEvents(aId) { + if (aId != null) { + _consoleStorage.delete(aId); + } else { + _consoleStorage.clear(); + Services.obs.notifyObservers(null, "console-storage-reset"); + } + }, +}; diff --git a/dom/console/ConsoleCommon.h b/dom/console/ConsoleCommon.h new file mode 100644 index 0000000000..7076c957a4 --- /dev/null +++ b/dom/console/ConsoleCommon.h @@ -0,0 +1,28 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_ConsoleCommon_h +#define mozilla_dom_ConsoleCommon_h + +#include "jsapi.h" +#include "nsString.h" + +namespace mozilla::dom::ConsoleCommon { + +// This class is used to clear any exception at the end of this method. +class MOZ_RAII ClearException { + public: + explicit ClearException(JSContext* aCx) : mCx(aCx) {} + + ~ClearException() { JS_ClearPendingException(mCx); } + + private: + JSContext* mCx; +}; + +} // namespace mozilla::dom::ConsoleCommon + +#endif /* mozilla_dom_ConsoleCommon_h */ diff --git a/dom/console/ConsoleInstance.cpp b/dom/console/ConsoleInstance.cpp new file mode 100644 index 0000000000..24477da56c --- /dev/null +++ b/dom/console/ConsoleInstance.cpp @@ -0,0 +1,271 @@ +/* -*- 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/ConsoleInstance.h" +#include "Console.h" +#include "mozilla/dom/ConsoleBinding.h" +#include "mozilla/Preferences.h" +#include "ConsoleCommon.h" +#include "ConsoleUtils.h" +#include "nsContentUtils.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ConsoleInstance, mConsole) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(ConsoleInstance) +NS_IMPL_CYCLE_COLLECTING_RELEASE(ConsoleInstance) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ConsoleInstance) + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY +NS_INTERFACE_MAP_END + +namespace { + +ConsoleUtils::Level WebIDLevelToConsoleUtilsLevel(ConsoleLevel aLevel) { + switch (aLevel) { + case ConsoleLevel::Log: + return ConsoleUtils::eLog; + case ConsoleLevel::Warning: + return ConsoleUtils::eWarning; + case ConsoleLevel::Error: + return ConsoleUtils::eError; + default: + break; + } + + return ConsoleUtils::eLog; +} + +} // namespace + +ConsoleInstance::ConsoleInstance(JSContext* aCx, + const ConsoleInstanceOptions& aOptions) + : mMaxLogLevel(ConsoleLogLevel::All), + mConsole(new Console(aCx, nullptr, 0, 0)) { + mConsole->mConsoleID = aOptions.mConsoleID; + mConsole->mPassedInnerID = aOptions.mInnerID; + + if (aOptions.mDump.WasPassed()) { + mConsole->mDumpFunction = &aOptions.mDump.Value(); + } + + mConsole->mPrefix = aOptions.mPrefix; + + // Let's inform that this is a custom instance. + mConsole->mChromeInstance = true; + + if (aOptions.mMaxLogLevel.WasPassed()) { + mMaxLogLevel = aOptions.mMaxLogLevel.Value(); + } + + if (!aOptions.mMaxLogLevelPref.IsEmpty()) { + if (!NS_IsMainThread()) { + NS_WARNING("Console.maxLogLevelPref is not supported on workers!"); + // Set the log level based on what we have. + SetLogLevel(); + return; + } + + CopyUTF16toUTF8(aOptions.mMaxLogLevelPref, mMaxLogLevelPref); + + Preferences::RegisterCallback(MaxLogLevelPrefChangedCallback, + mMaxLogLevelPref, this); + } + SetLogLevel(); +} + +ConsoleInstance::~ConsoleInstance() { + AssertIsOnMainThread(); + if (!mMaxLogLevelPref.IsEmpty()) { + Preferences::UnregisterCallback(MaxLogLevelPrefChangedCallback, + mMaxLogLevelPref, this); + } +}; + +ConsoleLogLevel PrefToValue(const nsACString& aPref, + const ConsoleLogLevel aLevel) { + if (aPref.IsEmpty()) { + return aLevel; + } + + nsAutoCString value; + nsresult rv = Preferences::GetCString(PromiseFlatCString(aPref).get(), value); + if (NS_WARN_IF(NS_FAILED(rv))) { + nsString message; + message.AssignLiteral( + "Console.maxLogLevelPref used with a non-existing pref: "); + message.Append(NS_ConvertUTF8toUTF16(aPref)); + + nsContentUtils::LogSimpleConsoleError(message, "chrome"_ns, false, + true /* from chrome context*/); + return aLevel; + } + + int index = FindEnumStringIndexImpl(value.get(), value.Length(), + ConsoleLogLevelValues::strings); + if (NS_WARN_IF(index < 0)) { + nsString message; + message.AssignLiteral("Invalid Console.maxLogLevelPref value: "); + message.Append(NS_ConvertUTF8toUTF16(value)); + + nsContentUtils::LogSimpleConsoleError(message, "chrome"_ns, false, + true /* from chrome context*/); + return aLevel; + } + + MOZ_ASSERT(index < (int)ConsoleLogLevelValues::Count); + return static_cast<ConsoleLogLevel>(index); +} + +void ConsoleInstance::SetLogLevel() { + mConsole->mCurrentLogLevel = mConsole->WebIDLLogLevelToInteger( + PrefToValue(mMaxLogLevelPref, mMaxLogLevel)); +} + +// static +void ConsoleInstance::MaxLogLevelPrefChangedCallback( + const char* /* aPrefName */, void* aSelf) { + AssertIsOnMainThread(); + auto* instance = static_cast<ConsoleInstance*>(aSelf); + if (MOZ_UNLIKELY(!instance->mConsole)) { + // We've been unlinked already but not destroyed yet. Bail. + return; + } + RefPtr pin{instance}; + pin->SetLogLevel(); +} + +JSObject* ConsoleInstance::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return ConsoleInstance_Binding::Wrap(aCx, this, aGivenProto); +} + +#define METHOD(name, string) \ + void ConsoleInstance::name(JSContext* aCx, \ + const Sequence<JS::Value>& aData) { \ + RefPtr<Console> console(mConsole); \ + console->MethodInternal(aCx, Console::Method##name, \ + nsLiteralString(string), aData); \ + } + +METHOD(Log, u"log") +METHOD(Info, u"info") +METHOD(Warn, u"warn") +METHOD(Error, u"error") +METHOD(Exception, u"exception") +METHOD(Debug, u"debug") +METHOD(Table, u"table") +METHOD(Trace, u"trace") +METHOD(Dir, u"dir"); +METHOD(Dirxml, u"dirxml"); +METHOD(Group, u"group") +METHOD(GroupCollapsed, u"groupCollapsed") + +#undef METHOD + +void ConsoleInstance::GroupEnd(JSContext* aCx) { + const Sequence<JS::Value> data; + RefPtr<Console> console(mConsole); + console->MethodInternal(aCx, Console::MethodGroupEnd, u"groupEnd"_ns, data); +} + +void ConsoleInstance::Time(JSContext* aCx, const nsAString& aLabel) { + RefPtr<Console> console(mConsole); + console->StringMethodInternal(aCx, aLabel, Sequence<JS::Value>(), + Console::MethodTime, u"time"_ns); +} + +void ConsoleInstance::TimeLog(JSContext* aCx, const nsAString& aLabel, + const Sequence<JS::Value>& aData) { + RefPtr<Console> console(mConsole); + console->StringMethodInternal(aCx, aLabel, aData, Console::MethodTimeLog, + u"timeLog"_ns); +} + +void ConsoleInstance::TimeEnd(JSContext* aCx, const nsAString& aLabel) { + RefPtr<Console> console(mConsole); + console->StringMethodInternal(aCx, aLabel, Sequence<JS::Value>(), + Console::MethodTimeEnd, u"timeEnd"_ns); +} + +void ConsoleInstance::TimeStamp(JSContext* aCx, + const JS::Handle<JS::Value> aData) { + ConsoleCommon::ClearException ce(aCx); + + Sequence<JS::Value> data; + SequenceRooter<JS::Value> rooter(aCx, &data); + + if (aData.isString() && !data.AppendElement(aData, fallible)) { + return; + } + + RefPtr<Console> console(mConsole); + console->MethodInternal(aCx, Console::MethodTimeStamp, u"timeStamp"_ns, data); +} + +void ConsoleInstance::Profile(JSContext* aCx, + const Sequence<JS::Value>& aData) { + RefPtr<Console> console(mConsole); + console->ProfileMethodInternal(aCx, Console::MethodProfile, u"profile"_ns, + aData); +} + +void ConsoleInstance::ProfileEnd(JSContext* aCx, + const Sequence<JS::Value>& aData) { + RefPtr<Console> console(mConsole); + console->ProfileMethodInternal(aCx, Console::MethodProfileEnd, + u"profileEnd"_ns, aData); +} + +void ConsoleInstance::Assert(JSContext* aCx, bool aCondition, + const Sequence<JS::Value>& aData) { + if (!aCondition) { + RefPtr<Console> console(mConsole); + console->MethodInternal(aCx, Console::MethodAssert, u"assert"_ns, aData); + } +} + +void ConsoleInstance::Count(JSContext* aCx, const nsAString& aLabel) { + RefPtr<Console> console(mConsole); + console->StringMethodInternal(aCx, aLabel, Sequence<JS::Value>(), + Console::MethodCount, u"count"_ns); +} + +void ConsoleInstance::CountReset(JSContext* aCx, const nsAString& aLabel) { + RefPtr<Console> console(mConsole); + console->StringMethodInternal(aCx, aLabel, Sequence<JS::Value>(), + Console::MethodCountReset, u"countReset"_ns); +} + +void ConsoleInstance::Clear(JSContext* aCx) { + const Sequence<JS::Value> data; + RefPtr<Console> console(mConsole); + console->MethodInternal(aCx, Console::MethodClear, u"clear"_ns, data); +} + +bool ConsoleInstance::ShouldLog(ConsoleLogLevel aLevel) { + return mConsole->mCurrentLogLevel <= + mConsole->WebIDLLogLevelToInteger(aLevel); +} + +void ConsoleInstance::ReportForServiceWorkerScope(const nsAString& aScope, + const nsAString& aMessage, + const nsAString& aFilename, + uint32_t aLineNumber, + uint32_t aColumnNumber, + ConsoleLevel aLevel) { + if (!NS_IsMainThread()) { + return; + } + + ConsoleUtils::ReportForServiceWorkerScope( + aScope, aMessage, aFilename, aLineNumber, aColumnNumber, + WebIDLevelToConsoleUtilsLevel(aLevel)); +} + +} // namespace mozilla::dom diff --git a/dom/console/ConsoleInstance.h b/dom/console/ConsoleInstance.h new file mode 100644 index 0000000000..5d322a867b --- /dev/null +++ b/dom/console/ConsoleInstance.h @@ -0,0 +1,122 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_ConsoleInstance_h +#define mozilla_dom_ConsoleInstance_h + +#include "mozilla/dom/Console.h" + +namespace mozilla::dom { + +class ConsoleInstance final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ConsoleInstance) + + explicit ConsoleInstance(JSContext* aCx, + const ConsoleInstanceOptions& aOptions); + + // WebIDL methods + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + nsPIDOMWindowInner* GetParentObject() const { return nullptr; } + + MOZ_CAN_RUN_SCRIPT + void Log(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Info(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Warn(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Error(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Exception(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Debug(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Table(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Trace(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Dir(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Dirxml(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Group(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void GroupCollapsed(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void GroupEnd(JSContext* aCx); + + MOZ_CAN_RUN_SCRIPT + void Time(JSContext* aCx, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + void TimeLog(JSContext* aCx, const nsAString& aLabel, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void TimeEnd(JSContext* aCx, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + void TimeStamp(JSContext* aCx, const JS::Handle<JS::Value> aData); + + MOZ_CAN_RUN_SCRIPT + void Profile(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void ProfileEnd(JSContext* aCx, const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Assert(JSContext* aCx, bool aCondition, + const Sequence<JS::Value>& aData); + + MOZ_CAN_RUN_SCRIPT + void Count(JSContext* aCx, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + void CountReset(JSContext* aCx, const nsAString& aLabel); + + MOZ_CAN_RUN_SCRIPT + void Clear(JSContext* aCx); + + bool ShouldLog(ConsoleLogLevel aLevel); + + // For testing only. + void ReportForServiceWorkerScope(const nsAString& aScope, + const nsAString& aMessage, + const nsAString& aFilename, + uint32_t aLineNumber, uint32_t aColumnNumber, + ConsoleLevel aLevel); + + private: + ~ConsoleInstance(); + + void SetLogLevel(); + static void MaxLogLevelPrefChangedCallback(const char* /* aPrefName */, + void* /* aClosure */); + + ConsoleLogLevel mMaxLogLevel; + nsCString mMaxLogLevelPref; + RefPtr<Console> mConsole; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_ConsoleInstance_h diff --git a/dom/console/ConsoleReportCollector.cpp b/dom/console/ConsoleReportCollector.cpp new file mode 100644 index 0000000000..f64d79aa64 --- /dev/null +++ b/dom/console/ConsoleReportCollector.cpp @@ -0,0 +1,198 @@ +/* -*- 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/ConsoleReportCollector.h" + +#include "mozilla/dom/Document.h" +#include "mozilla/net/NeckoChannelParams.h" + +#include "ConsoleUtils.h" +#include "nsIScriptError.h" +#include "nsNetUtil.h" + +namespace mozilla { + +using mozilla::dom::ConsoleUtils; + +NS_IMPL_ISUPPORTS(ConsoleReportCollector, nsIConsoleReportCollector) + +ConsoleReportCollector::ConsoleReportCollector() + : mMutex("mozilla::ConsoleReportCollector") {} + +void ConsoleReportCollector::AddConsoleReport( + uint32_t aErrorFlags, const nsACString& aCategory, + nsContentUtils::PropertiesFile aPropertiesFile, + const nsACString& aSourceFileURI, uint32_t aLineNumber, + uint32_t aColumnNumber, const nsACString& aMessageName, + const nsTArray<nsString>& aStringParams) { + // any thread + MutexAutoLock lock(mMutex); + + mPendingReports.EmplaceBack(aErrorFlags, aCategory, aPropertiesFile, + aSourceFileURI, aLineNumber, aColumnNumber, + aMessageName, aStringParams); +} + +void ConsoleReportCollector::FlushReportsToConsole(uint64_t aInnerWindowID, + ReportAction aAction) { + nsTArray<PendingReport> reports; + + { + MutexAutoLock lock(mMutex); + if (aAction == ReportAction::Forget) { + reports = std::move(mPendingReports); + } else { + reports = mPendingReports.Clone(); + } + } + + for (uint32_t i = 0; i < reports.Length(); ++i) { + PendingReport& report = reports[i]; + + nsAutoString errorText; + nsresult rv; + if (!report.mStringParams.IsEmpty()) { + rv = nsContentUtils::FormatLocalizedString( + report.mPropertiesFile, report.mMessageName.get(), + report.mStringParams, errorText); + } else { + rv = nsContentUtils::GetLocalizedString( + report.mPropertiesFile, report.mMessageName.get(), errorText); + } + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + // It would be nice if we did not have to do this since ReportToConsole() + // just turns around and converts it back to a spec. + nsCOMPtr<nsIURI> uri; + if (!report.mSourceFileURI.IsEmpty()) { + nsresult rv = NS_NewURI(getter_AddRefs(uri), report.mSourceFileURI); + if (NS_FAILED(rv)) { + NS_WARNING(nsPrintfCString("Failed to transform %s to uri", + report.mSourceFileURI.get()) + .get()); + continue; + } + } + + nsContentUtils::ReportToConsoleByWindowID( + errorText, report.mErrorFlags, report.mCategory, aInnerWindowID, uri, + u""_ns, report.mLineNumber, report.mColumnNumber); + } +} + +void ConsoleReportCollector::FlushReportsToConsoleForServiceWorkerScope( + const nsACString& aScope, ReportAction aAction) { + nsTArray<PendingReport> reports; + + { + MutexAutoLock lock(mMutex); + if (aAction == ReportAction::Forget) { + reports = std::move(mPendingReports); + } else { + reports = mPendingReports.Clone(); + } + } + + for (uint32_t i = 0; i < reports.Length(); ++i) { + PendingReport& report = reports[i]; + + nsAutoString errorText; + nsresult rv; + if (!report.mStringParams.IsEmpty()) { + rv = nsContentUtils::FormatLocalizedString( + report.mPropertiesFile, report.mMessageName.get(), + report.mStringParams, errorText); + } else { + rv = nsContentUtils::GetLocalizedString( + report.mPropertiesFile, report.mMessageName.get(), errorText); + } + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + ConsoleUtils::Level level = ConsoleUtils::eLog; + switch (report.mErrorFlags) { + case nsIScriptError::errorFlag: + level = ConsoleUtils::eError; + break; + case nsIScriptError::warningFlag: + level = ConsoleUtils::eWarning; + break; + default: + // default to log otherwise + break; + } + + ConsoleUtils::ReportForServiceWorkerScope( + NS_ConvertUTF8toUTF16(aScope), errorText, + NS_ConvertUTF8toUTF16(report.mSourceFileURI), report.mLineNumber, + report.mColumnNumber, level); + } +} + +void ConsoleReportCollector::FlushConsoleReports(dom::Document* aDocument, + ReportAction aAction) { + MOZ_ASSERT(NS_IsMainThread()); + + FlushReportsToConsole(aDocument ? aDocument->InnerWindowID() : 0, aAction); +} + +void ConsoleReportCollector::FlushConsoleReports(nsILoadGroup* aLoadGroup, + ReportAction aAction) { + FlushReportsToConsole(nsContentUtils::GetInnerWindowID(aLoadGroup), aAction); +} + +void ConsoleReportCollector::FlushConsoleReports( + nsIConsoleReportCollector* aCollector) { + MOZ_ASSERT(aCollector); + + nsTArray<PendingReport> reports; + + { + MutexAutoLock lock(mMutex); + reports = std::move(mPendingReports); + } + + for (uint32_t i = 0; i < reports.Length(); ++i) { + PendingReport& report = reports[i]; + aCollector->AddConsoleReport( + report.mErrorFlags, report.mCategory, report.mPropertiesFile, + report.mSourceFileURI, report.mLineNumber, report.mColumnNumber, + report.mMessageName, + static_cast<const nsTArray<nsString>&>(report.mStringParams)); + } +} + +void ConsoleReportCollector::StealConsoleReports( + nsTArray<net::ConsoleReportCollected>& aReports) { + aReports.Clear(); + + nsTArray<PendingReport> reports; + + { + MutexAutoLock lock(mMutex); + reports = std::move(mPendingReports); + } + + for (const PendingReport& report : reports) { + aReports.AppendElement(net::ConsoleReportCollected( + report.mErrorFlags, report.mCategory, report.mPropertiesFile, + report.mSourceFileURI, report.mLineNumber, report.mColumnNumber, + report.mMessageName, report.mStringParams)); + } +} + +void ConsoleReportCollector::ClearConsoleReports() { + MutexAutoLock lock(mMutex); + + mPendingReports.Clear(); +} + +ConsoleReportCollector::~ConsoleReportCollector() = default; + +} // namespace mozilla diff --git a/dom/console/ConsoleReportCollector.h b/dom/console/ConsoleReportCollector.h new file mode 100644 index 0000000000..9d4e0b1aa0 --- /dev/null +++ b/dom/console/ConsoleReportCollector.h @@ -0,0 +1,92 @@ +/* -*- 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/. */ + +#ifndef mozilla_ConsoleReportCollector_h +#define mozilla_ConsoleReportCollector_h + +#include "mozilla/Mutex.h" +#include "nsIConsoleReportCollector.h" +#include "nsTArray.h" + +namespace mozilla { + +namespace net { +class ConsoleReportCollected; +} + +class ConsoleReportCollector final : public nsIConsoleReportCollector { + public: + ConsoleReportCollector(); + + void AddConsoleReport(uint32_t aErrorFlags, const nsACString& aCategory, + nsContentUtils::PropertiesFile aPropertiesFile, + const nsACString& aSourceFileURI, uint32_t aLineNumber, + uint32_t aColumnNumber, const nsACString& aMessageName, + const nsTArray<nsString>& aStringParams) override; + + void FlushReportsToConsole( + uint64_t aInnerWindowID, + ReportAction aAction = ReportAction::Forget) override; + + void FlushReportsToConsoleForServiceWorkerScope( + const nsACString& aScope, + ReportAction aAction = ReportAction::Forget) override; + + void FlushConsoleReports( + dom::Document* aDocument, + ReportAction aAction = ReportAction::Forget) override; + + void FlushConsoleReports( + nsILoadGroup* aLoadGroup, + ReportAction aAction = ReportAction::Forget) override; + + void FlushConsoleReports(nsIConsoleReportCollector* aCollector) override; + + void StealConsoleReports( + nsTArray<net::ConsoleReportCollected>& aReports) override; + + void ClearConsoleReports() override; + + private: + ~ConsoleReportCollector(); + + struct PendingReport { + PendingReport(uint32_t aErrorFlags, const nsACString& aCategory, + nsContentUtils::PropertiesFile aPropertiesFile, + const nsACString& aSourceFileURI, uint32_t aLineNumber, + uint32_t aColumnNumber, const nsACString& aMessageName, + const nsTArray<nsString>& aStringParams) + : mErrorFlags(aErrorFlags), + mCategory(aCategory), + mPropertiesFile(aPropertiesFile), + mSourceFileURI(aSourceFileURI), + mLineNumber(aLineNumber), + mColumnNumber(aColumnNumber), + mMessageName(aMessageName), + mStringParams(aStringParams.Clone()) {} + + const uint32_t mErrorFlags; + const nsCString mCategory; + const nsContentUtils::PropertiesFile mPropertiesFile; + const nsCString mSourceFileURI; + const uint32_t mLineNumber; + const uint32_t mColumnNumber; + const nsCString mMessageName; + const CopyableTArray<nsString> mStringParams; + }; + + Mutex mMutex; + + // protected by mMutex + nsTArray<PendingReport> mPendingReports MOZ_GUARDED_BY(mMutex); + + public: + NS_DECL_THREADSAFE_ISUPPORTS +}; + +} // namespace mozilla + +#endif // mozilla_ConsoleReportCollector_h diff --git a/dom/console/ConsoleUtils.cpp b/dom/console/ConsoleUtils.cpp new file mode 100644 index 0000000000..9767dd30dd --- /dev/null +++ b/dom/console/ConsoleUtils.cpp @@ -0,0 +1,167 @@ +/* -*- 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 "ConsoleUtils.h" +#include "ConsoleCommon.h" +#include "nsContentUtils.h" +#include "nsIConsoleAPIStorage.h" +#include "nsIXPConnect.h" +#include "nsServiceManagerUtils.h" + +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/NullPrincipal.h" +#include "mozilla/dom/ConsoleBinding.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/dom/ScriptSettings.h" +#include "js/PropertyAndElement.h" // JS_DefineProperty + +namespace mozilla::dom { + +namespace { + +StaticRefPtr<ConsoleUtils> gConsoleUtilsService; + +} + +/* static */ +ConsoleUtils* ConsoleUtils::GetOrCreate() { + if (!gConsoleUtilsService) { + MOZ_ASSERT(NS_IsMainThread()); + + gConsoleUtilsService = new ConsoleUtils(); + ClearOnShutdown(&gConsoleUtilsService); + } + + return gConsoleUtilsService; +} + +ConsoleUtils::ConsoleUtils() = default; +ConsoleUtils::~ConsoleUtils() = default; + +/* static */ +void ConsoleUtils::ReportForServiceWorkerScope(const nsAString& aScope, + const nsAString& aMessage, + const nsAString& aFilename, + uint32_t aLineNumber, + uint32_t aColumnNumber, + Level aLevel) { + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr<ConsoleUtils> service = ConsoleUtils::GetOrCreate(); + if (NS_WARN_IF(!service)) { + return; + } + + service->ReportForServiceWorkerScopeInternal( + aScope, aMessage, aFilename, aLineNumber, aColumnNumber, aLevel); +} + +void ConsoleUtils::ReportForServiceWorkerScopeInternal( + const nsAString& aScope, const nsAString& aMessage, + const nsAString& aFilename, uint32_t aLineNumber, uint32_t aColumnNumber, + Level aLevel) { + MOZ_ASSERT(NS_IsMainThread()); + + AutoJSAPI jsapi; + jsapi.Init(); + + JSContext* cx = jsapi.cx(); + + ConsoleCommon::ClearException ce(cx); + JS::Rooted<JSObject*> global(cx, GetOrCreateSandbox(cx)); + if (NS_WARN_IF(!global)) { + return; + } + + // The GetOrCreateSandbox call returns a proxy to the actual sandbox object. + // We don't need a proxy here. + global = js::UncheckedUnwrap(global); + + JSAutoRealm ar(cx, global); + + RootedDictionary<ConsoleEvent> event(cx); + + event.mID.Construct(); + event.mID.Value().SetAsString() = aScope; + + event.mInnerID.Construct(); + event.mInnerID.Value().SetAsString() = u"ServiceWorker"_ns; + + switch (aLevel) { + case eLog: + event.mLevel = u"log"_ns; + break; + + case eWarning: + event.mLevel = u"warn"_ns; + break; + + case eError: + event.mLevel = u"error"_ns; + break; + } + + event.mFilename = aFilename; + event.mLineNumber = aLineNumber; + event.mColumnNumber = aColumnNumber; + event.mTimeStamp = JS_Now() / PR_USEC_PER_MSEC; + event.mMicroSecondTimeStamp = JS_Now(); + + JS::Rooted<JS::Value> messageValue(cx); + if (!dom::ToJSValue(cx, aMessage, &messageValue)) { + return; + } + + event.mArguments.Construct(); + if (!event.mArguments.Value().AppendElement(messageValue, fallible)) { + return; + } + + nsCOMPtr<nsIConsoleAPIStorage> storage = + do_GetService("@mozilla.org/consoleAPI-storage;1"); + + if (NS_WARN_IF(!storage)) { + return; + } + + JS::Rooted<JS::Value> eventValue(cx); + if (!ToJSValue(cx, event, &eventValue)) { + return; + } + + // This is a legacy property. + JS::Rooted<JSObject*> eventObj(cx, &eventValue.toObject()); + if (NS_WARN_IF(!JS_DefineProperty(cx, eventObj, "wrappedJSObject", eventObj, + JSPROP_ENUMERATE))) { + return; + } + + storage->RecordEvent(u"ServiceWorker"_ns, eventValue); +} + +JSObject* ConsoleUtils::GetOrCreateSandbox(JSContext* aCx) { + AssertIsOnMainThread(); + + if (!mSandbox) { + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + MOZ_ASSERT(xpc, "This should never be null!"); + + RefPtr<NullPrincipal> nullPrincipal = + NullPrincipal::CreateWithoutOriginAttributes(); + + JS::Rooted<JSObject*> sandbox(aCx); + nsresult rv = xpc->CreateSandbox(aCx, nullPrincipal, sandbox.address()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + mSandbox = new JSObjectHolder(aCx, sandbox); + } + + return mSandbox->GetJSObject(); +} + +} // namespace mozilla::dom diff --git a/dom/console/ConsoleUtils.h b/dom/console/ConsoleUtils.h new file mode 100644 index 0000000000..6e3d71ea04 --- /dev/null +++ b/dom/console/ConsoleUtils.h @@ -0,0 +1,53 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_ConsoleUtils_h +#define mozilla_dom_ConsoleUtils_h + +#include "mozilla/JSObjectHolder.h" +#include "nsISupportsImpl.h" +#include "nsString.h" + +namespace mozilla::dom { + +class ConsoleUtils final { + public: + NS_INLINE_DECL_REFCOUNTING(ConsoleUtils) + + enum Level { + eLog, + eWarning, + eError, + }; + + // Main-thread only, reports a console message from a ServiceWorker. + static void ReportForServiceWorkerScope(const nsAString& aScope, + const nsAString& aMessage, + const nsAString& aFilename, + uint32_t aLineNumber, + uint32_t aColumnNumber, Level aLevel); + + private: + ConsoleUtils(); + ~ConsoleUtils(); + + static ConsoleUtils* GetOrCreate(); + + JSObject* GetOrCreateSandbox(JSContext* aCx); + + void ReportForServiceWorkerScopeInternal(const nsAString& aScope, + const nsAString& aMessage, + const nsAString& aFilename, + uint32_t aLineNumber, + uint32_t aColumnNumber, + Level aLevel); + + RefPtr<JSObjectHolder> mSandbox; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_ConsoleUtils_h */ diff --git a/dom/console/components.conf b/dom/console/components.conf new file mode 100644 index 0000000000..fec7e41972 --- /dev/null +++ b/dom/console/components.conf @@ -0,0 +1,14 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +Classes = [ + { + 'cid': '{96cf7855-dfa9-4c6d-8276-f9705b4890f2}', + 'contract_ids': ['@mozilla.org/consoleAPI-storage;1'], + 'esModule': 'resource://gre/modules/ConsoleAPIStorage.sys.mjs', + 'constructor': 'ConsoleAPIStorageService', + }, +] diff --git a/dom/console/moz.build b/dom/console/moz.build new file mode 100644 index 0000000000..d5be3324ae --- /dev/null +++ b/dom/console/moz.build @@ -0,0 +1,57 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "DOM: Core & HTML") + +XPIDL_SOURCES += [ + "nsIConsoleAPIStorage.idl", +] + +XPIDL_MODULE = "dom" + +EXPORTS += [ + "nsIConsoleReportCollector.h", +] + +EXPORTS.mozilla += [ + "ConsoleReportCollector.h", +] + +EXPORTS.mozilla.dom += [ + "Console.h", + "ConsoleInstance.h", + "ConsoleUtils.h", +] + +UNIFIED_SOURCES += [ + "Console.cpp", + "ConsoleInstance.cpp", + "ConsoleReportCollector.cpp", + "ConsoleUtils.cpp", +] + +EXTRA_JS_MODULES += [ + "ConsoleAPIStorage.sys.mjs", +] + +XPCOM_MANIFESTS += [ + "components.conf", +] + +LOCAL_INCLUDES += [ + "/docshell/base", + "/dom/base", + "/js/xpconnect/src", +] + +MOCHITEST_MANIFESTS += ["tests/mochitest.toml"] +MOCHITEST_CHROME_MANIFESTS += ["tests/chrome.toml"] +XPCSHELL_TESTS_MANIFESTS += ["tests/xpcshell/xpcshell.toml"] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" diff --git a/dom/console/nsIConsoleAPIStorage.idl b/dom/console/nsIConsoleAPIStorage.idl new file mode 100644 index 0000000000..ec3638c295 --- /dev/null +++ b/dom/console/nsIConsoleAPIStorage.idl @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsISupports.idl" +#include "nsIPrincipal.idl" + +[scriptable, uuid(9e32a7b6-c4d1-4d9a-87b9-1ef6b75c27a9)] +interface nsIConsoleAPIStorage : nsISupports +{ + /** + * Get the events array by inner window ID or all events from all windows. + * + * @param string [aId] + * Optional, the inner window ID for which you want to get the array of + * cached events. + * @returns array + * The array of cached events for the given window. If no |aId| is + * given this function returns all of the cached events, from any + * window. + */ + jsval getEvents([optional] in AString aId); + + /** + * Adds a listener to be notified of log events. + * + * @param jsval [aListener] + * A JS listener which will be notified with the message object when + * a log event occurs. + * @param nsIPrincipal [aPrincipal] + * The principal of the listener - used to determine if we need to + * clone the message before forwarding it. + */ + void addLogEventListener(in jsval aListener, in nsIPrincipal aPrincipal); + + /** + * Removes a listener added with `addLogEventListener`. + * + * @param jsval [aListener] + * A JS listener which was added with `addLogEventListener`. + */ + void removeLogEventListener(in jsval aListener); + + /** + * Record an event associated with the given window ID. + * + * @param string aId + * The ID of the inner window for which the event occurred or "jsm" for + * messages logged from JavaScript modules.. + * @param object aEvent + * A JavaScript object you want to store. + */ + void recordEvent(in AString aId, in jsval aEvent); + + /** + * Clear storage data for the given window. + * + * @param string [aId] + * Optional, the inner window ID for which you want to clear the + * messages. If this is not specified all of the cached messages are + * cleared, from all window objects. + */ + void clearEvents([optional] in AString aId); +}; diff --git a/dom/console/nsIConsoleReportCollector.h b/dom/console/nsIConsoleReportCollector.h new file mode 100644 index 0000000000..3e972184e3 --- /dev/null +++ b/dom/console/nsIConsoleReportCollector.h @@ -0,0 +1,132 @@ +/* -*- 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/. */ + +#ifndef nsIConsoleReportCollector_h +#define nsIConsoleReportCollector_h + +#include "nsContentUtils.h" +#include "nsISupports.h" +#include "nsStringFwd.h" +#include "nsTArrayForwardDeclare.h" + +// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/nonidl.rs +#define NS_NSICONSOLEREPORTCOLLECTOR_IID \ + { \ + 0xdd98a481, 0xd2c4, 0x4203, { \ + 0x8d, 0xfa, 0x85, 0xbf, 0xd7, 0xdc, 0xd7, 0x05 \ + } \ + } + +namespace mozilla::net { +class ConsoleReportCollected; +} // namespace mozilla::net + +// An interface for saving reports until we can flush them to the correct +// window at a later time. +class NS_NO_VTABLE nsIConsoleReportCollector : public nsISupports { + public: + NS_DECLARE_STATIC_IID_ACCESSOR(NS_NSICONSOLEREPORTCOLLECTOR_IID) + + // Add a pending report to be later displayed on the console. This may be + // called from any thread. + // + // aErrorFlags A nsIScriptError flags value. + // aCategory Name of module reporting error. + // aPropertiesFile Properties file containing localized message. + // aSourceFileURI The URI of the script generating the error. Must be a URI + // spec. + // aLineNumber The line number where the error was generated. May be 0 if + // the line number is not known. + // aColumnNumber The column number where the error was generated. May be 0 + // if the line number is not known. + // aMessageName The name of the localized message contained in the + // properties file. + // aStringParams An array of nsString parameters to use when localizing the + // message. + virtual void AddConsoleReport(uint32_t aErrorFlags, + const nsACString& aCategory, + nsContentUtils::PropertiesFile aPropertiesFile, + const nsACString& aSourceFileURI, + uint32_t aLineNumber, uint32_t aColumnNumber, + const nsACString& aMessageName, + const nsTArray<nsString>& aStringParams) = 0; + + // A version of AddConsoleReport() that accepts the message parameters + // as variable nsString arguments (or really, any sort of const nsAString). + // All other args the same as AddConsoleReport(). + template <typename... Params> + void AddConsoleReport(uint32_t aErrorFlags, const nsACString& aCategory, + nsContentUtils::PropertiesFile aPropertiesFile, + const nsACString& aSourceFileURI, uint32_t aLineNumber, + uint32_t aColumnNumber, const nsACString& aMessageName, + Params&&... aParams) { + nsTArray<nsString> params; + mozilla::dom::StringArrayAppender::Append(params, sizeof...(Params), + std::forward<Params>(aParams)...); + AddConsoleReport(aErrorFlags, aCategory, aPropertiesFile, aSourceFileURI, + aLineNumber, aColumnNumber, aMessageName, params); + } + + // An enum calss to indicate whether should free the pending reports or not. + // Forget Free the pending reports. + // Save Keep the pending reports. + enum class ReportAction { Forget, Save }; + + // Flush all pending reports to the console. May be called from any thread. + // + // aInnerWindowID A inner window ID representing where to flush the reports. + // aAction An action to determine whether to reserve the pending + // reports. Defalut action is to forget the report. + virtual void FlushReportsToConsole( + uint64_t aInnerWindowID, ReportAction aAction = ReportAction::Forget) = 0; + + virtual void FlushReportsToConsoleForServiceWorkerScope( + const nsACString& aScope, + ReportAction aAction = ReportAction::Forget) = 0; + + // Flush all pending reports to the console. Main thread only. + // + // aDocument An optional document representing where to flush the + // reports. If provided, then the corresponding window's + // web console will get the reports. Otherwise the reports + // go to the browser console. + // aAction An action to determine whether to reserve the pending + // reports. Defalut action is to forget the report. + virtual void FlushConsoleReports( + mozilla::dom::Document* aDocument, + ReportAction aAction = ReportAction::Forget) = 0; + + // Flush all pending reports to the console. May be called from any thread. + // + // aLoadGroup An optional loadGroup representing where to flush the + // reports. If provided, then the corresponding window's + // web console will get the reports. Otherwise the reports + // go to the browser console. + // aAction An action to determine whether to reserve the pending + // reports. Defalut action is to forget the report. + virtual void FlushConsoleReports( + nsILoadGroup* aLoadGroup, + ReportAction aAction = ReportAction::Forget) = 0; + + // Flush all pending reports to another collector. May be called from any + // thread. + // + // aCollector A required collector object that will effectively take + // ownership of our currently console reports. + virtual void FlushConsoleReports(nsIConsoleReportCollector* aCollector) = 0; + + // Steal all pending reports to IPC structs. May be called from any thread. + virtual void StealConsoleReports( + nsTArray<mozilla::net::ConsoleReportCollected>& aReports) = 0; + + // Clear all pending reports. + virtual void ClearConsoleReports() = 0; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(nsIConsoleReportCollector, + NS_NSICONSOLEREPORTCOLLECTOR_IID) + +#endif // nsIConsoleReportCollector_h diff --git a/dom/console/tests/chrome.toml b/dom/console/tests/chrome.toml new file mode 100644 index 0000000000..5927dbb9cb --- /dev/null +++ b/dom/console/tests/chrome.toml @@ -0,0 +1,11 @@ +[DEFAULT] +skip-if = ["os == 'android'"] +support-files = [ + "file_empty.html", + "console.sys.mjs", + "head.js", +] + +["test_console.xhtml"] + +["test_jsm.xhtml"] diff --git a/dom/console/tests/console.sys.mjs b/dom/console/tests/console.sys.mjs new file mode 100644 index 0000000000..d239d58a5d --- /dev/null +++ b/dom/console/tests/console.sys.mjs @@ -0,0 +1,45 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +export var ConsoleTest = { + go(dumpFunction) { + console.log("Hello world!"); + console.createInstance().log("Hello world!"); + + let c = console.createInstance({ + consoleID: "wow", + innerID: "CUSTOM INNER", + dump: dumpFunction, + prefix: "_PREFIX_", + }); + + c.log("Hello world!"); + c.trace("Hello world!"); + + console + .createInstance({ innerID: "LEVEL", maxLogLevel: "Off" }) + .log("Invisible!"); + console + .createInstance({ innerID: "LEVEL", maxLogLevel: "All" }) + .log("Hello world!"); + console + .createInstance({ + innerID: "LEVEL", + maxLogLevelPref: "pref.test.console", + }) + .log("Hello world!"); + + this.c2 = console.createInstance({ + innerID: "NO PREF", + maxLogLevel: "Warn", + maxLogLevelPref: "pref.test.console.notset", + }); + this.c2.log("Invisible!"); + this.c2.warn("Hello world!"); + }, + + go2() { + this.c2.log("Hello world!"); + }, +}; diff --git a/dom/console/tests/file_empty.html b/dom/console/tests/file_empty.html new file mode 100644 index 0000000000..495c23ec8a --- /dev/null +++ b/dom/console/tests/file_empty.html @@ -0,0 +1 @@ +<!DOCTYPE html><html><body></body></html> diff --git a/dom/console/tests/head.js b/dom/console/tests/head.js new file mode 100644 index 0000000000..3e9c72cfb9 --- /dev/null +++ b/dom/console/tests/head.js @@ -0,0 +1,24 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const ConsoleAPIStorage = SpecialPowers.Cc[ + "@mozilla.org/consoleAPI-storage;1" +].getService(SpecialPowers.Ci.nsIConsoleAPIStorage); + +// This is intended to just be a drop-in replacement for an old observer +// notification. +function addConsoleStorageListener(listener) { + listener.__handler = (message, id) => { + listener.observe(message, id); + }; + ConsoleAPIStorage.addLogEventListener( + listener.__handler, + SpecialPowers.wrap(document).nodePrincipal + ); +} + +function removeConsoleStorageListener(listener) { + ConsoleAPIStorage.removeLogEventListener(listener.__handler); +} diff --git a/dom/console/tests/mochitest.toml b/dom/console/tests/mochitest.toml new file mode 100644 index 0000000000..4768f9521e --- /dev/null +++ b/dom/console/tests/mochitest.toml @@ -0,0 +1,23 @@ +[DEFAULT] +support-files = [ + "file_empty.html", + "head.js", +] + +["test_bug659625.html"] + +["test_bug978522.html"] + +["test_bug979109.html"] + +["test_bug989665.html"] + +["test_consoleEmptyStack.html"] + +["test_console_binding.html"] + +["test_console_proto.html"] + +["test_count.html"] + +["test_timer.html"] diff --git a/dom/console/tests/test_bug659625.html b/dom/console/tests/test_bug659625.html new file mode 100644 index 0000000000..1cf93d9bfd --- /dev/null +++ b/dom/console/tests/test_bug659625.html @@ -0,0 +1,107 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=659625 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 659625</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=659625">Mozilla Bug 659625</a> +<script type="application/javascript"> + const { Cc, Ci } = SpecialPowers; + let consoleStorage = Cc["@mozilla.org/consoleAPI-storage;1"]; + let storage = consoleStorage.getService(Ci.nsIConsoleAPIStorage); + + let clearAndCheckStorage = () => { + console.clear(); + is(storage.getEvents().length, 1, + "Only one event remains in consoleAPIStorage"); + is(storage.getEvents()[0].level, "clear", + "Remaining event has level 'clear'"); + }; + + storage.clearEvents(); + is(storage.getEvents().length, 0, + "Console is empty when test is starting"); + clearAndCheckStorage(); + + console.log("log"); + console.debug("debug"); + console.warn("warn"); + console.error("error"); + console.exception("exception"); + is(storage.getEvents().length, 6, + "5 new console events have been registered for logging variants"); + clearAndCheckStorage(); + + console.trace(); + is(storage.getEvents().length, 2, + "1 new console event registered for trace"); + clearAndCheckStorage(); + + console.dir({}); + is(storage.getEvents().length, 2, + "1 new console event registered for dir"); + clearAndCheckStorage(); + + console.count("count-label"); + console.count("count-label"); + is(storage.getEvents().length, 3, + "2 new console events registered for 2 count calls"); + clearAndCheckStorage(); + + // For bug 1346326. + console.count("default"); + console.count(); + console.count(undefined); + let events = storage.getEvents(); + // Drop the event from the previous "clear". + events.splice(0, 1); + is(events.length, 3, + "3 new console events registered for 3 'default' count calls"); + for (let i = 0; i < events.length; ++i) { + is(events[i].counter.count, i + 1, "check counter for event " + i); + is(events[i].counter.label, "default", "check label for event " + i); + } + clearAndCheckStorage(); + + console.group("group-label"); + console.log("group-log"); + is(storage.getEvents().length, 3, + "2 new console events registered for group + log"); + clearAndCheckStorage(); + + console.groupCollapsed("group-collapsed"); + console.log("group-collapsed-log"); + is(storage.getEvents().length, 3, + "2 new console events registered for groupCollapsed + log"); + clearAndCheckStorage(); + + console.group("closed-group-label"); + console.log("group-log"); + console.groupEnd(); + is(storage.getEvents().length, 4, + "3 new console events registered for group/groupEnd"); + clearAndCheckStorage(); + + console.time("time-label"); + console.timeEnd(); + is(storage.getEvents().length, 3, + "2 new console events registered for time/timeEnd"); + clearAndCheckStorage(); + + console.timeStamp("timestamp-label"); + is(storage.getEvents().length, 2, + "1 new console event registered for timeStamp"); + clearAndCheckStorage(); + + // Check that console.clear() clears previous clear messages + clearAndCheckStorage(); + +</script> +</body> +</html> diff --git a/dom/console/tests/test_bug978522.html b/dom/console/tests/test_bug978522.html new file mode 100644 index 0000000000..b0cc4e76b9 --- /dev/null +++ b/dom/console/tests/test_bug978522.html @@ -0,0 +1,32 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=978522 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 978522 - basic support</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=978522">Mozilla Bug 978522</a> +<script type="application/javascript"> + + console.log("%s", { + toString() { + console.log("%s", { + toString() { + ok(true, "Still alive \\o/"); + SimpleTest.finish(); + return "hello world"; + }, + }); + }, + }); + + SimpleTest.waitForExplicitFinish(); + +</script> +</body> +</html> diff --git a/dom/console/tests/test_bug979109.html b/dom/console/tests/test_bug979109.html new file mode 100644 index 0000000000..231808e260 --- /dev/null +++ b/dom/console/tests/test_bug979109.html @@ -0,0 +1,32 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=979109 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 979109</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=979109">Mozilla Bug 979109</a> +<script type="application/javascript"> + + console.warn("%", "a"); + console.warn("%%", "a"); + console.warn("%123", "a"); + console.warn("%123.", "a"); + console.warn("%123.123", "a"); + console.warn("%123.123o", "a"); + console.warn("%123.123s", "a"); + console.warn("%123.123d", "a"); + console.warn("%123.123f", "a"); + console.warn("%123.123z", "a"); + console.warn("%.", "a"); + console.warn("%.123", "a"); + ok(true, "Still alive \\o/"); + +</script> +</body> +</html> diff --git a/dom/console/tests/test_bug989665.html b/dom/console/tests/test_bug989665.html new file mode 100644 index 0000000000..484656a06b --- /dev/null +++ b/dom/console/tests/test_bug989665.html @@ -0,0 +1,21 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=989665 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 989665</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=989665">Mozilla Bug 989665</a> +<script type="application/javascript"> + +let w = new Worker("data:text/javascript;charset=UTF-8, console.log('%s', {toString: function() { throw 3 }}); "); +ok(true, "This test should not crash."); + +</script> +</body> +</html> diff --git a/dom/console/tests/test_console.xhtml b/dom/console/tests/test_console.xhtml new file mode 100644 index 0000000000..cbeb9469e7 --- /dev/null +++ b/dom/console/tests/test_console.xhtml @@ -0,0 +1,35 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?> +<window title="Test for URL API" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <iframe id="iframe" /> + </body> + + <!-- test code goes here --> + <script type="application/javascript"><![CDATA[ + + ok("console" in window, "Console exists"); + window.console.log(42); + ok("table" in console, "Console has the 'table' method."); + window.console = 42; + is(window.console, 42, "Console is replacable"); + + var frame = document.getElementById("iframe"); + ok(frame, "Frame must exist"); + frame.src="http://mochi.test:8888/tests/dom/console/test/file_empty.html"; + frame.onload = function() { + ok("console" in frame.contentWindow, "Console exists in the iframe"); + frame.contentWindow.console.log(42); + frame.contentWindow.console = 42; + is(frame.contentWindow.console, 42, "Console is replacable in the iframe"); + SimpleTest.finish(); + } + + SimpleTest.waitForExplicitFinish(); + ]]></script> +</window> diff --git a/dom/console/tests/test_consoleEmptyStack.html b/dom/console/tests/test_consoleEmptyStack.html new file mode 100644 index 0000000000..ec77d0ac6f --- /dev/null +++ b/dom/console/tests/test_consoleEmptyStack.html @@ -0,0 +1,26 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="UTF-8"> + <title>Test for empty stack in console</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<script type="application/javascript"> +SimpleTest.waitForExplicitFinish(); + +window.setTimeout(console.log.bind(console), 0, "xyz"); + +window.addEventListener("fake", console.log.bind(console, "xyz")); + +window.addEventListener("fake", function() { + ok(true, "Still alive"); + SimpleTest.finish(); +}); + +window.dispatchEvent(new Event("fake")); +</script> +</pre> +</body> +</html> diff --git a/dom/console/tests/test_console_binding.html b/dom/console/tests/test_console_binding.html new file mode 100644 index 0000000000..0ec1926400 --- /dev/null +++ b/dom/console/tests/test_console_binding.html @@ -0,0 +1,40 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test Console binding</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="head.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <script type="application/javascript"> + +function consoleListener() { + addConsoleStorageListener(this); +} + +var order = 0; +consoleListener.prototype = { + observe(obj) { + ok(!obj.chromeContext, "Thils is not a chrome context"); + if (order + 1 == parseInt(obj.arguments[0])) { + ok(true, "Message received: " + obj.arguments[0]); + order++; + } + + if (order == 3) { + removeConsoleStorageListener(this); + SimpleTest.finish(); + } + }, +}; + +var cl = new consoleListener(); +SimpleTest.waitForExplicitFinish(); + +[1, 2, 3].forEach(console.log); + + </script> +</body> +</html> diff --git a/dom/console/tests/test_console_proto.html b/dom/console/tests/test_console_proto.html new file mode 100644 index 0000000000..3e9461bade --- /dev/null +++ b/dom/console/tests/test_console_proto.html @@ -0,0 +1,17 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for console.__proto__</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <script type="application/javascript"> + + isnot(Object.getPrototypeOf(console), Object.prototype, "Foo"); + is(Object.getPrototypeOf(Object.getPrototypeOf(console)), Object.prototype, "Boo"); + + </script> +</body> +</html> diff --git a/dom/console/tests/test_count.html b/dom/console/tests/test_count.html new file mode 100644 index 0000000000..5591768150 --- /dev/null +++ b/dom/console/tests/test_count.html @@ -0,0 +1,117 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for count/countReset in console</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="head.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <script type="application/javascript"> + +SimpleTest.waitForExplicitFinish(); + +function ConsoleListener() { + addConsoleStorageListener(this); +} + +ConsoleListener.prototype = { + observe(aSubject) { + let obj = aSubject.wrappedJSObject; + if (obj.arguments[0] != "test") { + return; + } + + if (!this._cb) { + ok(false, "Callback not set!"); + return; + } + + if (!this._cb(obj)) { + return; + } + + this._cb = null; + this._resolve(); + }, + + shutdown() { + removeConsoleStorageListener(this); + }, + + waitFor(cb) { + return new Promise(resolve => { + this._cb = SpecialPowers.wrapCallback(cb); + this._resolve = resolve; + }); + }, +}; + +let listener = new ConsoleListener(); + +async function runTest() { + // First count. + let cl = listener.waitFor(obj => { + return ("counter" in obj) && + ("label" in obj.counter) && + obj.counter.label == "test" && + obj.counter.count == 1; + }); + console.count("test"); + await cl; + ok(true, "Console.count == 1 received!"); + + // Second count. + cl = listener.waitFor(obj => { + return ("counter" in obj) && + ("label" in obj.counter) && + obj.counter.label == "test" && + obj.counter.count == 2; + }); + console.count("test"); + await cl; + ok(true, "Console.count == 2 received!"); + + // Counter reset. + cl = listener.waitFor(obj => { + return ("counter" in obj) && + ("label" in obj.counter) && + obj.counter.label == "test" && + obj.counter.count == 0; + }); + console.countReset("test"); + await cl; + ok(true, "Console.countReset == 0 received!"); + + // Counter reset with error. + cl = listener.waitFor(obj => { + return ("counter" in obj) && + ("label" in obj.counter) && + obj.counter.label == "test" && + obj.counter.error == "counterDoesntExist"; + }); + console.countReset("test"); + await cl; + ok(true, "Console.countReset with error received!"); + + // First again! + cl = listener.waitFor(obj => { + return ("counter" in obj) && + ("label" in obj.counter) && + obj.counter.label == "test" && + obj.counter.count == 1; + }); + console.count("test"); + await cl; + ok(true, "Console.count == 1 received!"); +} + +runTest().then(() => { + listener.shutdown(); + SimpleTest.finish(); +}); + + </script> +</body> +</html> diff --git a/dom/console/tests/test_jsm.xhtml b/dom/console/tests/test_jsm.xhtml new file mode 100644 index 0000000000..0257956393 --- /dev/null +++ b/dom/console/tests/test_jsm.xhtml @@ -0,0 +1,103 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Console + MJS" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script src="head.js"/> + + <script type="application/javascript"> + <![CDATA[ + +const MJS = "chrome://mochitests/content/chrome/dom/console/tests/console.sys.mjs"; + +let dumpCalled = 0; +function dumpFunction(msg) { + ok(msg.includes("_PREFIX_"), "we have a prefix"); + dump("Message received: " + msg); // Just for debugging + dumpCalled++; +} + +function promiseConsoleListenerCalled() { + return new Promise(resolve => { + let consoleListener = { + count: 0, + + observe(aSubject) { + var obj = aSubject.wrappedJSObject; + ok(obj.chromeContext, "MJS is always a chrome context"); + + if (obj.innerID == MJS) { + is(obj.ID, "jsm", "ID and InnerID are correctly set."); + is(obj.arguments[0], "Hello world!", "Message matches"); + is(obj.consoleID, "", "No consoleID for console API"); + is(obj.prefix, "", "prefix is empty by default"); + + // We want to see 2 messages from this innerID, the first is generated + // by console.log, the second one from createInstance().log(); + ++this.count; + } else if (obj.innerID == "CUSTOM INNER") { + is(obj.ID, "jsm", "ID and InnerID are correctly set."); + is(obj.arguments[0], "Hello world!", "Message matches"); + is(obj.consoleID, "wow", "consoleID is set by consoleInstance"); + is(obj.prefix, "_PREFIX_", "prefix is set by consoleInstance"); + // We expect to see 2 messages from this innerID. + ++this.count; + } else if (obj.innerID == "LEVEL") { + // Nothing special... just we don't want to see 'invisible' messages. + is(obj.ID, "jsm", "ID and InnerID are correctly set."); + is(obj.arguments[0], "Hello world!", "Message matches"); + is(obj.prefix, "", "prefix is empty by default"); + // We expect to see 2 messages from this innerID. + ++this.count; + } else if (obj.innerID == "NO PREF") { + // Nothing special... just we don't want to see 'invisible' messages. + is(obj.ID, "jsm", "ID and InnerID are correctly set."); + is(obj.arguments[0], "Hello world!", "Message matches"); + is(obj.prefix, "", "prefix is empty by default"); + // We expect to see 2 messages from this innerID. + ++this.count; + } + + if (this.count == 8) { + is(dumpCalled, 2, "Dump has been called!"); + removeConsoleStorageListener(consoleListener); + resolve(); + } + } + } + addConsoleStorageListener(consoleListener); + }); +} + +async function test() { + SimpleTest.waitForExplicitFinish(); + + let consolePromise = promiseConsoleListenerCalled(); + let { ConsoleTest } = ChromeUtils.importESModule(MJS); + await SpecialPowers.pushPrefEnv({set: [["pref.test.console", "log"]]}) + ConsoleTest.go(dumpFunction); + + // ConsoleTest.go() has already tested the console without this preference. + // This test checks that the addition of the preference is tracked and + // correctly applied. + await SpecialPowers.pushPrefEnv({ + set: [["pref.test.console.notset", "Log"]], + }); + ConsoleTest.go2(); + + await consolePromise; + SimpleTest.finish(); +} + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + </body> +</window> diff --git a/dom/console/tests/test_timer.html b/dom/console/tests/test_timer.html new file mode 100644 index 0000000000..fa3ca7baec --- /dev/null +++ b/dom/console/tests/test_timer.html @@ -0,0 +1,112 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for timeStart/timeLog/timeEnd in console</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="head.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <script type="application/javascript"> + +SimpleTest.waitForExplicitFinish(); + +var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); +SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); + +function ConsoleListener() { + addConsoleStorageListener(this); +} + +ConsoleListener.prototype = { + observe(aSubject) { + let obj = aSubject.wrappedJSObject; + if (obj.arguments[0] != "test_bug1463614") { + return; + } + + if (!this._cb || !this._cb(obj)) { + return; + } + + this._cb = null; + this._resolve(); + }, + + shutdown() { + removeConsoleStorageListener(this); + }, + + waitFor(cb) { + return new Promise(resolve => { + this._cb = SpecialPowers.wrapCallback(cb); + this._resolve = resolve; + }); + }, +}; + +let listener = new ConsoleListener(); + +// Timer creation: +async function runTest() { + let cl = listener.waitFor(obj => { + return ("timer" in obj) && + ("name" in obj.timer) && + obj.timer.name == "test_bug1463614"; + }); + + console.time("test_bug1463614"); + await cl; + ok(true, "Console.time received!"); + + // Timer check: + cl = listener.waitFor(obj => { + return ("timer" in obj) && + ("name" in obj.timer) && + obj.timer.name == "test_bug1463614" && + ("duration" in obj.timer) && + obj.timer.duration >= 0 && + obj.arguments[1] == 1 && + obj.arguments[2] == 2 && + obj.arguments[3] == 3 && + obj.arguments[4] == 4; + }); + console.timeLog("test_bug1463614", 1, 2, 3, 4); + await cl; + ok(true, "Console.timeLog received!"); + + // Time deleted: + cl = listener.waitFor(obj => { + return ("timer" in obj) && + ("name" in obj.timer) && + obj.timer.name == "test_bug1463614" && + ("duration" in obj.timer) && + obj.timer.duration >= 0; + }); + console.timeEnd("test_bug1463614"); + await cl; + ok(true, "Console.timeEnd received!"); + + // Here an error: + cl = listener.waitFor(obj => { + return ("timer" in obj) && + ("name" in obj.timer) && + obj.timer.name == "test_bug1463614" && + ("error" in obj.timer); + }); + console.timeLog("test_bug1463614"); + await cl; + ok(true, "Console.time with error received!"); +} + +runTest().then(() => { + listener.shutdown(); + + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); +}); + + </script> +</body> +</html> diff --git a/dom/console/tests/xpcshell/head.js b/dom/console/tests/xpcshell/head.js new file mode 100644 index 0000000000..446eb9ba9e --- /dev/null +++ b/dom/console/tests/xpcshell/head.js @@ -0,0 +1,22 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"].getService( + Ci.nsIConsoleAPIStorage +); + +// This is intended to just be a drop-in replacement for an old observer +// notification. +function addConsoleStorageListener(listener) { + listener.__handler = (message, id) => { + listener.observe(message, id); + }; + ConsoleAPIStorage.addLogEventListener( + listener.__handler, + Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal) + ); +} + +function removeConsoleStorageListener(listener) { + ConsoleAPIStorage.removeLogEventListener(listener.__handler); +} diff --git a/dom/console/tests/xpcshell/test_basic.js b/dom/console/tests/xpcshell/test_basic.js new file mode 100644 index 0000000000..5736912979 --- /dev/null +++ b/dom/console/tests/xpcshell/test_basic.js @@ -0,0 +1,29 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(async function () { + Assert.ok("console" in this); + + let p = new Promise(resolve => { + function consoleListener() { + addConsoleStorageListener(this); + } + + consoleListener.prototype = { + observe(aSubject) { + let obj = aSubject.wrappedJSObject; + Assert.ok(obj.arguments[0] === 42, "Message received!"); + Assert.ok(obj.ID === "jsm", "The ID is JSM"); + Assert.ok(obj.innerID.endsWith("test_basic.js"), "The innerID matches"); + + removeConsoleStorageListener(this); + resolve(); + }, + }; + + new consoleListener(); + }); + + console.log(42); + await p; +}); diff --git a/dom/console/tests/xpcshell/test_console_shouldLog.js b/dom/console/tests/xpcshell/test_console_shouldLog.js new file mode 100644 index 0000000000..9e78c474db --- /dev/null +++ b/dom/console/tests/xpcshell/test_console_shouldLog.js @@ -0,0 +1,35 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(async function test_shouldLog_maxLogLevel() { + let ci = console.createInstance({ maxLogLevel: "Warn" }); + + Assert.ok( + ci.shouldLog("Error"), + "Should return true for logging a higher level" + ); + Assert.ok( + ci.shouldLog("Warn"), + "Should return true for logging the same level" + ); + Assert.ok( + !ci.shouldLog("Debug"), + "Should return false for logging a lower level;" + ); +}); + +add_task(async function test_shouldLog_maxLogLevelPref() { + Services.prefs.setStringPref("test.log", "Warn"); + let ci = console.createInstance({ maxLogLevelPref: "test.log" }); + + Assert.ok( + !ci.shouldLog("Debug"), + "Should return false for logging a lower level;" + ); + + Services.prefs.setStringPref("test.log", "Debug"); + Assert.ok( + ci.shouldLog("Debug"), + "Should return true for logging a lower level after pref update" + ); +}); diff --git a/dom/console/tests/xpcshell/test_failing_console_listener.js b/dom/console/tests/xpcshell/test_failing_console_listener.js new file mode 100644 index 0000000000..bb1b7cd46c --- /dev/null +++ b/dom/console/tests/xpcshell/test_failing_console_listener.js @@ -0,0 +1,35 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(async function () { + Assert.ok("console" in this); + + // Add a first listener that synchronously throws. + const removeListener1 = addConsoleListener(() => { + throw new Error("Fail"); + }); + + // Add a second listener updating a flag we can observe from the test. + let secondListenerCalled = false; + const removeListener2 = addConsoleListener( + () => (secondListenerCalled = true) + ); + + console.log(42); + Assert.ok(secondListenerCalled, "Second listener was called"); + + // Cleanup listeners. + removeListener1(); + removeListener2(); +}); + +function addConsoleListener(callback) { + const principal = Cc["@mozilla.org/systemprincipal;1"].createInstance( + Ci.nsIPrincipal + ); + ConsoleAPIStorage.addLogEventListener(callback, principal); + + return () => { + ConsoleAPIStorage.removeLogEventListener(callback, principal); + }; +} diff --git a/dom/console/tests/xpcshell/test_formatting.js b/dom/console/tests/xpcshell/test_formatting.js new file mode 100644 index 0000000000..89d5a1947e --- /dev/null +++ b/dom/console/tests/xpcshell/test_formatting.js @@ -0,0 +1,77 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(async function () { + Assert.ok("console" in this); + + const tests = [ + // Plain value. + [[42], ["42"]], + + // Integers. + [["%d", 42], ["42"]], + [["%i", 42], ["42"]], + [["c%iao", 42], ["c42ao"]], + + // Floats. + [["%2.4f", 42], ["42.0000"]], + [["%2.2f", 42], ["42.00"]], + [["%1.2f", 42], ["42.00"]], + [["a%3.2fb", 42], ["a42.00b"]], + [["%f", NaN], ["NaN"]], + + // Strings + [["%s", 42], ["42"]], + + // Empty values. + [ + ["", 42], + ["", "42"], + ], + [ + ["", 42], + ["", "42"], + ], + ]; + + let p = new Promise(resolve => { + let t = 0; + + function consoleListener() { + addConsoleStorageListener(this); + } + + consoleListener.prototype = { + observe(aSubject) { + let test = tests[t++]; + + let obj = aSubject.wrappedJSObject; + Assert.equal( + obj.arguments.length, + test[1].length, + "Same number of arguments" + ); + for (let i = 0; i < test[1].length; ++i) { + Assert.equal( + "" + obj.arguments[i], + test[1][i], + "Message received: " + test[1][i] + ); + } + + if (t === tests.length) { + removeConsoleStorageListener(this); + resolve(); + } + }, + }; + + new consoleListener(); + }); + + tests.forEach(test => { + console.log(...test[0]); + }); + + await p; +}); diff --git a/dom/console/tests/xpcshell/test_reportForServiceWorkerScope.js b/dom/console/tests/xpcshell/test_reportForServiceWorkerScope.js new file mode 100644 index 0000000000..f96519183c --- /dev/null +++ b/dom/console/tests/xpcshell/test_reportForServiceWorkerScope.js @@ -0,0 +1,42 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(async function () { + let p = new Promise(resolve => { + function consoleListener() { + addConsoleStorageListener(this); + } + + consoleListener.prototype = { + observe(aSubject) { + let obj = aSubject.wrappedJSObject; + Assert.ok(obj.arguments[0] === "Hello world!", "Message received!"); + Assert.ok(obj.ID === "scope", "The ID is the scope"); + Assert.ok( + obj.innerID === "ServiceWorker", + "The innerID is ServiceWorker" + ); + Assert.ok(obj.filename === "filename", "The filename matches"); + Assert.ok(obj.lineNumber === 42, "The lineNumber matches"); + Assert.ok(obj.columnNumber === 24, "The columnNumber matches"); + Assert.ok(obj.level === "error", "The level is correct"); + + removeConsoleStorageListener(this); + resolve(); + }, + }; + + new consoleListener(); + }); + + let ci = console.createInstance(); + ci.reportForServiceWorkerScope( + "scope", + "Hello world!", + "filename", + 42, + 24, + "error" + ); + await p; +}); diff --git a/dom/console/tests/xpcshell/xpcshell.toml b/dom/console/tests/xpcshell/xpcshell.toml new file mode 100644 index 0000000000..c5cc54d665 --- /dev/null +++ b/dom/console/tests/xpcshell/xpcshell.toml @@ -0,0 +1,13 @@ +[DEFAULT] +head = "head.js" +support-files = "" + +["test_basic.js"] + +["test_console_shouldLog.js"] + +["test_failing_console_listener.js"] + +["test_formatting.js"] + +["test_reportForServiceWorkerScope.js"] |