Console.cpp - mozsearch

mozilla-central/dom/console/Console.cpp (file symbol)

Enable keyboard shortcuts

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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