js/xpconnect/loader/ChromeScriptLoader.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "PrecompiledScript.h"
   8
   9 #include "nsIIncrementalStreamLoader.h"
  10 #include "nsIURI.h"
  11 #include "nsIChannel.h"
  12 #include "nsNetUtil.h"
  13 #include "nsThreadUtils.h"
  14
  15 #include "jsapi.h"
  16 #include "jsfriendapi.h"
  17 #include "js/CompileOptions.h"  // JS::CompileOptions, JS::OwningCompileOptions
  18 #include "js/CompilationAndEvaluation.h"
  19 #include "js/experimental/CompileScript.h"  // JS::CompileGlobalScriptToStencil, JS::NewFrontendContext, JS::DestroyFrontendContext, JS::SetNativeStackQuota, JS::ThreadStackQuotaForSize, JS::HadFrontendErrors, JS::ConvertFrontendErrorsToRuntimeErrors
  20 #include "js/experimental/JSStencil.h"  // JS::Stencil, JS::CompileGlobalScriptToStencil, JS::InstantiateGlobalStencil
  21 #include "js/SourceText.h"  // JS::SourceText
  22 #include "js/Utility.h"
  23
  24 #include "mozilla/AlreadyAddRefed.h"  // already_AddRefed
  25 #include "mozilla/Assertions.h"       // MOZ_ASSERT
  26 #include "mozilla/Attributes.h"
  27 #include "mozilla/ClearOnShutdown.h"  // RunOnShutdown
  28 #include "mozilla/EventQueue.h"       // EventQueuePriority
  29 #include "mozilla/Mutex.h"
  30 #include "mozilla/SchedulerGroup.h"
  31 #include "mozilla/StaticMutex.h"
  32 #include "mozilla/StaticPrefs_javascript.h"
  33 #include "mozilla/dom/ChromeUtils.h"
  34 #include "mozilla/dom/Promise.h"
  35 #include "mozilla/dom/ScriptLoader.h"
  36 #include "mozilla/HoldDropJSObjects.h"
  37 #include "mozilla/RefPtr.h"          // RefPtr
  38 #include "mozilla/TaskController.h"  // TaskController, Task
  39 #include "mozilla/ThreadSafety.h"    // MOZ_GUARDED_BY
  40 #include "mozilla/Utf8.h"            // Utf8Unit
  41 #include "mozilla/Vector.h"
  42 #include "nsCCUncollectableMarker.h"
  43 #include "nsCycleCollectionParticipant.h"
  44
  45 using namespace JS;
  46 using namespace mozilla;
  47 using namespace mozilla::dom;
  48
  49 class AsyncScriptCompileTask final : public Task {
  50   static mozilla::StaticMutex sOngoingTasksMutex;
  51   static Vector<AsyncScriptCompileTask*> sOngoingTasks
  52       MOZ_GUARDED_BY(sOngoingTasksMutex);
  53   static bool sIsShutdownRegistered;
  54
  55   // Compilation tasks should be cancelled before calling JS_ShutDown, in order
  56   // to avoid keeping JS::Stencil and SharedImmutableString pointers alive
  57   // beyond it.
  58   //
  59   // Cancel all ongoing tasks at ShutdownPhase::XPCOMShutdownFinal, which
  60   // happens before calling JS_ShutDown.
  61   static bool RegisterTask(AsyncScriptCompileTask* aTask) {
  62     MOZ_ASSERT(NS_IsMainThread());
  63
  64     if (!sIsShutdownRegistered) {
  65       sIsShutdownRegistered = true;
  66
  67       RunOnShutdown([] {
  68         StaticMutexAutoLock lock(sOngoingTasksMutex);
  69         for (auto* task : sOngoingTasks) {
  70           task->Cancel();
  71         }
  72       });
  73     }
  74
  75     StaticMutexAutoLock lock(sOngoingTasksMutex);
  76     return sOngoingTasks.append(aTask);
  77   }
  78
  79   static void UnregisterTask(const AsyncScriptCompileTask* aTask) {
  80     StaticMutexAutoLock lock(sOngoingTasksMutex);
  81     sOngoingTasks.eraseIfEqual(aTask);
  82   }
  83
  84  public:
  85   explicit AsyncScriptCompileTask(JS::SourceText<Utf8Unit>&& aSrcBuf)
  86       : Task(Kind::OffMainThreadOnly, EventQueuePriority::Normal),
  87         mOptions(JS::OwningCompileOptions::ForFrontendContext()),
  88         mSrcBuf(std::move(aSrcBuf)),
  89         mMutex("AsyncScriptCompileTask") {}
  90
  91   ~AsyncScriptCompileTask() {
  92     if (mFrontendContext) {
  93       JS::DestroyFrontendContext(mFrontendContext);
  94     }
  95     UnregisterTask(this);
  96   }
  97
  98   bool Init(const JS::OwningCompileOptions& aOptions) {
  99     if (!RegisterTask(this)) {
 100       return false;
 101     }
 102
 103     mFrontendContext = JS::NewFrontendContext();
 104     if (!mFrontendContext) {
 105       return false;
 106     }
 107
 108     if (!mOptions.copy(mFrontendContext, aOptions)) {
 109       return false;
 110     }
 111
 112     return true;
 113   }
 114
 115  private:
 116   void Compile() {
 117     // NOTE: The stack limit must be set from the same thread that compiles.
 118     size_t stackSize = TaskController::GetThreadStackSize();
 119     JS::SetNativeStackQuota(mFrontendContext,
 120                             JS::ThreadStackQuotaForSize(stackSize));
 121
 122     mStencil =
 123         JS::CompileGlobalScriptToStencil(mFrontendContext, mOptions, mSrcBuf);
 124   }
 125
 126   // Cancel the task.
 127   // If the task is already running, this waits for the task to finish.
 128   void Cancel() {
 129     MOZ_ASSERT(NS_IsMainThread());
 130
 131     MutexAutoLock lock(mMutex);
 132
 133     mIsCancelled = true;
 134
 135     mStencil = nullptr;
 136   }
 137
 138  public:
 139   TaskResult Run() override {
 140     MutexAutoLock lock(mMutex);
 141
 142     if (mIsCancelled) {
 143       return TaskResult::Complete;
 144     }
 145
 146     Compile();
 147     return TaskResult::Complete;
 148   }
 149
 150   already_AddRefed<JS::Stencil> StealStencil(JSContext* aCx) {
 151     JS::FrontendContext* fc = mFrontendContext;
 152     mFrontendContext = nullptr;
 153
 154     MOZ_ASSERT(fc);
 155
 156     if (JS::HadFrontendErrors(fc)) {
 157       (void)JS::ConvertFrontendErrorsToRuntimeErrors(aCx, fc, mOptions);
 158       JS::DestroyFrontendContext(fc);
 159       return nullptr;
 160     }
 161
 162     // Report warnings.
 163     if (!JS::ConvertFrontendErrorsToRuntimeErrors(aCx, fc, mOptions)) {
 164       JS::DestroyFrontendContext(fc);
 165       return nullptr;
 166     }
 167
 168     JS::DestroyFrontendContext(fc);
 169
 170     return mStencil.forget();
 171   }
 172
 173 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
 174   bool GetName(nsACString& aName) override {
 175     aName.AssignLiteral("AsyncScriptCompileTask");
 176     return true;
 177   }
 178 #endif
 179
 180  private:
 181   // Owning-pointer for the context associated with the script compilation.
 182   //
 183   // The context is allocated on main thread in Init method, and is freed on
 184   // any thread in the destructor.
 185   JS::FrontendContext* mFrontendContext = nullptr;
 186
 187   JS::OwningCompileOptions mOptions;
 188
 189   RefPtr<JS::Stencil> mStencil;
 190
 191   JS::SourceText<Utf8Unit> mSrcBuf;
 192
 193   // This mutex is locked during running the task or cancelling task.
 194   mozilla::Mutex mMutex;
 195
 196   bool mIsCancelled MOZ_GUARDED_BY(mMutex) = false;
 197 };
 198
 199 /* static */ mozilla::StaticMutex AsyncScriptCompileTask::sOngoingTasksMutex;
 200 MOZ_RUNINIT /* static */ Vector<AsyncScriptCompileTask*>
 201     AsyncScriptCompileTask::sOngoingTasks;
 202 /* static */ bool AsyncScriptCompileTask::sIsShutdownRegistered = false;
 203
 204 class AsyncScriptCompiler;
 205
 206 class AsyncScriptCompilationCompleteTask : public Task {
 207  public:
 208   AsyncScriptCompilationCompleteTask(AsyncScriptCompiler* aCompiler,
 209                                      AsyncScriptCompileTask* aCompileTask)
 210       : Task(Kind::MainThreadOnly, EventQueuePriority::Normal),
 211         mCompiler(aCompiler),
 212         mCompileTask(aCompileTask) {
 213     MOZ_ASSERT(NS_IsMainThread());
 214   }
 215
 216 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
 217   bool GetName(nsACString& aName) override {
 218     aName.AssignLiteral("AsyncScriptCompilationCompleteTask");
 219     return true;
 220   }
 221 #endif
 222
 223   TaskResult Run() override;
 224
 225  private:
 226   // NOTE:
 227   // This field is main-thread only, and this task shouldn't be freed off
 228   // main thread.
 229   //
 230   // This is guaranteed by not having off-thread tasks which depends on this
 231   // task, because otherwise the off-thread task's mDependencies can be the
 232   // last reference, which results in freeing this task off main thread.
 233   //
 234   // If such task is added, this field must be moved to separate storage.
 235   RefPtr<AsyncScriptCompiler> mCompiler;
 236
 237   RefPtr<AsyncScriptCompileTask> mCompileTask;
 238 };
 239
 240 class AsyncScriptCompiler final : public nsIIncrementalStreamLoaderObserver {
 241  public:
 242   // Note: References to this class are never held by cycle-collected objects.
 243   // If at any point a reference is returned to a caller, please update this
 244   // class to implement cycle collection.
 245   NS_DECL_ISUPPORTS
 246   NS_DECL_NSIINCREMENTALSTREAMLOADEROBSERVER
 247
 248   AsyncScriptCompiler(JSContext* aCx, nsIGlobalObject* aGlobal,
 249                       const nsACString& aURL, Promise* aPromise)
 250       : mOptions(aCx),
 251         mURL(aURL),
 252         mGlobalObject(aGlobal),
 253         mPromise(aPromise),
 254         mScriptLength(0) {}
 255
 256   [[nodiscard]] nsresult Start(JSContext* aCx,
 257                                const CompileScriptOptionsDictionary& aOptions,
 258                                nsIPrincipal* aPrincipal);
 259
 260   void OnCompilationComplete(AsyncScriptCompileTask* aCompileTask);
 261
 262  protected:
 263   virtual ~AsyncScriptCompiler() {
 264     if (mPromise->State() == Promise::PromiseState::Pending) {
 265       mPromise->MaybeReject(NS_ERROR_FAILURE);
 266     }
 267   }
 268
 269  private:
 270   void Reject(JSContext* aCx);
 271   void Reject(JSContext* aCx, const char* aMxg);
 272
 273   bool StartCompile(JSContext* aCx);
 274   bool StartOffThreadCompile(JS::SourceText<Utf8Unit>&& aSrcBuf);
 275   void FinishCompile(JSContext* aCx);
 276   void Finish(JSContext* aCx, RefPtr<JS::Stencil>&& aStencil);
 277
 278   OwningCompileOptions mOptions;
 279   nsCString mURL;
 280   nsCOMPtr<nsIGlobalObject> mGlobalObject;
 281   RefPtr<Promise> mPromise;
 282   nsString mCharset;
 283   UniquePtr<Utf8Unit[], JS::FreePolicy> mScriptText;
 284   size_t mScriptLength;
 285 };
 286
 287 NS_IMPL_ISUPPORTS(AsyncScriptCompiler, nsIIncrementalStreamLoaderObserver)
 288
 289 nsresult AsyncScriptCompiler::Start(
 290     JSContext* aCx, const CompileScriptOptionsDictionary& aOptions,
 291     nsIPrincipal* aPrincipal) {
 292   mCharset = aOptions.mCharset;
 293
 294   CompileOptions options(aCx);
 295   nsAutoCString filename;
 296   if (aOptions.mFilename.WasPassed()) {
 297     filename = NS_ConvertUTF16toUTF8(aOptions.mFilename.Value());
 298     options.setFile(filename.get());
 299   } else {
 300     options.setFile(mURL.get());
 301   }
 302   options.setNoScriptRval(!aOptions.mHasReturnValue);
 303
 304   if (!aOptions.mLazilyParse) {
 305     options.setForceFullParse();
 306   }
 307
 308   if (NS_WARN_IF(!mOptions.copy(aCx, options))) {
 309     return NS_ERROR_OUT_OF_MEMORY;
 310   }
 311
 312   nsCOMPtr<nsIURI> uri;
 313   nsresult rv = NS_NewURI(getter_AddRefs(uri), mURL);
 314   NS_ENSURE_SUCCESS(rv, rv);
 315
 316   nsCOMPtr<nsIChannel> channel;
 317   rv = NS_NewChannel(
 318       getter_AddRefs(channel), uri, aPrincipal,
 319       nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
 320       nsIContentPolicy::TYPE_INTERNAL_CHROMEUTILS_COMPILED_SCRIPT);
 321   NS_ENSURE_SUCCESS(rv, rv);
 322
 323   // allow deprecated HTTP request from SystemPrincipal
 324   nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
 325   loadInfo->SetAllowDeprecatedSystemRequests(true);
 326   nsCOMPtr<nsIIncrementalStreamLoader> loader;
 327   rv = NS_NewIncrementalStreamLoader(getter_AddRefs(loader), this);
 328   NS_ENSURE_SUCCESS(rv, rv);
 329
 330   return channel->AsyncOpen(loader);
 331 }
 332
 333 bool AsyncScriptCompiler::StartCompile(JSContext* aCx) {
 334   JS::SourceText<Utf8Unit> srcBuf;
 335   if (!srcBuf.init(aCx, std::move(mScriptText), mScriptLength)) {
 336     return false;
 337   }
 338
 339   // TODO: This uses the same heuristics and the same threshold as the
 340   //       JS::CanCompileOffThread, but the heuristics needs to be updated to
 341   //       reflect the change regarding the Stencil API, and also the thread
 342   //       management on the consumer side (bug 1846388).
 343   static constexpr size_t OffThreadMinimumTextLength = 5 * 1000;
 344
 345   if (StaticPrefs::javascript_options_parallel_parsing() &&
 346       mScriptLength >= OffThreadMinimumTextLength) {
 347     if (!StartOffThreadCompile(std::move(srcBuf))) {
 348       return false;
 349     }
 350     return true;
 351   }
 352
 353   RefPtr<Stencil> stencil =
 354       JS::CompileGlobalScriptToStencil(aCx, mOptions, srcBuf);
 355   if (!stencil) {
 356     return false;
 357   }
 358
 359   Finish(aCx, std::move(stencil));
 360   return true;
 361 }
 362
 363 bool AsyncScriptCompiler::StartOffThreadCompile(
 364     JS::SourceText<Utf8Unit>&& aSrcBuf) {
 365   RefPtr<AsyncScriptCompileTask> compileTask =
 366       new AsyncScriptCompileTask(std::move(aSrcBuf));
 367
 368   RefPtr<AsyncScriptCompilationCompleteTask> complationCompleteTask =
 369       new AsyncScriptCompilationCompleteTask(this, compileTask.get());
 370
 371   if (!compileTask->Init(mOptions)) {
 372     return false;
 373   }
 374
 375   complationCompleteTask->AddDependency(compileTask.get());
 376
 377   TaskController::Get()->AddTask(compileTask.forget());
 378   TaskController::Get()->AddTask(complationCompleteTask.forget());
 379   return true;
 380 }
 381
 382 Task::TaskResult AsyncScriptCompilationCompleteTask::Run() {
 383   mCompiler->OnCompilationComplete(mCompileTask.get());
 384   mCompiler = nullptr;
 385   mCompileTask = nullptr;
 386   return TaskResult::Complete;
 387 }
 388
 389 void AsyncScriptCompiler::OnCompilationComplete(
 390     AsyncScriptCompileTask* aCompileTask) {
 391   AutoJSAPI jsapi;
 392   if (!jsapi.Init(mGlobalObject)) {
 393     mPromise->MaybeReject(NS_ERROR_FAILURE);
 394     return;
 395   }
 396
 397   JSContext* cx = jsapi.cx();
 398   RefPtr<JS::Stencil> stencil = aCompileTask->StealStencil(cx);
 399   if (!stencil) {
 400     Reject(cx);
 401     return;
 402   }
 403
 404   Finish(cx, std::move(stencil));
 405   return;
 406 }
 407
 408 void AsyncScriptCompiler::Finish(JSContext* aCx,
 409                                  RefPtr<JS::Stencil>&& aStencil) {
 410   RefPtr<PrecompiledScript> result =
 411       new PrecompiledScript(mGlobalObject, aStencil, mOptions);
 412
 413   mPromise->MaybeResolve(result);
 414 }
 415
 416 void AsyncScriptCompiler::Reject(JSContext* aCx) {
 417   RootedValue value(aCx, JS::UndefinedValue());
 418   if (JS_GetPendingException(aCx, &value)) {
 419     JS_ClearPendingException(aCx);
 420   }
 421   mPromise->MaybeReject(value);
 422 }
 423
 424 void AsyncScriptCompiler::Reject(JSContext* aCx, const char* aMsg) {
 425   nsAutoString msg;
 426   msg.AppendASCII(aMsg);
 427   msg.AppendLiteral(": ");
 428   nsDependentCString filename(mOptions.filename().c_str());
 429   AppendUTF8toUTF16(filename, msg);
 430
 431   RootedValue exn(aCx);
 432   if (xpc::NonVoidStringToJsval(aCx, msg, &exn)) {
 433     JS_SetPendingException(aCx, exn);
 434   }
 435
 436   Reject(aCx);
 437 }
 438
 439 NS_IMETHODIMP
 440 AsyncScriptCompiler::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
 441
 442 NS_IMETHODIMP
 443 AsyncScriptCompiler::OnIncrementalData(nsIIncrementalStreamLoader* aLoader,
 444                                        nsISupports* aContext,
 445                                        uint32_t aDataLength,
 446                                        const uint8_t* aData,
 447                                        uint32_t* aConsumedData) {
 448   return NS_OK;
 449 }
 450
 451 NS_IMETHODIMP
 452 AsyncScriptCompiler::OnStreamComplete(nsIIncrementalStreamLoader* aLoader,
 453                                       nsISupports* aContext, nsresult aStatus,
 454                                       uint32_t aLength, const uint8_t* aBuf) {
 455   AutoJSAPI jsapi;
 456   if (!jsapi.Init(mGlobalObject)) {
 457     mPromise->MaybeReject(NS_ERROR_FAILURE);
 458     return NS_OK;
 459   }
 460
 461   JSContext* cx = jsapi.cx();
 462
 463   if (NS_FAILED(aStatus)) {
 464     Reject(cx, "Unable to load script");
 465     return NS_OK;
 466   }
 467
 468   nsresult rv = ScriptLoader::ConvertToUTF8(
 469       nullptr, aBuf, aLength, mCharset, nullptr, mScriptText, mScriptLength);
 470   if (NS_FAILED(rv)) {
 471     Reject(cx, "Unable to decode script");
 472     return NS_OK;
 473   }
 474
 475   if (!StartCompile(cx)) {
 476     Reject(cx);
 477   }
 478
 479   return NS_OK;
 480 }
 481
 482 namespace mozilla {
 483 namespace dom {
 484
 485 /* static */
 486 already_AddRefed<Promise> ChromeUtils::CompileScript(
 487     GlobalObject& aGlobal, const nsAString& aURL,
 488     const CompileScriptOptionsDictionary& aOptions, ErrorResult& aRv) {
 489   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
 490   MOZ_ASSERT(global);
 491
 492   RefPtr<Promise> promise = Promise::Create(global, aRv);
 493   if (aRv.Failed()) {
 494     return nullptr;
 495   }
 496
 497   NS_ConvertUTF16toUTF8 url(aURL);
 498   RefPtr<AsyncScriptCompiler> compiler =
 499       new AsyncScriptCompiler(aGlobal.Context(), global, url, promise);
 500
 501   nsresult rv = compiler->Start(aGlobal.Context(), aOptions,
 502                                 aGlobal.GetSubjectPrincipal());
 503   if (NS_FAILED(rv)) {
 504     promise->MaybeReject(rv);
 505   }
 506
 507   return promise.forget();
 508 }
 509
 510 PrecompiledScript::PrecompiledScript(nsISupports* aParent,
 511                                      RefPtr<JS::Stencil> aStencil,
 512                                      JS::ReadOnlyCompileOptions& aOptions)
 513     : mParent(aParent),
 514       mStencil(aStencil),
 515       mPublicURL(aOptions.filename().c_str()),
 516       mHasReturnValue(!aOptions.noScriptRval) {
 517   MOZ_ASSERT(aParent);
 518   MOZ_ASSERT(aStencil);
 519 #ifdef DEBUG
 520   // AsyncScriptCompiler::Start can call JS::CompileOptions::setForceFullParse,
 521   // but it should be compatible with the default JS::InstantiateOptions.
 522   JS::InstantiateOptions options(aOptions);
 523   options.assertCompatibleWithDefault();
 524 #endif
 525 };
 526
 527 void PrecompiledScript::ExecuteInGlobal(JSContext* aCx, HandleObject aGlobal,
 528                                         const ExecuteInGlobalOptions& aOptions,
 529                                         MutableHandleValue aRval,
 530                                         ErrorResult& aRv) {
 531   {
 532     RootedObject targetObj(aCx, JS_FindCompilationScope(aCx, aGlobal));
 533     // Use AutoEntryScript for its ReportException method call.
 534     // This will ensure notified any exception happening in the content script
 535     // directly to the console, so that exceptions are flagged with the right
 536     // innerWindowID. It helps these exceptions to appear in the page's web
 537     // console.
 538     AutoEntryScript aes(targetObj, "pre-compiled-script execution");
 539     JSContext* cx = aes.cx();
 540
 541     // See assertion in constructor.
 542     JS::InstantiateOptions options;
 543     Rooted<JSScript*> script(
 544         cx, JS::InstantiateGlobalStencil(cx, options, mStencil));
 545     if (!script) {
 546       aRv.NoteJSContextException(aCx);
 547       return;
 548     }
 549
 550     if (!JS_ExecuteScript(cx, script, aRval)) {
 551       JS::RootedValue exn(cx);
 552       if (aOptions.mReportExceptions) {
 553         // Note that ReportException will consume the exception.
 554         aes.ReportException();
 555       } else {
 556         // Set the exception on our caller's cx.
 557         aRv.MightThrowJSException();
 558         aRv.StealExceptionFromJSContext(cx);
 559       }
 560       return;
 561     }
 562   }
 563
 564   JS_WrapValue(aCx, aRval);
 565 }
 566
 567 void PrecompiledScript::GetUrl(nsAString& aUrl) {
 568   CopyUTF8toUTF16(mPublicURL, aUrl);
 569 }
 570
 571 bool PrecompiledScript::HasReturnValue() { return mHasReturnValue; }
 572
 573 JSObject* PrecompiledScript::WrapObject(JSContext* aCx,
 574                                         HandleObject aGivenProto) {
 575   return PrecompiledScript_Binding::Wrap(aCx, this, aGivenProto);
 576 }
 577
 578 bool PrecompiledScript::IsBlackForCC(bool aTracingNeeded) {
 579   return (nsCCUncollectableMarker::sGeneration && HasKnownLiveWrapper() &&
 580           (!aTracingNeeded || HasNothingToTrace(this)));
 581 }
 582
 583 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PrecompiledScript, mParent)
 584
 585 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PrecompiledScript)
 586   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
 587   NS_INTERFACE_MAP_ENTRY(nsISupports)
 588 NS_INTERFACE_MAP_END
 589
 590 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(PrecompiledScript)
 591   return tmp->IsBlackForCC(false);
 592 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
 593
 594 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(PrecompiledScript)
 595   return tmp->IsBlackForCC(true);
 596 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
 597
 598 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(PrecompiledScript)
 599   return tmp->IsBlackForCC(false);
 600 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
 601
 602 NS_IMPL_CYCLE_COLLECTING_ADDREF(PrecompiledScript)
 603 NS_IMPL_CYCLE_COLLECTING_RELEASE(PrecompiledScript)
 604
 605 }  // namespace dom
 606 }  // namespace mozilla