Backed out 2 changesets (bug 1510226) for causing xpcshell crashes and xpcshell failures in test_TelemetrySession.js CLOSED TREE

Mihai Alexandru Michis · Mihai Alexandru Michis · commit 4e1448e7e681 · 2019-09-25T04:25:07.000+03:00
Backed out changeset cb739de6606d (bug 1510226) Backed out changeset b6f670610dc3 (bug 1510226)
diff --git a/dom/canvas/ImageBitmap.cpp b/dom/canvas/ImageBitmap.cpp
@@ -1083,11 +1083,11 @@ class CreateImageBitmapFromBlob final : public CancelableRunnable,
         mCropRect(aCropRect),
         mOriginalCropRect(aCropRect),
         mMainThreadEventTarget(aMainThreadEventTarget),
-        mThread(PR_GetCurrentThread()) {}
+        mThread(GetCurrentVirtualThread()) {}
 
   virtual ~CreateImageBitmapFromBlob() {}
 
-  bool IsCurrentThread() const { return mThread == PR_GetCurrentThread(); }
+  bool IsCurrentThread() const { return mThread == GetCurrentVirtualThread(); }
 
   // Called on the owning thread.
   nsresult StartMimeTypeAndDecodeAndCropBlob();
diff --git a/dom/indexedDB/ActorsParent.cpp b/dom/indexedDB/ActorsParent.cpp
@@ -5147,7 +5147,7 @@ struct ConnectionPool::DatabaseInfo final {
 
   void AssertIsOnConnectionThread() const {
     MOZ_ASSERT(mDEBUGConnectionThread);
-    MOZ_ASSERT(PR_GetCurrentThread() == mDEBUGConnectionThread);
+    MOZ_ASSERT(GetCurrentPhysicalThread() == mDEBUGConnectionThread);
   }
 
   uint64_t TotalTransactionCount() const {
@@ -10904,7 +10904,7 @@ nsresult ConnectionPool::GetOrCreateConnection(
                    NS_ConvertUTF16toUTF8(aDatabase->FilePath()).get()));
 
 #ifdef DEBUG
-    dbInfo->mDEBUGConnectionThread = PR_GetCurrentThread();
+    dbInfo->mDEBUGConnectionThread = GetCurrentPhysicalThread();
 #endif
   }
 
