dom/base/Console.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/Console.h"
   7 #include "mozilla/dom/ConsoleBinding.h"
   8
   9 #include "mozilla/dom/Exceptions.h"
  10 #include "mozilla/dom/ToJSValue.h"
  11 #include "mozilla/Maybe.h"
  12 #include "nsCycleCollectionParticipant.h"
  13 #include "nsDocument.h"
  14 #include "nsDOMNavigationTiming.h"
  15 #include "nsGlobalWindow.h"
  16 #include "nsJSUtils.h"
  17 #include "nsPerformance.h"
  18 #include "ScriptSettings.h"
  19 #include "WorkerPrivate.h"
  20 #include "WorkerRunnable.h"
  21 #include "xpcprivate.h"
  22 #include "nsContentUtils.h"
  23
  24 #include "nsIConsoleAPIStorage.h"
  25 #include "nsIDOMWindowUtils.h"
  26 #include "nsIInterfaceRequestorUtils.h"
  27 #include "nsILoadContext.h"
  28 #include "nsIServiceManager.h"
  29 #include "nsISupportsPrimitives.h"
  30 #include "nsIWebNavigation.h"
  31
  32 // The maximum allowed number of concurrent timers per page.
  33 #define MAX_PAGE_TIMERS 10000
  34
  35 // The maximum allowed number of concurrent counters per page.
  36 #define MAX_PAGE_COUNTERS 10000
  37
  38 // The maximum stacktrace depth when populating the stacktrace array used for
  39 // console.trace().
  40 #define DEFAULT_MAX_STACKTRACE_DEPTH 200
  41
  42 // The console API methods are async and their action is executed later. This
  43 // delay tells how much later.
  44 #define CALL_DELAY 15 // milliseconds
  45
  46 // This constant tells how many messages to process in a single timer execution.
  47 #define MESSAGES_IN_INTERVAL 1500
  48
  49 // This tag is used in the Structured Clone Algorithm to move js values from
  50 // worker thread to main thread
  51 #define CONSOLE_TAG JS_SCTAG_USER_MIN
  52
  53 using namespace mozilla::dom::exceptions;
  54 using namespace mozilla::dom::workers;
  55
  56 namespace mozilla {
  57 namespace dom {
  58
  59 /**
  60  * Console API in workers uses the Structured Clone Algorithm to move any value
  61  * from the worker thread to the main-thread. Some object cannot be moved and,
  62  * in these cases, we convert them to strings.
  63  * It's not the best, but at least we are able to show something.
  64  */
  65
  66 // This method is called by the Structured Clone Algorithm when some data has
  67 // to be read.
  68 static JSObject*
  69 ConsoleStructuredCloneCallbacksRead(JSContext* aCx,
  70                                     JSStructuredCloneReader* /* unused */,
  71                                     uint32_t aTag, uint32_t aData,
  72                                     void* aClosure)
  73 {
  74   AssertIsOnMainThread();
  75
  76   if (aTag != CONSOLE_TAG) {
  77     return nullptr;
  78   }
  79
  80   nsTArray<nsString>* strings = static_cast<nsTArray<nsString>*>(aClosure);
  81   MOZ_ASSERT(strings->Length() > aData);
  82
  83   JS::Rooted<JS::Value> value(aCx);
  84   if (!xpc::StringToJsval(aCx, strings->ElementAt(aData), &value)) {
  85     return nullptr;
  86   }
  87
  88   JS::Rooted<JSObject*> obj(aCx);
  89   if (!JS_ValueToObject(aCx, value, &obj)) {
  90     return nullptr;
  91   }
  92
  93   return obj;
  94 }
  95
  96 // This method is called by the Structured Clone Algorithm when some data has
  97 // to be written.
  98 static bool
  99 ConsoleStructuredCloneCallbacksWrite(JSContext* aCx,
 100                                      JSStructuredCloneWriter* aWriter,
 101                                      JS::Handle<JSObject*> aObj,
 102                                      void* aClosure)
 103 {
 104   JS::Rooted<JS::Value> value(aCx, JS::ObjectOrNullValue(aObj));
 105   JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, value));
 106   if (!jsString) {
 107     return false;
 108   }
 109
 110   nsAutoJSString string;
 111   if (!string.init(aCx, jsString)) {
 112     return false;
 113   }
 114
 115   nsTArray<nsString>* strings = static_cast<nsTArray<nsString>*>(aClosure);
 116
 117   if (!JS_WriteUint32Pair(aWriter, CONSOLE_TAG, strings->Length())) {
 118     return false;
 119   }
 120
 121   strings->AppendElement(string);
 122
 123   return true;
 124 }
 125
 126 static void
 127 ConsoleStructuredCloneCallbacksError(JSContext* /* aCx */,
 128                                      uint32_t /* aErrorId */)
 129 {
 130   NS_WARNING("Failed to clone data for the Console API in workers.");
 131 }
 132
 133 JSStructuredCloneCallbacks gConsoleCallbacks = {
 134   ConsoleStructuredCloneCallbacksRead,
 135   ConsoleStructuredCloneCallbacksWrite,
 136   ConsoleStructuredCloneCallbacksError
 137 };
 138
 139 class ConsoleCallData MOZ_FINAL : public LinkedListElement<ConsoleCallData>
 140 {
 141 public:
 142   ConsoleCallData()
 143     : mMethodName(Console::MethodLog)
 144     , mPrivate(false)
 145     , mTimeStamp(JS_Now() / PR_USEC_PER_MSEC)
 146     , mMonotonicTimer(0)
 147   {
 148     MOZ_COUNT_CTOR(ConsoleCallData);
 149   }
 150
 151   ~ConsoleCallData()
 152   {
 153     MOZ_COUNT_DTOR(ConsoleCallData);
 154   }
 155
 156   void
 157   Initialize(JSContext* aCx, Console::MethodName aName,
 158              const nsAString& aString, const Sequence<JS::Value>& aArguments)
 159   {
 160     mGlobal = JS::CurrentGlobalOrNull(aCx);
 161     mMethodName = aName;
 162     mMethodString = aString;
 163
 164     for (uint32_t i = 0; i < aArguments.Length(); ++i) {
 165       mArguments.AppendElement(aArguments[i]);
 166     }
 167   }
 168
 169   JS::Heap<JSObject*> mGlobal;
 170
 171   Console::MethodName mMethodName;
 172   bool mPrivate;
 173   int64_t mTimeStamp;
 174   DOMHighResTimeStamp mMonotonicTimer;
 175
 176   nsString mMethodString;
 177   nsTArray<JS::Heap<JS::Value>> mArguments;
 178
 179   // Stack management is complicated, because we want to do it as
 180   // lazily as possible.  Therefore, we have the following behavior:
 181   // 1)  mTopStackFrame is initialized whenever we have any JS on the stack
 182   // 2)  mReifiedStack is initialized if we're created in a worker.
 183   // 3)  mStack is set (possibly to null if there is no JS on the stack) if
 184   //     we're created on main thread.
 185   Maybe<ConsoleStackEntry> mTopStackFrame;
 186   Maybe<nsTArray<ConsoleStackEntry>> mReifiedStack;
 187   nsCOMPtr<nsIStackFrame> mStack;
 188 };
 189
 190 // This class is used to clear any exception at the end of this method.
 191 class ClearException
 192 {
 193 public:
 194   explicit ClearException(JSContext* aCx)
 195     : mCx(aCx)
 196   {
 197   }
 198
 199   ~ClearException()
 200   {
 201     JS_ClearPendingException(mCx);
 202   }
 203
 204 private:
 205   JSContext* mCx;
 206 };
 207
 208 class ConsoleRunnable : public nsRunnable
 209 {
 210 public:
 211   ConsoleRunnable()
 212     : mWorkerPrivate(GetCurrentThreadWorkerPrivate())
 213   {
 214     MOZ_ASSERT(mWorkerPrivate);
 215   }
 216
 217   virtual
 218   ~ConsoleRunnable()
 219   {
 220   }
 221
 222   bool
 223   Dispatch()
 224   {
 225     mWorkerPrivate->AssertIsOnWorkerThread();
 226
 227     JSContext* cx = mWorkerPrivate->GetJSContext();
 228
 229     if (!PreDispatch(cx)) {
 230       return false;
 231     }
 232
 233     AutoSyncLoopHolder syncLoop(mWorkerPrivate);
 234     mSyncLoopTarget = syncLoop.EventTarget();
 235
 236     if (NS_FAILED(NS_DispatchToMainThread(this))) {
 237       JS_ReportError(cx,
 238                      "Failed to dispatch to main thread for the Console API!");
 239       return false;
 240     }
 241
 242     return syncLoop.Run();
 243   }
 244
 245 private:
 246   NS_IMETHOD Run()
 247   {
 248     AssertIsOnMainThread();
 249
 250     RunConsole();
 251
 252     nsRefPtr<MainThreadStopSyncLoopRunnable> response =
 253       new MainThreadStopSyncLoopRunnable(mWorkerPrivate,
 254                                          mSyncLoopTarget.forget(),
 255                                          true);
 256     if (!response->Dispatch(nullptr)) {
 257       NS_WARNING("Failed to dispatch response!");
 258     }
 259
 260     return NS_OK;
 261   }
 262
 263 protected:
 264   virtual bool
 265   PreDispatch(JSContext* aCx) = 0;
 266
 267   virtual void
 268   RunConsole() = 0;
 269
 270   WorkerPrivate* mWorkerPrivate;
 271
 272 private:
 273   nsCOMPtr<nsIEventTarget> mSyncLoopTarget;
 274 };
 275
 276 // This runnable appends a CallData object into the Console queue running on
 277 // the main-thread.
 278 class ConsoleCallDataRunnable MOZ_FINAL : public ConsoleRunnable
 279 {
 280 public:
 281   explicit ConsoleCallDataRunnable(ConsoleCallData* aCallData)
 282     : mCallData(aCallData)
 283   {
 284   }
 285
 286 private:
 287   bool
 288   PreDispatch(JSContext* aCx) MOZ_OVERRIDE
 289   {
 290     ClearException ce(aCx);
 291     JSAutoCompartment ac(aCx, mCallData->mGlobal);
 292
 293     JS::Rooted<JSObject*> arguments(aCx,
 294       JS_NewArrayObject(aCx, mCallData->mArguments.Length()));
 295     if (!arguments) {
 296       return false;
 297     }
 298
 299     JS::Rooted<JS::Value> arg(aCx);
 300     for (uint32_t i = 0; i < mCallData->mArguments.Length(); ++i) {
 301       arg = mCallData->mArguments[i];
 302       if (!JS_DefineElement(aCx, arguments, i, arg, JSPROP_ENUMERATE)) {
 303         return false;
 304       }
 305     }
 306
 307     JS::Rooted<JS::Value> value(aCx, JS::ObjectValue(*arguments));
 308
 309     if (!mArguments.write(aCx, value, &gConsoleCallbacks, &mStrings)) {
 310       return false;
 311     }
 312
 313     mCallData->mArguments.Clear();
 314     mCallData->mGlobal = nullptr;
 315     return true;
 316   }
 317
 318   void
 319   RunConsole() MOZ_OVERRIDE
 320   {
 321     // Walk up to our containing page
 322     WorkerPrivate* wp = mWorkerPrivate;
 323     while (wp->GetParent()) {
 324       wp = wp->GetParent();
 325     }
 326
 327     nsPIDOMWindow* window = wp->GetWindow();
 328     NS_ENSURE_TRUE_VOID(window);
 329
 330     nsRefPtr<nsGlobalWindow> win = static_cast<nsGlobalWindow*>(window);
 331     NS_ENSURE_TRUE_VOID(win);
 332
 333     AutoJSAPI jsapi;
 334     if (NS_WARN_IF(!jsapi.Init(win))) {
 335       return;
 336     }
 337     JSContext* cx = jsapi.cx();
 338     ClearException ce(cx);
 339
 340     ErrorResult error;
 341     nsRefPtr<Console> console = win->GetConsole(error);
 342     if (error.Failed()) {
 343       NS_WARNING("Failed to get console from the window.");
 344       return;
 345     }
 346
 347     JS::Rooted<JS::Value> argumentsValue(cx);
 348     if (!mArguments.read(cx, &argumentsValue, &gConsoleCallbacks, &mStrings)) {
 349       return;
 350     }
 351
 352     MOZ_ASSERT(argumentsValue.isObject());
 353     JS::Rooted<JSObject*> argumentsObj(cx, &argumentsValue.toObject());
 354     MOZ_ASSERT(JS_IsArrayObject(cx, argumentsObj));
 355
 356     uint32_t length;
 357     if (!JS_GetArrayLength(cx, argumentsObj, &length)) {
 358       return;
 359     }
 360
 361     for (uint32_t i = 0; i < length; ++i) {
 362       JS::Rooted<JS::Value> value(cx);
 363
 364       if (!JS_GetElement(cx, argumentsObj, i, &value)) {
 365         return;
 366       }
 367
 368       mCallData->mArguments.AppendElement(value);
 369     }
 370
 371     MOZ_ASSERT(mCallData->mArguments.Length() == length);
 372
 373     mCallData->mGlobal = JS::CurrentGlobalOrNull(cx);
 374     console->AppendCallData(mCallData.forget());
 375   }
 376
 377 private:
 378   nsAutoPtr<ConsoleCallData> mCallData;
 379
 380   JSAutoStructuredCloneBuffer mArguments;
 381   nsTArray<nsString> mStrings;
 382 };
 383
 384 // This runnable calls ProfileMethod() on the console on the main-thread.
 385 class ConsoleProfileRunnable MOZ_FINAL : public ConsoleRunnable
 386 {
 387 public:
 388   ConsoleProfileRunnable(const nsAString& aAction,
 389                          const Sequence<JS::Value>& aArguments)
 390     : mAction(aAction)
 391     , mArguments(aArguments)
 392   {
 393   }
 394
 395 private:
 396   bool
 397   PreDispatch(JSContext* aCx) MOZ_OVERRIDE
 398   {
 399     ClearException ce(aCx);
 400
 401     JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
 402     if (!global) {
 403       return false;
 404     }
 405
 406     JSAutoCompartment ac(aCx, global);
 407
 408     JS::Rooted<JSObject*> arguments(aCx,
 409       JS_NewArrayObject(aCx, mArguments.Length()));
 410     if (!arguments) {
 411       return false;
 412     }
 413
 414     JS::Rooted<JS::Value> arg(aCx);
 415     for (uint32_t i = 0; i < mArguments.Length(); ++i) {
 416       arg = mArguments[i];
 417       if (!JS_DefineElement(aCx, arguments, i, arg, JSPROP_ENUMERATE)) {
 418         return false;
 419       }
 420     }
 421
 422     JS::Rooted<JS::Value> value(aCx, JS::ObjectValue(*arguments));
 423
 424     if (!mBuffer.write(aCx, value, &gConsoleCallbacks, &mStrings)) {
 425       return false;
 426     }
 427
 428     return true;
 429   }
 430
 431   void
 432   RunConsole() MOZ_OVERRIDE
 433   {
 434     // Walk up to our containing page
 435     WorkerPrivate* wp = mWorkerPrivate;
 436     while (wp->GetParent()) {
 437       wp = wp->GetParent();
 438     }
 439
 440     nsPIDOMWindow* window = wp->GetWindow();
 441     NS_ENSURE_TRUE_VOID(window);
 442
 443     nsRefPtr<nsGlobalWindow> win = static_cast<nsGlobalWindow*>(window);
 444     NS_ENSURE_TRUE_VOID(win);
 445
 446     AutoJSAPI jsapi;
 447     if (NS_WARN_IF(!jsapi.Init(win))) {
 448       return;
 449     }
 450     JSContext* cx = jsapi.cx();
 451     ClearException ce(cx);
 452
 453     ErrorResult error;
 454     nsRefPtr<Console> console = win->GetConsole(error);
 455     if (error.Failed()) {
 456       NS_WARNING("Failed to get console from the window.");
 457       return;
 458     }
 459
 460     JS::Rooted<JS::Value> argumentsValue(cx);
 461     if (!mBuffer.read(cx, &argumentsValue, &gConsoleCallbacks, &mStrings)) {
 462       return;
 463     }
 464
 465     MOZ_ASSERT(argumentsValue.isObject());
 466     JS::Rooted<JSObject*> argumentsObj(cx, &argumentsValue.toObject());
 467     MOZ_ASSERT(JS_IsArrayObject(cx, argumentsObj));
 468
 469     uint32_t length;
 470     if (!JS_GetArrayLength(cx, argumentsObj, &length)) {
 471       return;
 472     }
 473
 474     Sequence<JS::Value> arguments;
 475
 476     for (uint32_t i = 0; i < length; ++i) {
 477       JS::Rooted<JS::Value> value(cx);
 478
 479       if (!JS_GetElement(cx, argumentsObj, i, &value)) {
 480         return;
 481       }
 482
 483       arguments.AppendElement(value);
 484     }
 485
 486     console->ProfileMethod(cx, mAction, arguments);
 487   }
 488
 489 private:
 490   nsString mAction;
 491   Sequence<JS::Value> mArguments;
 492
 493   JSAutoStructuredCloneBuffer mBuffer;
 494   nsTArray<nsString> mStrings;
 495 };
 496
 497 NS_IMPL_CYCLE_COLLECTION_CLASS(Console)
 498
 499 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Console)
 500   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
 501   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTimer)
 502   NS_IMPL_CYCLE_COLLECTION_UNLINK(mStorage)
 503   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
 504
 505   tmp->ClearConsoleData();
 506
 507 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 508
 509 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Console)
 510   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow)
 511   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTimer)
 512   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStorage)
 513   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
 514 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 515
 516 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Console)
 517   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
 518
 519   for (ConsoleCallData* data = tmp->mQueuedCalls.getFirst(); data != nullptr;
 520        data = data->getNext()) {
 521     if (data->mGlobal) {
 522       aCallbacks.Trace(&data->mGlobal, "data->mGlobal", aClosure);
 523     }
 524
 525     for (uint32_t i = 0; i < data->mArguments.Length(); ++i) {
 526       aCallbacks.Trace(&data->mArguments[i], "data->mArguments[i]", aClosure);
 527     }
 528   }
 529
 530 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 531
 532 NS_IMPL_CYCLE_COLLECTING_ADDREF(Console)
 533 NS_IMPL_CYCLE_COLLECTING_RELEASE(Console)
 534
 535 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Console)
 536   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
 537   NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
 538   NS_INTERFACE_MAP_ENTRY(nsIObserver)
 539   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITimerCallback)
 540 NS_INTERFACE_MAP_END
 541
 542 Console::Console(nsPIDOMWindow* aWindow)
 543   : mWindow(aWindow)
 544   , mOuterID(0)
 545   , mInnerID(0)
 546 {
 547   if (mWindow) {
 548     MOZ_ASSERT(mWindow->IsInnerWindow());
 549     mInnerID = mWindow->WindowID();
 550
 551     nsPIDOMWindow* outerWindow = mWindow->GetOuterWindow();
 552     MOZ_ASSERT(outerWindow);
 553     mOuterID = outerWindow->WindowID();
 554   }
 555
 556   if (NS_IsMainThread()) {
 557     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 558     if (obs) {
 559       obs->AddObserver(this, "inner-window-destroyed", false);
 560     }
 561   }
 562
 563   SetIsDOMBinding();
 564   mozilla::HoldJSObjects(this);
 565 }
 566
 567 Console::~Console()
 568 {
 569   mozilla::DropJSObjects(this);
 570 }
 571
 572 NS_IMETHODIMP
 573 Console::Observe(nsISupports* aSubject, const char* aTopic,
 574                  const char16_t* aData)
 575 {
 576   MOZ_ASSERT(NS_IsMainThread());
 577
 578   if (strcmp(aTopic, "inner-window-destroyed")) {
 579     return NS_OK;
 580   }
 581
 582   nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
 583   NS_ENSURE_TRUE(wrapper, NS_ERROR_FAILURE);
 584
 585   uint64_t innerID;
 586   nsresult rv = wrapper->GetData(&innerID);
 587   NS_ENSURE_SUCCESS(rv, rv);
 588
 589   if (innerID == mInnerID) {
 590     nsCOMPtr<nsIObserverService> obs =
 591       do_GetService("@mozilla.org/observer-service;1");
 592     if (obs) {
 593       obs->RemoveObserver(this, "inner-window-destroyed");
 594     }
 595
 596     ClearConsoleData();
 597     mTimerRegistry.Clear();
 598
 599     if (mTimer) {
 600       mTimer->Cancel();
 601       mTimer = nullptr;
 602     }
 603   }
 604
 605   return NS_OK;
 606 }
 607
 608 JSObject*
 609 Console::WrapObject(JSContext* aCx)
 610 {
 611   return ConsoleBinding::Wrap(aCx, this);
 612 }
 613
 614 #define METHOD(name, string)                                          \
 615   void                                                                \
 616   Console::name(JSContext* aCx, const Sequence<JS::Value>& aData)     \
 617   {                                                                   \
 618     Method(aCx, Method##name, NS_LITERAL_STRING(string), aData);      \
 619   }
 620
 621 METHOD(Log, "log")
 622 METHOD(Info, "info")
 623 METHOD(Warn, "warn")
 624 METHOD(Error, "error")
 625 METHOD(Exception, "exception")
 626 METHOD(Debug, "debug")
 627 METHOD(Table, "table")
 628
 629 void
 630 Console::Trace(JSContext* aCx)
 631 {
 632   const Sequence<JS::Value> data;
 633   Method(aCx, MethodTrace, NS_LITERAL_STRING("trace"), data);
 634 }
 635
 636 // Displays an interactive listing of all the properties of an object.
 637 METHOD(Dir, "dir");
 638
 639 METHOD(Group, "group")
 640 METHOD(GroupCollapsed, "groupCollapsed")
 641 METHOD(GroupEnd, "groupEnd")
 642
 643 void
 644 Console::Time(JSContext* aCx, const JS::Handle<JS::Value> aTime)
 645 {
 646   Sequence<JS::Value> data;
 647   SequenceRooter<JS::Value> rooter(aCx, &data);
 648
 649   if (!aTime.isUndefined()) {
 650     data.AppendElement(aTime);
 651   }
 652
 653   Method(aCx, MethodTime, NS_LITERAL_STRING("time"), data);
 654 }
 655
 656 void
 657 Console::TimeEnd(JSContext* aCx, const JS::Handle<JS::Value> aTime)
 658 {
 659   Sequence<JS::Value> data;
 660   SequenceRooter<JS::Value> rooter(aCx, &data);
 661
 662   if (!aTime.isUndefined()) {
 663     data.AppendElement(aTime);
 664   }
 665
 666   Method(aCx, MethodTimeEnd, NS_LITERAL_STRING("timeEnd"), data);
 667 }
 668
 669 void
 670 Console::Profile(JSContext* aCx, const Sequence<JS::Value>& aData)
 671 {
 672   ProfileMethod(aCx, NS_LITERAL_STRING("profile"), aData);
 673 }
 674
 675 void
 676 Console::ProfileEnd(JSContext* aCx, const Sequence<JS::Value>& aData)
 677 {
 678   ProfileMethod(aCx, NS_LITERAL_STRING("profileEnd"), aData);
 679 }
 680
 681 void
 682 Console::ProfileMethod(JSContext* aCx, const nsAString& aAction,
 683                        const Sequence<JS::Value>& aData)
 684 {
 685   if (!NS_IsMainThread()) {
 686     // Here we are in a worker thread.
 687     nsRefPtr<ConsoleProfileRunnable> runnable =
 688       new ConsoleProfileRunnable(aAction, aData);
 689     runnable->Dispatch();
 690     return;
 691   }
 692
 693   ClearException ce(aCx);
 694
 695   RootedDictionary<ConsoleProfileEvent> event(aCx);
 696   event.mAction = aAction;
 697
 698   event.mArguments.Construct();
 699   Sequence<JS::Value>& sequence = event.mArguments.Value();
 700
 701   for (uint32_t i = 0; i < aData.Length(); ++i) {
 702     sequence.AppendElement(aData[i]);
 703   }
 704
 705   JS::Rooted<JS::Value> eventValue(aCx);
 706   if (!ToJSValue(aCx, event, &eventValue)) {
 707     return;
 708   }
 709
 710   JS::Rooted<JSObject*> eventObj(aCx, &eventValue.toObject());
 711   MOZ_ASSERT(eventObj);
 712
 713   if (!JS_DefineProperty(aCx, eventObj, "wrappedJSObject", eventValue,
 714       JSPROP_ENUMERATE)) {
 715     return;
 716   }
 717
 718   nsXPConnect*  xpc = nsXPConnect::XPConnect();
 719   nsCOMPtr<nsISupports> wrapper;
 720   const nsIID& iid = NS_GET_IID(nsISupports);
 721
 722   if (NS_FAILED(xpc->WrapJS(aCx, eventObj, iid, getter_AddRefs(wrapper)))) {
 723     return;
 724   }
 725
 726   nsCOMPtr<nsIObserverService> obs =
 727     do_GetService("@mozilla.org/observer-service;1");
 728   if (obs) {
 729     obs->NotifyObservers(wrapper, "console-api-profiler", nullptr);
 730   }
 731 }
 732
 733 void
 734 Console::Assert(JSContext* aCx, bool aCondition,
 735                 const Sequence<JS::Value>& aData)
 736 {
 737   if (!aCondition) {
 738     Method(aCx, MethodAssert, NS_LITERAL_STRING("assert"), aData);
 739   }
 740 }
 741
 742 METHOD(Count, "count")
 743
 744 void
 745 Console::__noSuchMethod__()
 746 {
 747   // Nothing to do.
 748 }
 749
 750 static
 751 nsresult
 752 StackFrameToStackEntry(nsIStackFrame* aStackFrame,
 753                        ConsoleStackEntry& aStackEntry,
 754                        uint32_t aLanguage)
 755 {
 756   MOZ_ASSERT(aStackFrame);
 757
 758   nsresult rv = aStackFrame->GetFilename(aStackEntry.mFilename);
 759   NS_ENSURE_SUCCESS(rv, rv);
 760
 761   int32_t lineNumber;
 762   rv = aStackFrame->GetLineNumber(&lineNumber);
 763   NS_ENSURE_SUCCESS(rv, rv);
 764
 765   aStackEntry.mLineNumber = lineNumber;
 766
 767   rv = aStackFrame->GetName(aStackEntry.mFunctionName);
 768   NS_ENSURE_SUCCESS(rv, rv);
 769
 770   aStackEntry.mLanguage = aLanguage;
 771   return NS_OK;
 772 }
 773
 774 static
 775 nsresult
 776 ReifyStack(nsIStackFrame* aStack, nsTArray<ConsoleStackEntry>& aRefiedStack)
 777 {
 778   nsCOMPtr<nsIStackFrame> stack(aStack);
 779
 780   while (stack) {
 781     uint32_t language;
 782     nsresult rv = stack->GetLanguage(&language);
 783     NS_ENSURE_SUCCESS(rv, rv);
 784
 785     if (language == nsIProgrammingLanguage::JAVASCRIPT ||
 786         language == nsIProgrammingLanguage::JAVASCRIPT2) {
 787       ConsoleStackEntry& data = *aRefiedStack.AppendElement();
 788       rv = StackFrameToStackEntry(stack, data, language);
 789       NS_ENSURE_SUCCESS(rv, rv);
 790     }
 791
 792     nsCOMPtr<nsIStackFrame> caller;
 793     rv = stack->GetCaller(getter_AddRefs(caller));
 794     NS_ENSURE_SUCCESS(rv, rv);
 795
 796     stack.swap(caller);
 797   }
 798
 799   return NS_OK;
 800 }
 801
 802 // Queue a call to a console method. See the CALL_DELAY constant.
 803 void
 804 Console::Method(JSContext* aCx, MethodName aMethodName,
 805                 const nsAString& aMethodString,
 806                 const Sequence<JS::Value>& aData)
 807 {
 808   // This RAII class removes the last element of the mQueuedCalls if something
 809   // goes wrong.
 810   class RAII {
 811   public:
 812     explicit RAII(LinkedList<ConsoleCallData>& aList)
 813       : mList(aList)
 814       , mUnfinished(true)
 815     {
 816     }
 817
 818     ~RAII()
 819     {
 820       if (mUnfinished) {
 821         ConsoleCallData* data = mList.popLast();
 822         MOZ_ASSERT(data);
 823         delete data;
 824       }
 825     }
 826
 827     void
 828     Finished()
 829     {
 830       mUnfinished = false;
 831     }
 832
 833   private:
 834     LinkedList<ConsoleCallData>& mList;
 835     bool mUnfinished;
 836   };
 837
 838   ConsoleCallData* callData = new ConsoleCallData();
 839   mQueuedCalls.insertBack(callData);
 840
 841   ClearException ce(aCx);
 842
 843   callData->Initialize(aCx, aMethodName, aMethodString, aData);
 844   RAII raii(mQueuedCalls);
 845
 846   if (mWindow) {
 847     nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(mWindow);
 848     if (!webNav) {
 849       return;
 850     }
 851
 852     nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(webNav);
 853     MOZ_ASSERT(loadContext);
 854
 855     loadContext->GetUsePrivateBrowsing(&callData->mPrivate);
 856   }
 857
 858   uint32_t maxDepth = ShouldIncludeStackrace(aMethodName) ?
 859                       DEFAULT_MAX_STACKTRACE_DEPTH : 1;
 860   nsCOMPtr<nsIStackFrame> stack = CreateStack(aCx, maxDepth);
 861
 862   if (!stack) {
 863     return;
 864   }
 865
 866   // Walk up to the first JS stack frame and save it if we find it.
 867   do {
 868     uint32_t language;
 869     nsresult rv = stack->GetLanguage(&language);
 870     if (NS_FAILED(rv)) {
 871       return;
 872     }
 873
 874     if (language == nsIProgrammingLanguage::JAVASCRIPT ||
 875         language == nsIProgrammingLanguage::JAVASCRIPT2) {
 876       callData->mTopStackFrame.emplace();
 877       nsresult rv = StackFrameToStackEntry(stack,
 878                                            *callData->mTopStackFrame,
 879                                            language);
 880       if (NS_FAILED(rv)) {
 881         return;
 882       }
 883
 884       break;
 885     }
 886
 887     nsCOMPtr<nsIStackFrame> caller;
 888     rv = stack->GetCaller(getter_AddRefs(caller));
 889     if (NS_FAILED(rv)) {
 890       return;
 891     }
 892
 893     stack.swap(caller);
 894   } while (stack);
 895
 896   if (NS_IsMainThread()) {
 897     callData->mStack = stack;
 898   } else {
 899     // nsIStackFrame is not threadsafe, so we need to snapshot it now,
 900     // before we post our runnable to the main thread.
 901     callData->mReifiedStack.emplace();
 902     nsresult rv = ReifyStack(stack, *callData->mReifiedStack);
 903     if (NS_WARN_IF(NS_FAILED(rv))) {
 904       return;
 905     }
 906   }
 907
 908   // Monotonic timer for 'time' and 'timeEnd'
 909   if ((aMethodName == MethodTime || aMethodName == MethodTimeEnd)) {
 910     if (mWindow) {
 911       nsGlobalWindow *win = static_cast<nsGlobalWindow*>(mWindow.get());
 912       MOZ_ASSERT(win);
 913
 914       ErrorResult rv;
 915       nsRefPtr<nsPerformance> performance = win->GetPerformance(rv);
 916       if (rv.Failed() || !performance) {
 917         return;
 918       }
 919
 920       callData->mMonotonicTimer = performance->Now();
 921     } else {
 922       WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
 923       MOZ_ASSERT(workerPrivate);
 924
 925       TimeDuration duration =
 926         mozilla::TimeStamp::Now() - workerPrivate->CreationTimeStamp();
 927
 928       callData->mMonotonicTimer = duration.ToMilliseconds();
 929     }
 930   }
 931
 932   // The operation is completed. RAII class has to be disabled.
 933   raii.Finished();
 934
 935   if (!NS_IsMainThread()) {
 936     // Here we are in a worker thread. The ConsoleCallData has to been removed
 937     // from the list and it will be deleted by the ConsoleCallDataRunnable or
 938     // by the Main-Thread Console object.
 939     mQueuedCalls.popLast();
 940
 941     nsRefPtr<ConsoleCallDataRunnable> runnable =
 942       new ConsoleCallDataRunnable(callData);
 943     runnable->Dispatch();
 944     return;
 945   }
 946
 947   if (!mTimer) {
 948     mTimer = do_CreateInstance("@mozilla.org/timer;1");
 949     mTimer->InitWithCallback(this, CALL_DELAY,
 950                              nsITimer::TYPE_REPEATING_SLACK);
 951   }
 952 }
 953
 954 void
 955 Console::AppendCallData(ConsoleCallData* aCallData)
 956 {
 957   mQueuedCalls.insertBack(aCallData);
 958
 959   if (!mTimer) {
 960     mTimer = do_CreateInstance("@mozilla.org/timer;1");
 961     mTimer->InitWithCallback(this, CALL_DELAY,
 962                              nsITimer::TYPE_REPEATING_SLACK);
 963   }
 964 }
 965
 966 // Timer callback used to process each of the queued calls.
 967 NS_IMETHODIMP
 968 Console::Notify(nsITimer *timer)
 969 {
 970   MOZ_ASSERT(!mQueuedCalls.isEmpty());
 971
 972   for (uint32_t i = 0; i < MESSAGES_IN_INTERVAL; ++i) {
 973     ConsoleCallData* data = mQueuedCalls.popFirst();
 974     if (!data) {
 975       break;
 976     }
 977
 978     ProcessCallData(data);
 979     delete data;
 980   }
 981
 982   if (mQueuedCalls.isEmpty() && mTimer) {
 983     mTimer->Cancel();
 984     mTimer = nullptr;
 985   }
 986
 987   return NS_OK;
 988 }
 989
 990 // We store information to lazily compute the stack in the reserved slots of
 991 // LazyStackGetter.  The first slot always stores a JS object: it's either the
 992 // JS wrapper of the nsIStackFrame or the actual reified stack representation.
 993 // The second slot is a PrivateValue() holding an nsIStackFrame* when we haven't
 994 // reified the stack yet, or an UndefinedValue() otherwise.
 995 enum {
 996   SLOT_STACKOBJ,
 997   SLOT_RAW_STACK
 998 };
 999
1000 bool
1001 LazyStackGetter(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
1002 {
1003   JS::CallArgs args = CallArgsFromVp(aArgc, aVp);
1004   JS::Rooted<JSObject*> callee(aCx, &args.callee());
1005
1006   JS::Value v = js::GetFunctionNativeReserved(&args.callee(), SLOT_RAW_STACK);
1007   if (v.isUndefined()) {
1008     // Already reified.
1009     args.rval().set(js::GetFunctionNativeReserved(callee, SLOT_STACKOBJ));
1010     return true;
1011   }
1012
1013   nsIStackFrame* stack = reinterpret_cast<nsIStackFrame*>(v.toPrivate());
1014   nsTArray<ConsoleStackEntry> reifiedStack;
1015   nsresult rv = ReifyStack(stack, reifiedStack);
1016   if (NS_FAILED(rv)) {
1017     Throw(aCx, rv);
1018     return false;
1019   }
1020
1021   JS::Rooted<JS::Value> stackVal(aCx);
1022   if (!ToJSValue(aCx, reifiedStack, &stackVal)) {
1023     return false;
1024   }
1025
1026   MOZ_ASSERT(stackVal.isObject());
1027
1028   js::SetFunctionNativeReserved(callee, SLOT_STACKOBJ, stackVal);
1029   js::SetFunctionNativeReserved(callee, SLOT_RAW_STACK, JS::UndefinedValue());
1030
1031   args.rval().set(stackVal);
1032   return true;
1033 }
1034
1035 void
1036 Console::ProcessCallData(ConsoleCallData* aData)
1037 {
1038   MOZ_ASSERT(aData);
1039   MOZ_ASSERT(NS_IsMainThread());
1040
1041   ConsoleStackEntry frame;
1042   if (aData->mTopStackFrame) {
1043     frame = *aData->mTopStackFrame;
1044   }
1045
1046   AutoSafeJSContext cx;
1047   ClearException ce(cx);
1048   RootedDictionary<ConsoleEvent> event(cx);
1049
1050   JSAutoCompartment ac(cx, aData->mGlobal);
1051
1052   event.mID.Construct();
1053   event.mInnerID.Construct();
1054   if (mWindow) {
1055     event.mID.Value().SetAsUnsignedLong() = mOuterID;
1056     event.mInnerID.Value().SetAsUnsignedLong() = mInnerID;
1057   } else {
1058     // If we are in a JSM, the window doesn't exist.
1059     event.mID.Value().SetAsString() = NS_LITERAL_STRING("jsm");
1060     event.mInnerID.Value().SetAsString() = frame.mFilename;
1061   }
1062
1063   event.mLevel = aData->mMethodString;
1064   event.mFilename = frame.mFilename;
1065   event.mLineNumber = frame.mLineNumber;
1066   event.mFunctionName = frame.mFunctionName;
1067   event.mTimeStamp = aData->mTimeStamp;
1068   event.mPrivate = aData->mPrivate;
1069
1070   switch (aData->mMethodName) {
1071     case MethodLog:
1072     case MethodInfo:
1073     case MethodWarn:
1074     case MethodError:
1075     case MethodException:
1076     case MethodDebug:
1077     case MethodAssert:
1078       event.mArguments.Construct();
1079       event.mStyles.Construct();
1080       ProcessArguments(cx, aData->mArguments, event.mArguments.Value(),
1081                        event.mStyles.Value());
1082       break;
1083
1084     default:
1085       event.mArguments.Construct();
1086       ArgumentsToValueList(aData->mArguments, event.mArguments.Value());
1087   }
1088
1089   if (aData->mMethodName == MethodGroup ||
1090       aData->mMethodName == MethodGroupCollapsed ||
1091       aData->mMethodName == MethodGroupEnd) {
1092     ComposeGroupName(cx, aData->mArguments, event.mGroupName);
1093   }
1094
1095   else if (aData->mMethodName == MethodTime && !aData->mArguments.IsEmpty()) {
1096     event.mTimer = StartTimer(cx, aData->mArguments[0], aData->mMonotonicTimer);
1097   }
1098
1099   else if (aData->mMethodName == MethodTimeEnd && !aData->mArguments.IsEmpty()) {
1100     event.mTimer = StopTimer(cx, aData->mArguments[0], aData->mMonotonicTimer);
1101   }
1102
1103   else if (aData->mMethodName == MethodCount) {
1104     event.mCounter = IncreaseCounter(cx, frame, aData->mArguments);
1105   }
1106
1107   // We want to create a console event object and pass it to our
1108   // nsIConsoleAPIStorage implementation.  We want to define some accessor
1109   // properties on this object, and those will need to keep an nsIStackFrame
1110   // alive.  But nsIStackFrame cannot be wrapped in an untrusted scope.  And
1111   // further, passing untrusted objects to system code is likely to run afoul of
1112   // Object Xrays.  So we want to wrap in a system-principal scope here.  But
1113   // which one?  We could cheat and try to get the underlying JSObject* of
1114   // mStorage, but that's a bit fragile.  Instead, we just use the junk scope,
1115   // with explicit permission from the XPConnect module owner.  If you're
1116   // tempted to do that anywhere else, talk to said module owner first.
1117   JSAutoCompartment ac2(cx, xpc::PrivilegedJunkScope());
1118
1119   JS::Rooted<JS::Value> eventValue(cx);
1120   if (!ToJSValue(cx, event, &eventValue)) {
1121     return;
1122   }
1123
1124   JS::Rooted<JSObject*> eventObj(cx, &eventValue.toObject());
1125   MOZ_ASSERT(eventObj);
1126
1127   if (!JS_DefineProperty(cx, eventObj, "wrappedJSObject", eventValue, JSPROP_ENUMERATE)) {
1128     return;
1129   }
1130
1131   if (ShouldIncludeStackrace(aData->mMethodName)) {
1132     // Now define the "stacktrace" property on eventObj.  There are two cases
1133     // here.  Either we came from a worker and have a reified stack, or we want
1134     // to define a getter that will lazily reify the stack.
1135     if (aData->mReifiedStack) {
1136       JS::Rooted<JS::Value> stacktrace(cx);
1137       if (!ToJSValue(cx, *aData->mReifiedStack, &stacktrace) ||
1138           !JS_DefineProperty(cx, eventObj, "stacktrace", stacktrace,
1139                              JSPROP_ENUMERATE)) {
1140         return;
1141       }
1142     } else {
1143       JSFunction* fun = js::NewFunctionWithReserved(cx, LazyStackGetter, 0, 0,
1144                                                     eventObj, "stacktrace");
1145       if (!fun) {
1146         return;
1147       }
1148
1149       JS::Rooted<JSObject*> funObj(cx, JS_GetFunctionObject(fun));
1150
1151       // We want to store our stack in the function and have it stay alive.  But
1152       // we also need sane access to the C++ nsIStackFrame.  So store both a JS
1153       // wrapper and the raw pointer: the former will keep the latter alive.
1154       JS::Rooted<JS::Value> stackVal(cx);
1155       nsresult rv = nsContentUtils::WrapNative(cx, aData->mStack,
1156                                                &stackVal);
1157       if (NS_FAILED(rv)) {
1158         return;
1159       }
1160
1161       js::SetFunctionNativeReserved(funObj, SLOT_STACKOBJ, stackVal);
1162       js::SetFunctionNativeReserved(funObj, SLOT_RAW_STACK,
1163                                     JS::PrivateValue(aData->mStack.get()));
1164
1165       if (!JS_DefineProperty(cx, eventObj, "stacktrace",
1166                              JS::UndefinedHandleValue,
1167                              JSPROP_ENUMERATE | JSPROP_SHARED | JSPROP_GETTER |
1168                              JSPROP_SETTER,
1169                              JS_DATA_TO_FUNC_PTR(JSPropertyOp, funObj.get()),
1170                              nullptr)) {
1171         return;
1172       }
1173     }
1174   }
1175
1176   if (!mStorage) {
1177     mStorage = do_GetService("@mozilla.org/consoleAPI-storage;1");
1178   }
1179
1180   if (!mStorage) {
1181     NS_WARNING("Failed to get the ConsoleAPIStorage service.");
1182     return;
1183   }
1184
1185   nsAutoString innerID;
1186   innerID.AppendInt(mInnerID);
1187
1188   if (NS_FAILED(mStorage->RecordEvent(innerID, eventValue))) {
1189     NS_WARNING("Failed to record a console event.");
1190   }
1191
1192   nsXPConnect*  xpc = nsXPConnect::XPConnect();
1193   nsCOMPtr<nsISupports> wrapper;
1194   const nsIID& iid = NS_GET_IID(nsISupports);
1195
1196   if (NS_FAILED(xpc->WrapJS(cx, eventObj, iid, getter_AddRefs(wrapper)))) {
1197     return;
1198   }
1199
1200   nsCOMPtr<nsIObserverService> obs =
1201     do_GetService("@mozilla.org/observer-service;1");
1202   if (obs) {
1203     nsAutoString outerID;
1204     outerID.AppendInt(mOuterID);
1205
1206     obs->NotifyObservers(wrapper, "console-api-log-event", outerID.get());
1207   }
1208 }
1209
1210 void
1211 Console::ProcessArguments(JSContext* aCx,
1212                           const nsTArray<JS::Heap<JS::Value>>& aData,
1213                           Sequence<JS::Value>& aSequence,
1214                           Sequence<JS::Value>& aStyles)
1215 {
1216   if (aData.IsEmpty()) {
1217     return;
1218   }
1219
1220   if (aData.Length() == 1 || !aData[0].isString()) {
1221     ArgumentsToValueList(aData, aSequence);
1222     return;
1223   }
1224
1225   JS::Rooted<JS::Value> format(aCx, aData[0]);
1226   JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, format));
1227   if (!jsString) {
1228     return;
1229   }
1230
1231   nsAutoJSString string;
1232   if (!string.init(aCx, jsString)) {
1233     return;
1234   }
1235
1236   nsString::const_iterator start, end;
1237   string.BeginReading(start);
1238   string.EndReading(end);
1239
1240   nsString output;
1241   uint32_t index = 1;
1242
1243   while (start != end) {
1244     if (*start != '%') {
1245       output.Append(*start);
1246       ++start;
1247       continue;
1248     }
1249
1250     ++start;
1251     if (start == end) {
1252       output.Append('%');
1253       break;
1254     }
1255
1256     if (*start == '%') {
1257       output.Append(*start);
1258       ++start;
1259       continue;
1260     }
1261
1262     nsAutoString tmp;
1263     tmp.Append('%');
1264
1265     int32_t integer = -1;
1266     int32_t mantissa = -1;
1267
1268     // Let's parse %<number>.<number> for %d and %f
1269     if (*start >= '0' && *start <= '9') {
1270       integer = 0;
1271
1272       do {
1273         integer = integer * 10 + *start - '0';
1274         tmp.Append(*start);
1275         ++start;
1276       } while (*start >= '0' && *start <= '9' && start != end);
1277     }
1278
1279     if (start == end) {
1280       output.Append(tmp);
1281       break;
1282     }
1283
1284     if (*start == '.') {
1285       tmp.Append(*start);
1286       ++start;
1287
1288       if (start == end) {
1289         output.Append(tmp);
1290         break;
1291       }
1292
1293       // '.' must be followed by a number.
1294       if (*start < '0' || *start > '9') {
1295         output.Append(tmp);
1296         continue;
1297       }
1298
1299       mantissa = 0;
1300
1301       do {
1302         mantissa = mantissa * 10 + *start - '0';
1303         tmp.Append(*start);
1304         ++start;
1305       } while (*start >= '0' && *start <= '9' && start != end);
1306
1307       if (start == end) {
1308         output.Append(tmp);
1309         break;
1310       }
1311     }
1312
1313     char ch = *start;
1314     tmp.Append(ch);
1315     ++start;
1316
1317     switch (ch) {
1318       case 'o':
1319       case 'O':
1320       {
1321         if (!output.IsEmpty()) {
1322           JS::Rooted<JSString*> str(aCx, JS_NewUCStringCopyN(aCx,
1323                                                              output.get(),
1324                                                              output.Length()));
1325           if (!str) {
1326             return;
1327           }
1328
1329           aSequence.AppendElement(JS::StringValue(str));
1330           output.Truncate();
1331         }
1332
1333         JS::Rooted<JS::Value> v(aCx);
1334         if (index < aData.Length()) {
1335           v = aData[index++];
1336         }
1337
1338         aSequence.AppendElement(v);
1339         break;
1340       }
1341
1342       case 'c':
1343       {
1344         if (!output.IsEmpty()) {
1345           JS::Rooted<JSString*> str(aCx, JS_NewUCStringCopyN(aCx,
1346                                                              output.get(),
1347                                                              output.Length()));
1348           if (!str) {
1349             return;
1350           }
1351
1352           aSequence.AppendElement(JS::StringValue(str));
1353           output.Truncate();
1354         }
1355
1356         if (index < aData.Length()) {
1357           JS::Rooted<JS::Value> v(aCx, aData[index++]);
1358           JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, v));
1359           if (!jsString) {
1360             return;
1361           }
1362
1363           int32_t diff = aSequence.Length() - aStyles.Length();
1364           if (diff > 0) {
1365             for (int32_t i = 0; i < diff; i++) {
1366               aStyles.AppendElement(JS::NullValue());
1367             }
1368           }
1369           aStyles.AppendElement(JS::StringValue(jsString));
1370         }
1371         break;
1372       }
1373
1374       case 's':
1375         if (index < aData.Length()) {
1376           JS::Rooted<JS::Value> value(aCx, aData[index++]);
1377           JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, value));
1378           if (!jsString) {
1379             return;
1380           }
1381
1382           nsAutoJSString v;
1383           if (!v.init(aCx, jsString)) {
1384             return;
1385           }
1386
1387           output.Append(v);
1388         }
1389         break;
1390
1391       case 'd':
1392       case 'i':
1393         if (index < aData.Length()) {
1394           JS::Rooted<JS::Value> value(aCx, aData[index++]);
1395
1396           int32_t v;
1397           if (!JS::ToInt32(aCx, value, &v)) {
1398             return;
1399           }
1400
1401           nsCString format;
1402           MakeFormatString(format, integer, mantissa, 'd');
1403           output.AppendPrintf(format.get(), v);
1404         }
1405         break;
1406
1407       case 'f':
1408         if (index < aData.Length()) {
1409           JS::Rooted<JS::Value> value(aCx, aData[index++]);
1410
1411           double v;
1412           if (!JS::ToNumber(aCx, value, &v)) {
1413             return;
1414           }
1415
1416           nsCString format;
1417           MakeFormatString(format, integer, mantissa, 'f');
1418           output.AppendPrintf(format.get(), v);
1419         }
1420         break;
1421
1422       default:
1423         output.Append(tmp);
1424         break;
1425     }
1426   }
1427
1428   if (!output.IsEmpty()) {
1429     JS::Rooted<JSString*> str(aCx, JS_NewUCStringCopyN(aCx, output.get(),
1430                                                        output.Length()));
1431     if (!str) {
1432       return;
1433     }
1434
1435     aSequence.AppendElement(JS::StringValue(str));
1436   }
1437
1438   // The rest of the array, if unused by the format string.
1439   for (; index < aData.Length(); ++index) {
1440     aSequence.AppendElement(aData[index]);
1441   }
1442 }
1443
1444 void
1445 Console::MakeFormatString(nsCString& aFormat, int32_t aInteger,
1446                           int32_t aMantissa, char aCh)
1447 {
1448   aFormat.Append('%');
1449   if (aInteger >= 0) {
1450     aFormat.AppendInt(aInteger);
1451   }
1452
1453   if (aMantissa >= 0) {
1454     aFormat.Append('.');
1455     aFormat.AppendInt(aMantissa);
1456   }
1457
1458   aFormat.Append(aCh);
1459 }
1460
1461 void
1462 Console::ComposeGroupName(JSContext* aCx,
1463                           const nsTArray<JS::Heap<JS::Value>>& aData,
1464                           nsAString& aName)
1465 {
1466   for (uint32_t i = 0; i < aData.Length(); ++i) {
1467     if (i != 0) {
1468       aName.AppendASCII(" ");
1469     }
1470
1471     JS::Rooted<JS::Value> value(aCx, aData[i]);
1472     JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, value));
1473     if (!jsString) {
1474       return;
1475     }
1476
1477     nsAutoJSString string;
1478     if (!string.init(aCx, jsString)) {
1479       return;
1480     }
1481
1482     aName.Append(string);
1483   }
1484 }
1485
1486 JS::Value
1487 Console::StartTimer(JSContext* aCx, const JS::Value& aName,
1488                     DOMHighResTimeStamp aTimestamp)
1489 {
1490   if (mTimerRegistry.Count() >= MAX_PAGE_TIMERS) {
1491     RootedDictionary<ConsoleTimerError> error(aCx);
1492
1493     JS::Rooted<JS::Value> value(aCx);
1494     if (!ToJSValue(aCx, error, &value)) {
1495       return JS::UndefinedValue();
1496     }
1497
1498     return value;
1499   }
1500
1501   RootedDictionary<ConsoleTimerStart> timer(aCx);
1502
1503   JS::Rooted<JS::Value> name(aCx, aName);
1504   JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, name));
1505   if (!jsString) {
1506     return JS::UndefinedValue();
1507   }
1508
1509   nsAutoJSString key;
1510   if (!key.init(aCx, jsString)) {
1511     return JS::UndefinedValue();
1512   }
1513
1514   timer.mName = key;
1515
1516   DOMHighResTimeStamp entry;
1517   if (!mTimerRegistry.Get(key, &entry)) {
1518     mTimerRegistry.Put(key, aTimestamp);
1519   } else {
1520     aTimestamp = entry;
1521   }
1522
1523   timer.mStarted = aTimestamp;
1524
1525   JS::Rooted<JS::Value> value(aCx);
1526   if (!ToJSValue(aCx, timer, &value)) {
1527     return JS::UndefinedValue();
1528   }
1529
1530   return value;
1531 }
1532
1533 JS::Value
1534 Console::StopTimer(JSContext* aCx, const JS::Value& aName,
1535                    DOMHighResTimeStamp aTimestamp)
1536 {
1537   JS::Rooted<JS::Value> name(aCx, aName);
1538   JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, name));
1539   if (!jsString) {
1540     return JS::UndefinedValue();
1541   }
1542
1543   nsAutoJSString key;
1544   if (!key.init(aCx, jsString)) {
1545     return JS::UndefinedValue();
1546   }
1547
1548   DOMHighResTimeStamp entry;
1549   if (!mTimerRegistry.Get(key, &entry)) {
1550     return JS::UndefinedValue();
1551   }
1552
1553   mTimerRegistry.Remove(key);
1554
1555   RootedDictionary<ConsoleTimerEnd> timer(aCx);
1556   timer.mName = key;
1557   timer.mDuration = aTimestamp - entry;
1558
1559   JS::Rooted<JS::Value> value(aCx);
1560   if (!ToJSValue(aCx, timer, &value)) {
1561     return JS::UndefinedValue();
1562   }
1563
1564   return value;
1565 }
1566
1567 void
1568 Console::ArgumentsToValueList(const nsTArray<JS::Heap<JS::Value>>& aData,
1569                               Sequence<JS::Value>& aSequence)
1570 {
1571   for (uint32_t i = 0; i < aData.Length(); ++i) {
1572     aSequence.AppendElement(aData[i]);
1573   }
1574 }
1575
1576 JS::Value
1577 Console::IncreaseCounter(JSContext* aCx, const ConsoleStackEntry& aFrame,
1578                           const nsTArray<JS::Heap<JS::Value>>& aArguments)
1579 {
1580   ClearException ce(aCx);
1581
1582   nsAutoString key;
1583   nsAutoString label;
1584
1585   if (!aArguments.IsEmpty()) {
1586     JS::Rooted<JS::Value> labelValue(aCx, aArguments[0]);
1587     JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, labelValue));
1588
1589     nsAutoJSString string;
1590     if (jsString && string.init(aCx, jsString)) {
1591       label = string;
1592       key = string;
1593     }
1594   }
1595
1596   if (key.IsEmpty()) {
1597     key.Append(aFrame.mFilename);
1598     key.Append(':');
1599     key.AppendInt(aFrame.mLineNumber);
1600   }
1601
1602   uint32_t count = 0;
1603   if (!mCounterRegistry.Get(key, &count)) {
1604     if (mCounterRegistry.Count() >= MAX_PAGE_COUNTERS) {
1605       RootedDictionary<ConsoleCounterError> error(aCx);
1606
1607       JS::Rooted<JS::Value> value(aCx);
1608       if (!ToJSValue(aCx, error, &value)) {
1609         return JS::UndefinedValue();
1610       }
1611
1612       return value;
1613     }
1614   }
1615
1616   ++count;
1617   mCounterRegistry.Put(key, count);
1618
1619   RootedDictionary<ConsoleCounter> data(aCx);
1620   data.mLabel = label;
1621   data.mCount = count;
1622
1623   JS::Rooted<JS::Value> value(aCx);
1624   if (!ToJSValue(aCx, data, &value)) {
1625     return JS::UndefinedValue();
1626   }
1627
1628   return value;
1629 }
1630
1631 void
1632 Console::ClearConsoleData()
1633 {
1634   while (ConsoleCallData* data = mQueuedCalls.popFirst()) {
1635     delete data;
1636   }
1637 }
1638
1639 bool
1640 Console::ShouldIncludeStackrace(MethodName aMethodName)
1641 {
1642   switch (aMethodName) {
1643     case MethodError:
1644     case MethodException:
1645     case MethodAssert:
1646     case MethodTrace:
1647       return true;
1648     default:
1649       return false;
1650   }
1651 }
1652
1653 } // namespace dom
1654 } // namespace mozilla