diff --git a/dom/media/MediaManager.cpp b/dom/media/MediaManager.cpp
@@ -4072,7 +4072,7 @@ void SourceListener::Activate(RefPtr<MediaDevice> aAudioDevice,
   MOZ_ASSERT(!mStopped, "Cannot activate stopped source listener");
   MOZ_ASSERT(!Activated(), "Already activated");
 
-  mMainThreadCheck = PR_GetCurrentThread();
+  mMainThreadCheck = GetCurrentVirtualThread();
   if (aAudioDevice) {
     bool offWhileDisabled =
         aAudioDevice->GetMediaSource() == MediaSourceEnum::Microphone &&
diff --git a/ipc/glue/MessageChannel.cpp b/ipc/glue/MessageChannel.cpp
@@ -829,7 +829,7 @@ bool MessageChannel::Open(Transport* aTransport, MessageLoop* aIOLoop,
 
   mMonitor = new RefCountedMonitor();
   mWorkerLoop = MessageLoop::current();
-  mWorkerThread = PR_GetCurrentThread();
+  mWorkerThread = GetCurrentVirtualThread();
   mWorkerLoop->AddDestructionObserver(this);
   mListener->OnIPCChannelOpened();
 
@@ -910,7 +910,7 @@ void MessageChannel::OnOpenAsSlave(MessageChannel* aTargetChan, Side aSide) {
 void MessageChannel::CommonThreadOpenInit(MessageChannel* aTargetChan,
                                           Side aSide) {
   mWorkerLoop = MessageLoop::current();
-  mWorkerThread = PR_GetCurrentThread();
+  mWorkerThread = GetCurrentVirtualThread();
   mWorkerLoop->AddDestructionObserver(this);
   mListener->OnIPCChannelOpened();
 
diff --git a/ipc/glue/MessageChannel.h b/ipc/glue/MessageChannel.h
@@ -544,7 +544,7 @@ class MessageChannel : HasResultCodes, MessageLoop::DestructionObserver {
   // Can be run on either thread
   void AssertWorkerThread() const {
     MOZ_ASSERT(mWorkerThread, "Channel hasn't been opened yet");
-    MOZ_RELEASE_ASSERT(mWorkerThread == PR_GetCurrentThread(),
+    MOZ_RELEASE_ASSERT(mWorkerThread == GetCurrentVirtualThread(),
                        "not on worker thread!");
   }
 
@@ -562,7 +562,7 @@ class MessageChannel : HasResultCodes, MessageLoop::DestructionObserver {
     // If we aren't a same-thread channel, our "link" thread is _not_ our
     // worker thread!
     MOZ_ASSERT(mWorkerThread, "Channel hasn't been opened yet");
-    MOZ_RELEASE_ASSERT(mWorkerThread != PR_GetCurrentThread(),
+    MOZ_RELEASE_ASSERT(mWorkerThread != GetCurrentVirtualThread(),
                        "on worker thread but should not be!");
   }
 
diff --git a/tools/fuzzing/ipc/ProtocolFuzzer.cpp b/tools/fuzzing/ipc/ProtocolFuzzer.cpp
@@ -24,7 +24,7 @@ mozilla::dom::ContentParent* ProtocolFuzzerHelper::CreateContentParent(
     mozilla::dom::ContentParent* aOpener, const nsAString& aRemoteType) {
   auto* cp = new mozilla::dom::ContentParent(aOpener, aRemoteType);
   // TODO: this duplicates MessageChannel::Open
-  cp->GetIPCChannel()->mWorkerThread = PR_GetCurrentThread();
+  cp->GetIPCChannel()->mWorkerThread = GetCurrentVirtualThread();
   cp->GetIPCChannel()->mMonitor = new RefCountedMonitor();
   return cp;
 }
diff --git a/xpcom/base/nsISupportsImpl.cpp b/xpcom/base/nsISupportsImpl.cpp
@@ -32,7 +32,7 @@ nsresult NS_FASTCALL NS_TableDrivenQI(void* aThis, REFNSIID aIID,
 }
 
 #ifdef MOZ_THREAD_SAFETY_OWNERSHIP_CHECKS_SUPPORTED
-nsAutoOwningThread::nsAutoOwningThread() : mThread(PR_GetCurrentThread()) {}
+nsAutoOwningThread::nsAutoOwningThread() : mThread(GetCurrentVirtualThread()) {}
 
 void nsAutoOwningThread::AssertCurrentThreadOwnsMe(const char* msg) const {
   if (MOZ_UNLIKELY(!IsCurrentThread())) {
@@ -42,6 +42,6 @@ void nsAutoOwningThread::AssertCurrentThreadOwnsMe(const char* msg) const {
 }
 
 bool nsAutoOwningThread::IsCurrentThread() const {
-  return mThread == PR_GetCurrentThread();
+  return mThread == GetCurrentVirtualThread();
 }
 #endif
diff --git a/xpcom/threads/TaskQueue.cpp b/xpcom/threads/TaskQueue.cpp
@@ -164,7 +164,7 @@ bool TaskQueue::IsEmpty() {
 }
 
 bool TaskQueue::IsCurrentThreadIn() const {
-  bool in = mRunningThread == PR_GetCurrentThread();
+  bool in = mRunningThread == GetCurrentPhysicalThread();
   return in;
 }
 
diff --git a/xpcom/threads/TaskQueue.h b/xpcom/threads/TaskQueue.h
@@ -156,13 +156,13 @@ class TaskQueue : public AbstractThread {
       sCurrentThreadTLS.set(aQueue);
 
       MOZ_ASSERT(mQueue->mRunningThread == nullptr);
-      mQueue->mRunningThread = PR_GetCurrentThread();
+      mQueue->mRunningThread = GetCurrentPhysicalThread();
     }
 
     ~AutoTaskGuard() {
       DrainDirectTasks();
 
-      MOZ_ASSERT(mQueue->mRunningThread == PR_GetCurrentThread());
+      MOZ_ASSERT(mQueue->mRunningThread == GetCurrentPhysicalThread());
       mQueue->mRunningThread = nullptr;
 
       sCurrentThreadTLS.set(mLastCurrentThread);
diff --git a/xpcom/threads/ThreadEventTarget.cpp b/xpcom/threads/ThreadEventTarget.cpp
@@ -89,11 +89,11 @@ NS_IMPL_ISUPPORTS_INHERITED(DelayedRunnable, Runnable, nsITimerCallback)
 ThreadEventTarget::ThreadEventTarget(ThreadTargetSink* aSink,
                                      bool aIsMainThread)
     : mSink(aSink), mIsMainThread(aIsMainThread) {
-  mThread = PR_GetCurrentThread();
+  mVirtualThread = GetCurrentVirtualThread();
 }
 
-void ThreadEventTarget::SetCurrentThread(PRThread* aThread) {
-  mThread = aThread;
+void ThreadEventTarget::SetCurrentThread() {
+  mVirtualThread = GetCurrentVirtualThread();
 }
 
 NS_IMPL_ISUPPORTS(ThreadEventTarget, nsIEventTarget, nsISerialEventTarget)
@@ -185,6 +185,6 @@ ThreadEventTarget::IsOnCurrentThread(bool* aIsOnCurrentThread) {
 
 NS_IMETHODIMP_(bool)
 ThreadEventTarget::IsOnCurrentThreadInfallible() {
-  // Rely on mThread being correct.
+  // Rely on mVirtualThread being correct.
   MOZ_CRASH("IsOnCurrentThreadInfallible should never be called on nsIThread");
 }
diff --git a/xpcom/threads/ThreadEventTarget.h b/xpcom/threads/ThreadEventTarget.h
@@ -30,7 +30,7 @@ class ThreadEventTarget final : public nsISerialEventTarget {
 
   // Sets the thread for which IsOnCurrentThread returns true to the current
   // thread.
-  void SetCurrentThread(PRThread* aThread);
+  void SetCurrentThread();
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
     size_t n = 0;
diff --git a/xpcom/threads/nsIEventTarget.idl b/xpcom/threads/nsIEventTarget.idl
@@ -9,7 +9,6 @@
 %{C++
 #include "nsCOMPtr.h"
 #include "mozilla/AlreadyAddRefed.h"
-#include "mozilla/Atomics.h"
 %}
 
 native alreadyAddRefed_nsIRunnable(already_AddRefed<nsIRunnable>);
@@ -70,8 +69,8 @@ interface nsIEventTarget : nsISupports
    *
    * The infallible version of IsOnCurrentThread() is optimized to avoid a
    * virtual call for non-thread event targets. Thread targets should set
-   * mThread to their virtual PRThread. Non-thread targets should leave
-   * mThread null and implement IsOnCurrentThreadInfallible() to
+   * mVirtualThread to their virtual PRThread. Non-thread targets should leave
+   * mVirtualThread null and implement IsOnCurrentThreadInfallible() to
    * return the correct answer.
    *
    * The fallible version of IsOnCurrentThread may return errors, such as during
@@ -82,16 +81,13 @@ interface nsIEventTarget : nsISupports
   %{C++
 public:
   // Infallible. Defined in nsThreadUtils.cpp. Delegates to
-  // IsOnCurrentThreadInfallible when mThread is null.
+  // IsOnCurrentThreadInfallible when mVirtualThread is null.
   bool IsOnCurrentThread();
 
 protected:
-  // This can be written from multiple threads on thread creation, which would
-  // technically be UB even though they are writing the same value if it's not
-  // marked as atomic.
-  mozilla::Atomic<PRThread*> mThread;
+  PRThread* mVirtualThread;
 
-  nsIEventTarget() : mThread(nullptr) {}
+  nsIEventTarget() : mVirtualThread(nullptr) {}
   %}
   // Note that this method is protected.  We define it through IDL, rather than
   // in a %{C++ block, to ensure that the correct method indices are recorded
diff --git a/xpcom/threads/nsThread.cpp b/xpcom/threads/nsThread.cpp
@@ -203,6 +203,39 @@ NS_INTERFACE_MAP_END
 NS_IMPL_CI_INTERFACE_GETTER(nsThread, nsIThread, nsIThreadInternal,
                             nsIEventTarget, nsISupportsPriority)
 
+//-----------------------------------------------------------------------------
+
+class nsThreadStartupEvent final : public Runnable {
+ public:
+  nsThreadStartupEvent()
+      : Runnable("nsThreadStartupEvent"),
+        mMon("nsThreadStartupEvent.mMon"),
+        mInitialized(false) {}
+
+  // This method does not return until the thread startup object is in the
+  // completion state.
+  void Wait() {
+    ReentrantMonitorAutoEnter mon(mMon);
+    while (!mInitialized) {
+      mon.Wait();
+    }
+  }
+
+ private:
+  ~nsThreadStartupEvent() = default;
+
+  NS_IMETHOD Run() override {
+    ReentrantMonitorAutoEnter mon(mMon);
+    mInitialized = true;
+    mon.Notify();
+    return NS_OK;
+  }
+
+  ReentrantMonitor mMon;
+  bool mInitialized;
+};
+//-----------------------------------------------------------------------------
+
 struct nsThreadShutdownContext {
   nsThreadShutdownContext(NotNull<nsThread*> aTerminatingThread,
                           NotNull<nsThread*> aJoiningThread,
@@ -325,7 +358,7 @@ namespace {
 
 struct ThreadInitData {
   nsThread* thread;
-  nsCString name;
+  const nsACString& name;
 };
 
 }  // namespace
@@ -378,16 +411,15 @@ void nsThread::MaybeRemoveFromThreadList() {
 void nsThread::ThreadFunc(void* aArg) {
   using mozilla::ipc::BackgroundChild;
 
-  UniquePtr<ThreadInitData> initData(static_cast<ThreadInitData*>(aArg));
+  ThreadInitData* initData = static_cast<ThreadInitData*>(aArg);
   nsThread* self = initData->thread;  // strong reference
 
   MOZ_ASSERT(self->mEventTarget);
   MOZ_ASSERT(self->mEvents);
 
-  // Note: see the comment in nsThread::Init, where we set these same values.
-  MOZ_ASSERT(!self->mThread || (self->mThread == PR_GetCurrentThread()));
   self->mThread = PR_GetCurrentThread();
-  self->mEventTarget->SetCurrentThread(self->mThread);
+  self->mVirtualThread = GetCurrentVirtualThread();
+  self->mEventTarget->SetCurrentThread();
   SetupCurrentThreadForChaosMode();
 
   if (!initData->name.IsEmpty()) {
@@ -408,6 +440,15 @@ void nsThread::ThreadFunc(void* aArg) {
     PROFILER_REGISTER_THREAD(initData->name.BeginReading());
   }
 
+  // Wait for and process startup event
+  nsCOMPtr<nsIRunnable> event = self->mEvents->GetEvent(true, nullptr);
+  MOZ_ASSERT(event);
+
+  initData = nullptr;  // clear before unblocking nsThread::Init
+
+  event->Run();  // unblocks nsThread::Init
+  event = nullptr;
+
   {
     // Scope for MessageLoop.
     nsAutoPtr<MessageLoop> loop(
@@ -449,9 +490,7 @@ void nsThread::ThreadFunc(void* aArg) {
   NotNull<nsThreadShutdownContext*> context =
       WrapNotNull(self->mShutdownContext);
   MOZ_ASSERT(context->mTerminatingThread == self);
-
-  nsCOMPtr<nsIRunnable> event =
-      do_QueryObject(new nsThreadShutdownAckEvent(context));
+  event = do_QueryObject(new nsThreadShutdownAckEvent(context));
   if (context->mIsMainThreadJoining) {
     SystemGroup::Dispatch(TaskCategory::Other, event.forget());
   } else {
@@ -555,6 +594,7 @@ nsThread::nsThread(NotNull<SynchronizedEventQueue*> aQueue,
           new ThreadEventTarget(mEvents.get(), aMainThread == MAIN_THREAD)),
       mShutdownContext(nullptr),
       mScriptObserver(nullptr),
+      mThread(nullptr),
       mStackSize(aStackSize),
       mNestedEventLoopDepth(0),
       mCurrentEventLoopDepth(MaxValue<uint32_t>::value),
@@ -577,6 +617,7 @@ nsThread::nsThread()
       mEventTarget(nullptr),
       mShutdownContext(nullptr),
       mScriptObserver(nullptr),
+      mThread(nullptr),
       mStackSize(0),
       mNestedEventLoopDepth(0),
       mCurrentEventLoopDepth(MaxValue<uint32_t>::value),
@@ -617,36 +658,41 @@ nsThread::~nsThread() {
 nsresult nsThread::Init(const nsACString& aName) {
   MOZ_ASSERT(mEvents);
   MOZ_ASSERT(mEventTarget);
-  MOZ_ASSERT(!mThread);
+
+  // spawn thread and wait until it is fully setup
+  RefPtr<nsThreadStartupEvent> startup = new nsThreadStartupEvent();
 
   NS_ADDREF_THIS();
 
   mShutdownRequired = true;
 
-  ThreadInitData* initData = new ThreadInitData{this, nsCString(aName)};
+  ThreadInitData initData = {this, aName};
 
-  PRThread* thread = nullptr;
   // ThreadFunc is responsible for setting mThread
-  if (!(thread = PR_CreateThread(PR_USER_THREAD, ThreadFunc, initData,
-                                 PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
-                                 PR_JOINABLE_THREAD, mStackSize))) {
-    delete initData;
+  if (!PR_CreateThread(PR_USER_THREAD, ThreadFunc, &initData,
+                       PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD,
+                       mStackSize)) {
     NS_RELEASE_THIS();
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
-  // Note: we set these both here and inside ThreadFunc, to what should be
-  // the same value. This is because calls within ThreadFunc need these values
-  // to be set, and our callers need these values to be set.
-  MOZ_ASSERT(!mThread || (mThread == thread));
-  mThread = thread;
-  mEventTarget->SetCurrentThread(thread);
+  // ThreadFunc will wait for this event to be run before it tries to access
+  // mThread.  By delaying insertion of this event into the queue, we ensure
+  // that mThread is set properly.
+  {
+    mEvents->PutEvent(do_AddRef(startup),
+                      EventQueuePriority::Normal);  // retain a reference
+  }
 
+  // Wait for thread to call ThreadManager::SetupCurrentThread, which completes
+  // initialization of ThreadFunc.
+  startup->Wait();
   return NS_OK;
 }
 
 nsresult nsThread::InitCurrentThread() {
   mThread = PR_GetCurrentThread();
+  mVirtualThread = GetCurrentVirtualThread();
   SetupCurrentThreadForChaosMode();
   InitCommon();
 
@@ -690,13 +736,13 @@ nsThread::IsOnCurrentThread(bool* aResult) {
   if (mEventTarget) {
     return mEventTarget->IsOnCurrentThread(aResult);
   }
-  *aResult = PR_GetCurrentThread() == mThread;
+  *aResult = GetCurrentVirtualThread() == mVirtualThread;
   return NS_OK;
 }
 
 NS_IMETHODIMP_(bool)
 nsThread::IsOnCurrentThreadInfallible() {
-  // Rely on mThread being correct.
+  // Rely on mVirtualThread being correct.
   MOZ_CRASH("IsOnCurrentThreadInfallible should never be called on nsIThread");
 }
 
@@ -813,6 +859,7 @@ void nsThread::ShutdownComplete(NotNull<nsThreadShutdownContext*> aContext) {
   // Now, it should be safe to join without fear of dead-locking.
 
   PR_JoinThread(mThread);
+  mThread = nullptr;
 
 #ifdef DEBUG
   nsCOMPtr<nsIThreadObserver> obs = mEvents->GetObserver();
diff --git a/xpcom/threads/nsThread.h b/xpcom/threads/nsThread.h
@@ -212,6 +212,7 @@ class nsThread : public nsIThreadInternal,
 
   mozilla::CycleCollectedJSContext* mScriptObserver;
 
+  PRThread* mThread;
   void* mStackBase = nullptr;
   uint32_t mStackSize;
   uint32_t mThreadId;
diff --git a/xpcom/threads/nsThreadManager.cpp b/xpcom/threads/nsThreadManager.cpp
diff --git a/xpcom/threads/nsThreadUtils.cpp b/xpcom/threads/nsThreadUtils.cpp
diff --git a/xpcom/threads/nsThreadUtils.h b/xpcom/threads/nsThreadUtils.h

Original file line number	Diff line number	Diff line change
`@@ -5147,7 +5147,7 @@ struct ConnectionPool::DatabaseInfo final {`
`5147`	`5147`
`5148`	`5148`	`void AssertIsOnConnectionThread() const {`
`5149`	`5149`	`MOZ_ASSERT(mDEBUGConnectionThread);`
`5150`		`- MOZ_ASSERT(PR_GetCurrentThread() == mDEBUGConnectionThread);`
	`5150`	`+ MOZ_ASSERT(GetCurrentPhysicalThread() == mDEBUGConnectionThread);`
`5151`	`5151`	`}`
`5152`	`5152`
`5153`	`5153`	`uint64_t TotalTransactionCount() const {`
`@@ -10904,7 +10904,7 @@ nsresult ConnectionPool::GetOrCreateConnection(`
`10904`	`10904`	`NS_ConvertUTF16toUTF8(aDatabase->FilePath()).get()));`
`10905`	`10905`
`10906`	`10906`	`#ifdef DEBUG`
`10907`		`- dbInfo->mDEBUGConnectionThread = PR_GetCurrentThread();`
	`10907`	`+ dbInfo->mDEBUGConnectionThread = GetCurrentPhysicalThread();`
`10908`	`10908`	`#endif`
`10909`	`10909`	`}`
`10910`	`10910`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ mozilla::dom::ContentParent* ProtocolFuzzerHelper::CreateContentParent(`
`24`	`24`	`mozilla::dom::ContentParent* aOpener, const nsAString& aRemoteType) {`
`25`	`25`	`auto* cp = new mozilla::dom::ContentParent(aOpener, aRemoteType);`
`26`	`26`	`// TODO: this duplicates MessageChannel::Open`
`27`		`- cp->GetIPCChannel()->mWorkerThread = PR_GetCurrentThread();`
	`27`	`+ cp->GetIPCChannel()->mWorkerThread = GetCurrentVirtualThread();`
`28`	`28`	`cp->GetIPCChannel()->mMonitor = new RefCountedMonitor();`
`29`	`29`	`return cp;`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ nsresult NS_FASTCALL NS_TableDrivenQI(void* aThis, REFNSIID aIID,`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`#ifdef MOZ_THREAD_SAFETY_OWNERSHIP_CHECKS_SUPPORTED`
`35`		`-nsAutoOwningThread::nsAutoOwningThread() : mThread(PR_GetCurrentThread()) {}`
	`35`	`+nsAutoOwningThread::nsAutoOwningThread() : mThread(GetCurrentVirtualThread()) {}`
`36`	`36`
`37`	`37`	`void nsAutoOwningThread::AssertCurrentThreadOwnsMe(const char* msg) const {`
`38`	`38`	`if (MOZ_UNLIKELY(!IsCurrentThread())) {`
`@@ -42,6 +42,6 @@ void nsAutoOwningThread::AssertCurrentThreadOwnsMe(const char* msg) const {`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`bool nsAutoOwningThread::IsCurrentThread() const {`
`45`		`- return mThread == PR_GetCurrentThread();`
	`45`	`+ return mThread == GetCurrentVirtualThread();`
`46`	`46`	`}`
`47`	`47`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ bool TaskQueue::IsEmpty() {`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`bool TaskQueue::IsCurrentThreadIn() const {`
`167`		`- bool in = mRunningThread == PR_GetCurrentThread();`
	`167`	`+ bool in = mRunningThread == GetCurrentPhysicalThread();`
`168`	`168`	`return in;`
`169`	`169`	`}`
`170`	`170`
Original file line number	Diff line number	Diff line change
`@@ -89,11 +89,11 @@ NS_IMPL_ISUPPORTS_INHERITED(DelayedRunnable, Runnable, nsITimerCallback)`
`89`	`89`	`ThreadEventTarget::ThreadEventTarget(ThreadTargetSink* aSink,`
`90`	`90`	`bool aIsMainThread)`
`91`	`91`	`: mSink(aSink), mIsMainThread(aIsMainThread) {`
`92`		`- mThread = PR_GetCurrentThread();`
	`92`	`+ mVirtualThread = GetCurrentVirtualThread();`
`93`	`93`	`}`
`94`	`94`
`95`		`-void ThreadEventTarget::SetCurrentThread(PRThread* aThread) {`
`96`		`- mThread = aThread;`
	`95`	`+void ThreadEventTarget::SetCurrentThread() {`
	`96`	`+ mVirtualThread = GetCurrentVirtualThread();`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`NS_IMPL_ISUPPORTS(ThreadEventTarget, nsIEventTarget, nsISerialEventTarget)`
`@@ -185,6 +185,6 @@ ThreadEventTarget::IsOnCurrentThread(bool* aIsOnCurrentThread) {`
`185`	`185`
`186`	`186`	`NS_IMETHODIMP_(bool)`
`187`	`187`	`ThreadEventTarget::IsOnCurrentThreadInfallible() {`
`188`		`- // Rely on mThread being correct.`
	`188`	`+ // Rely on mVirtualThread being correct.`
`189`	`189`	`MOZ_CRASH("IsOnCurrentThreadInfallible should never be called on nsIThread");`
`190`	`190`	`}`