Backed out 8 changesets (bug 1331804, bug 1332100) for windows vm debug dt5 failures a=backout
authorWes Kocher <wkocher@mozilla.com>
Tue, 24 Jan 2017 15:12:21 -0800
changeset 359946 6abcbe944f8f36edf1f710c9ab32dec6b371d392
parent 359945 3613ce87bd3dcc611c0e24d2fbeb456d56a4fc69
child 359947 6dccae211ae5fec6a1c1244b878ce0b93860154f
child 359976 c430436bb9debe4b6eb4799ca5d40984daf86a73
push id10863
push userjlorenzo@mozilla.com
push dateMon, 06 Mar 2017 23:02:23 +0000
treeherdermozilla-aurora@0931190cd725 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1331804, 1332100
milestone54.0a1
backs out8bf7f0e27c6c2293645125395b6c6eacf87189cb
600c0b9026c2f0a5bd3cf47f64a2930a6935b391
3a5b5b9ecace7a09a1c5b72a3d43c1ad8f4e9f60
c76432c9954e9bac1d8d083815df4602da31cac3
46a9096745e7ca6c6d1f4c40ab53f2dd723781a9
8b751230fa23d507b929edfff0afb283473a7bc4
2810212347fd94a60f6622ef9e391ca67c518a8c
be72b7763910890fc9fd647ef4b0ed79e1ab418f
Backed out 8 changesets (bug 1331804, bug 1332100) for windows vm debug dt5 failures a=backout Backed out changeset 8bf7f0e27c6c (bug 1331804) Backed out changeset 600c0b9026c2 (bug 1331804) Backed out changeset 3a5b5b9ecace (bug 1331804) Backed out changeset c76432c9954e (bug 1331804) Backed out changeset 46a9096745e7 (bug 1332100) Backed out changeset 8b751230fa23 (bug 1331804) Backed out changeset 2810212347fd (bug 1331804) Backed out changeset be72b7763910 (bug 1331804) MozReview-Commit-ID: Ywdsr4GZ4a
dom/base/Timeout.cpp
dom/base/nsDocument.cpp
dom/base/nsGlobalWindow.cpp
dom/base/nsScriptLoader.cpp
dom/events/AsyncEventDispatcher.cpp
dom/html/HTMLMediaElement.cpp
dom/workers/RuntimeService.cpp
dom/workers/WorkerPrivate.cpp
ipc/glue/BackgroundImpl.cpp
ipc/glue/MessageChannel.cpp
ipc/glue/MessageChannel.h
ipc/ipdl/ipdl.py
netwerk/base/nsTransportUtils.cpp
netwerk/cache2/CacheEntry.h
netwerk/dns/DNSListenerProxy.h
parser/html/nsHtml5SVGLoadDispatcher.cpp
parser/html/nsHtml5StreamParser.cpp
parser/html/nsHtml5TreeOpExecutor.cpp
storage/mozStorageAsyncStatementExecution.cpp
storage/mozStorageConnection.cpp
storage/mozStorageConnection.h
toolkit/components/telemetry/Histograms.json
widget/nsBaseAppShell.cpp
xpcom/io/nsStreamUtils.cpp
xpcom/threads/ThrottledEventQueue.cpp
xpcom/threads/nsEventQueue.cpp
xpcom/threads/nsEventQueue.h
xpcom/threads/nsINamed.idl
xpcom/threads/nsITimer.idl
xpcom/threads/nsProxyRelease.h
xpcom/threads/nsThread.cpp
xpcom/threads/nsThreadUtils.cpp
xpcom/threads/nsThreadUtils.h
xpcom/threads/nsTimerImpl.cpp
--- a/dom/base/Timeout.cpp
+++ b/dom/base/Timeout.cpp
@@ -61,32 +61,20 @@ namespace {
 void
 TimerCallback(nsITimer*, void* aClosure)
 {
   RefPtr<Timeout> timeout = (Timeout*)aClosure;
   timeout->mWindow->AsInner()->TimeoutManager().RunTimeout(timeout);
 }
 
 void
-TimerNameCallback(nsITimer* aTimer, bool aAnonymize, void* aClosure,
-                  char* aBuf, size_t aLen)
+TimerNameCallback(nsITimer* aTimer, void* aClosure, char* aBuf, size_t aLen)
 {
   RefPtr<Timeout> timeout = (Timeout*)aClosure;
 
-  // Filename and line-number information is privacy sensitive. If we're
-  // supposed to anonymize the data, don't include it.
-  if (aAnonymize) {
-    if (timeout->mIsInterval) {
-      snprintf(aBuf, aLen, "setInterval");
-    } else {
-      snprintf(aBuf, aLen, "setTimeout");
-    }
-    return;
-  }
-
   const char* filename;
   uint32_t lineNum, column;
   timeout->mScriptHandler->GetLocation(&filename, &lineNum, &column);
   snprintf(aBuf, aLen, "[content] %s:%u:%u", filename, lineNum, column);
 }
 
 } // anonymous namespace
 
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -5279,17 +5279,17 @@ nsDocument::UnblockDOMContentLoaded()
   }
   mDidFireDOMContentLoaded = true;
 
   MOZ_ASSERT(mReadyState == READYSTATE_INTERACTIVE);
   if (!mSynchronousDOMContentLoaded) {
     MOZ_RELEASE_ASSERT(NS_IsMainThread());
     nsCOMPtr<nsIRunnable> ev =
       NewRunnableMethod(this, &nsDocument::DispatchContentLoadedEvents);
-    Dispatch("nsDocument::DispatchContentLoadedEvents", TaskCategory::Other, ev.forget());
+    Dispatch("DispatchContentLoadedEvents", TaskCategory::Other, ev.forget());
   } else {
     DispatchContentLoadedEvents();
   }
 }
 
 void
 nsDocument::ContentStateChanged(nsIContent* aContent, EventStates aStateMask)
 {
@@ -12054,17 +12054,17 @@ nsDocument::GetVisibilityState() const
   return dom::VisibilityState::Visible;
 }
 
 /* virtual */ void
 nsDocument::PostVisibilityUpdateEvent()
 {
   nsCOMPtr<nsIRunnable> event =
     NewRunnableMethod(this, &nsDocument::UpdateVisibilityState);
-  Dispatch("nsDocument::UpdateVisibilityState", TaskCategory::Other, event.forget());
+  Dispatch("UpdateVisibility", TaskCategory::Other, event.forget());
 }
 
 void
 nsDocument::MaybeActiveMediaComponents()
 {
   if (mEverInForeground) {
     return;
   }
@@ -12595,20 +12595,16 @@ nsDocument::UpdateIntersectionObservatio
   for (const auto& observer : mIntersectionObservers) {
     observer->Update(this, time);
   }
 }
 
 void
 nsDocument::ScheduleIntersectionObserverNotification()
 {
-  if (mIntersectionObservers.IsEmpty()) {
-    return;
-  }
-
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   nsCOMPtr<nsIRunnable> notification =
     NewRunnableMethod(this, &nsDocument::NotifyIntersectionObservers);
   Dispatch("nsDocument::IntersectionObserverNotification", TaskCategory::Other,
            notification.forget());
 }
 
 void
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -8547,17 +8547,17 @@ nsGlobalWindow::PostMessageMozOuter(JSCo
   JS::Rooted<JS::Value> message(aCx, aMessage);
   JS::Rooted<JS::Value> transfer(aCx, aTransfer);
 
   event->Write(aCx, message, transfer, JS::CloneDataPolicy(), aError);
   if (NS_WARN_IF(aError.Failed())) {
     return;
   }
 
-  aError = Dispatch("PostMessageEvent", TaskCategory::Other, event.forget());
+  aError = Dispatch("PostMessage", TaskCategory::Other, event.forget());
 }
 
 void
 nsGlobalWindow::PostMessageMoz(JSContext* aCx, JS::Handle<JS::Value> aMessage,
                                const nsAString& aTargetOrigin,
                                JS::Handle<JS::Value> aTransfer,
                                nsIPrincipal& aSubjectPrincipal,
                                ErrorResult& aError)
--- a/dom/base/nsScriptLoader.cpp
+++ b/dom/base/nsScriptLoader.cpp
@@ -1737,18 +1737,17 @@ public:
   void SetToken(void* aToken) {
     MOZ_ASSERT(aToken && !mToken);
     mToken = aToken;
   }
 
   static void Dispatch(already_AddRefed<NotifyOffThreadScriptLoadCompletedRunnable>&& aSelf) {
     RefPtr<NotifyOffThreadScriptLoadCompletedRunnable> self = aSelf;
     RefPtr<DocGroup> docGroup = self->mDocGroup;
-    docGroup->Dispatch("NotifyOffThreadScriptLoadCompletedRunnable",
-                       TaskCategory::Other, self.forget());
+    docGroup->Dispatch("OffThreadScriptLoader", TaskCategory::Other, self.forget());
   }
 
   NS_DECL_NSIRUNNABLE
 };
 
 } /* anonymous namespace */
 
 nsresult
--- a/dom/events/AsyncEventDispatcher.cpp
+++ b/dom/events/AsyncEventDispatcher.cpp
@@ -63,24 +63,24 @@ AsyncEventDispatcher::Cancel()
 }
 
 nsresult
 AsyncEventDispatcher::PostDOMEvent()
 {
   RefPtr<AsyncEventDispatcher> ensureDeletionWhenFailing = this;
   if (NS_IsMainThread()) {
     if (nsCOMPtr<nsIGlobalObject> global = mTarget->GetOwnerGlobal()) {
-      return global->Dispatch("AsyncEventDispatcher", TaskCategory::Other, ensureDeletionWhenFailing.forget());
+      return global->Dispatch("AsyncEvent", TaskCategory::Other, ensureDeletionWhenFailing.forget());
     }
 
     // Sometimes GetOwnerGlobal returns null because it uses
     // GetScriptHandlingObject rather than GetScopeObject.
     if (nsCOMPtr<nsINode> node = do_QueryInterface(mTarget)) {
       nsCOMPtr<nsIDocument> doc = node->OwnerDoc();
-      return doc->Dispatch("AsyncEventDispatcher", TaskCategory::Other, ensureDeletionWhenFailing.forget());
+      return doc->Dispatch("AsyncEvent", TaskCategory::Other, ensureDeletionWhenFailing.forget());
     }
   }
   return NS_DispatchToCurrentThread(this);
 }
 
 void
 AsyncEventDispatcher::RunDOMEventWhenSafe()
 {
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -7201,33 +7201,33 @@ HTMLMediaElement::AsyncResolvePendingPla
   if (mShuttingDown) {
     return;
   }
 
   nsCOMPtr<nsIRunnable> event
     = new nsResolveOrRejectPendingPlayPromisesRunner(this,
                                                      TakePendingPlayPromises());
 
-  OwnerDoc()->Dispatch("nsResolveOrRejectPendingPlayPromisesRunner",
+  OwnerDoc()->Dispatch("HTMLMediaElement::AsyncResolvePendingPlayPromises",
                        TaskCategory::Other,
                        event.forget());
 }
 
 void
 HTMLMediaElement::AsyncRejectPendingPlayPromises(nsresult aError)
 {
   if (mShuttingDown) {
     return;
   }
 
   nsCOMPtr<nsIRunnable> event
     = new nsResolveOrRejectPendingPlayPromisesRunner(this,
                                                      TakePendingPlayPromises(),
                                                      aError);
 
-  OwnerDoc()->Dispatch("nsResolveOrRejectPendingPlayPromisesRunner",
+  OwnerDoc()->Dispatch("HTMLMediaElement::AsyncRejectPendingPlayPromises",
                        TaskCategory::Other,
                        event.forget());
 }
 
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -1187,18 +1187,17 @@ class WorkerThreadPrimaryRunnable final 
   JSContext* mParentContext;
 
   class FinishedRunnable final : public Runnable
   {
     RefPtr<WorkerThread> mThread;
 
   public:
     explicit FinishedRunnable(already_AddRefed<WorkerThread> aThread)
-    : Runnable("WorkerThreadPrimaryRunnable::FinishedRunnable")
-    , mThread(aThread)
+    : mThread(aThread)
     {
       MOZ_ASSERT(mThread);
     }
 
     NS_DECL_ISUPPORTS_INHERITED
 
   private:
     ~FinishedRunnable()
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -4742,21 +4742,17 @@ WorkerPrivate::DispatchToMainThread(nsIR
   nsCOMPtr<nsIRunnable> r = aRunnable;
   return DispatchToMainThread(r.forget(), aFlags);
 }
 
 nsresult
 WorkerPrivate::DispatchToMainThread(already_AddRefed<nsIRunnable> aRunnable,
                                     uint32_t aFlags)
 {
-  nsCOMPtr<nsIRunnable> runnable = aRunnable;
-  if (nsCOMPtr<nsINamed> named = do_QueryInterface(runnable)) {
-    named->SetName("WorkerRunnable");
-  }
-  return mMainThreadEventTarget->Dispatch(runnable.forget(), aFlags);
+  return mMainThreadEventTarget->Dispatch(Move(aRunnable), aFlags);
 }
 
 void
 WorkerPrivate::InitializeGCTimers()
 {
   AssertIsOnWorkerThread();
 
   // We need a timer for GC. The basic plan is to run a non-shrinking GC
--- a/ipc/glue/BackgroundImpl.cpp
+++ b/ipc/glue/BackgroundImpl.cpp
@@ -745,18 +745,17 @@ class ChildImpl::OpenMainProcessActorRun
   RefPtr<ChildImpl> mActor;
   RefPtr<ParentImpl> mParentActor;
   MessageLoop* mParentMessageLoop;
 
 public:
   OpenMainProcessActorRunnable(already_AddRefed<ChildImpl>&& aChildActor,
                                already_AddRefed<ParentImpl> aParentActor,
                                MessageLoop* aParentMessageLoop)
-  : Runnable("ChildImpl::OpenMainProcessActorRunnable"),
-    mActor(aChildActor), mParentActor(aParentActor),
+  : mActor(aChildActor), mParentActor(aParentActor),
     mParentMessageLoop(aParentMessageLoop)
   {
     AssertIsOnMainThread();
     MOZ_ASSERT(mParentActor);
     MOZ_ASSERT(aParentMessageLoop);
   }
 
 private:
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -1586,24 +1586,16 @@ MessageChannel::RunMessage(MessageTask& 
         return;
     }
 
     DispatchMessage(Move(msg));
 }
 
 NS_IMPL_ISUPPORTS_INHERITED(MessageChannel::MessageTask, CancelableRunnable, nsIRunnablePriority)
 
-MessageChannel::MessageTask::MessageTask(MessageChannel* aChannel, Message&& aMessage)
-  : CancelableRunnable(StringFromIPCMessageType(aMessage.type()))
-  , mChannel(aChannel)
-  , mMessage(Move(aMessage))
-  , mScheduled(false)
-{
-}
-
 nsresult
 MessageChannel::MessageTask::Run()
 {
     if (!mChannel) {
         return NS_OK;
     }
 
     mChannel->AssertWorkerThread();
--- a/ipc/glue/MessageChannel.h
+++ b/ipc/glue/MessageChannel.h
@@ -450,17 +450,19 @@ class MessageChannel : HasResultCodes
 
   private:
     class MessageTask :
         public CancelableRunnable,
         public LinkedListElement<RefPtr<MessageTask>>,
         public nsIRunnablePriority
     {
     public:
-        explicit MessageTask(MessageChannel* aChannel, Message&& aMessage);
+        explicit MessageTask(MessageChannel* aChannel, Message&& aMessage)
+          : mChannel(aChannel), mMessage(Move(aMessage)), mScheduled(false)
+        {}
 
         NS_DECL_ISUPPORTS_INHERITED
 
         NS_IMETHOD Run() override;
         nsresult Cancel() override;
         NS_IMETHOD GetPriority(uint32_t* aPriority) override;
         void Post();
         void Clear();
--- a/ipc/ipdl/ipdl.py
+++ b/ipc/ipdl/ipdl.py
@@ -215,17 +215,17 @@ for protocol in sorted(allmessages.keys(
         if num or msg.endswith('End'):
             continue
         print >>ipc_msgtype_name, """
   case %s__%s:
     return "%s::%s";""" % (protocol, msg, protocol, msg)
 
 print >>ipc_msgtype_name, """
   default:
-    return "<unknown IPC msg name>";
+    return "???";
   }
 }
 
 } // namespace ipc
 } // namespace mozilla
 """
 
 ipdl.writeifmodified(ipcmsgstart.getvalue(), ipcmessagestartpath)
--- a/netwerk/base/nsTransportUtils.cpp
+++ b/netwerk/base/nsTransportUtils.cpp
@@ -50,18 +50,17 @@ public:
 class nsTransportStatusEvent : public Runnable
 {
 public:
     nsTransportStatusEvent(nsTransportEventSinkProxy *proxy,
                            nsITransport *transport,
                            nsresult status,
                            int64_t progress,
                            int64_t progressMax)
-        : Runnable("nsTransportStatusEvent")
-        , mProxy(proxy)
+        : mProxy(proxy)
         , mTransport(transport)
         , mStatus(status)
         , mProgress(progress)
         , mProgressMax(progressMax)
     {}
 
     ~nsTransportStatusEvent() {}
 
--- a/netwerk/cache2/CacheEntry.h
+++ b/netwerk/cache2/CacheEntry.h
@@ -181,18 +181,17 @@ private:
 
   // Since OnCacheEntryAvailable must be invoked on the main thread
   // we need a runnable for it...
   class AvailableCallbackRunnable : public Runnable
   {
   public:
     AvailableCallbackRunnable(CacheEntry* aEntry,
                               Callback const &aCallback)
-      : Runnable("CacheEntry::AvailableCallbackRunnable")
-      , mEntry(aEntry)
+      : mEntry(aEntry)
       , mCallback(aCallback)
     {}
 
   private:
     NS_IMETHOD Run() override
     {
       mEntry->InvokeAvailableCallback(mCallback);
       return NS_OK;
--- a/netwerk/dns/DNSListenerProxy.h
+++ b/netwerk/dns/DNSListenerProxy.h
@@ -38,18 +38,17 @@ public:
 
   class OnLookupCompleteRunnable : public Runnable
   {
   public:
     OnLookupCompleteRunnable(const nsMainThreadPtrHandle<nsIDNSListener>& aListener,
                              nsICancelable* aRequest,
                              nsIDNSRecord* aRecord,
                              nsresult aStatus)
-      : Runnable("DNSListenerProxy::OnLookupCompleteRunnable")
-      , mListener(aListener)
+      : mListener(aListener)
       , mRequest(aRequest)
       , mRecord(aRecord)
       , mStatus(aStatus)
     { }
 
     NS_DECL_NSIRUNNABLE
 
   private:
--- a/parser/html/nsHtml5SVGLoadDispatcher.cpp
+++ b/parser/html/nsHtml5SVGLoadDispatcher.cpp
@@ -7,18 +7,17 @@
 #include "nsIPresShell.h"
 #include "mozilla/BasicEvents.h"
 #include "mozilla/EventDispatcher.h"
 #include "nsIDocument.h"
 
 using namespace mozilla;
 
 nsHtml5SVGLoadDispatcher::nsHtml5SVGLoadDispatcher(nsIContent* aElement)
-  : Runnable("nsHtml5SVGLoadDispatcher")
-  , mElement(aElement)
+  : mElement(aElement)
   , mDocument(mElement->OwnerDoc())
 {
   mDocument->BlockOnload();
 }
 
 NS_IMETHODIMP
 nsHtml5SVGLoadDispatcher::Run()
 {
--- a/parser/html/nsHtml5StreamParser.cpp
+++ b/parser/html/nsHtml5StreamParser.cpp
@@ -1331,17 +1331,17 @@ nsHtml5StreamParser::FlushTreeOpsAndDisa
     mFlushTimer->Cancel();
     mFlushTimerArmed = false;
   }
   if (mMode == VIEW_SOURCE_HTML || mMode == VIEW_SOURCE_XML) {
     mTokenizer->FlushViewSource();
   }
   mTreeBuilder->Flush();
   nsCOMPtr<nsIRunnable> runnable(mExecutorFlusher);
-  if (NS_FAILED(mExecutor->GetDocument()->Dispatch("nsHtml5ExecutorFlusher",
+  if (NS_FAILED(mExecutor->GetDocument()->Dispatch("FlushTreeOpsAndDisarmTimer",
                                                    dom::TaskCategory::Other,
                                                    runnable.forget()))) {
     NS_WARNING("failed to dispatch executor flush event");
   }
 }
 
 void
 nsHtml5StreamParser::ParseAvailableData()
--- a/parser/html/nsHtml5TreeOpExecutor.cpp
+++ b/parser/html/nsHtml5TreeOpExecutor.cpp
@@ -260,17 +260,17 @@ FlushTimerCallback(nsITimer* aTimer, voi
   }
 }
 
 void
 nsHtml5TreeOpExecutor::ContinueInterruptedParsingAsync()
 {
   if (!mDocument || !mDocument->IsInBackgroundWindow()) {
     nsCOMPtr<nsIRunnable> flusher = new nsHtml5ExecutorReflusher(this);  
-    if (NS_FAILED(mDocument->Dispatch("nsHtml5ExecutorReflusher",
+    if (NS_FAILED(mDocument->Dispatch("ContinueInterruptedParsingAsync",
                                       dom::TaskCategory::Other,
                                       flusher.forget()))) {
       NS_WARNING("failed to dispatch executor flush event");
     }
   } else {
     if (!gBackgroundFlushList) {
       gBackgroundFlushList = new mozilla::LinkedList<nsHtml5TreeOpExecutor>();
     }
--- a/storage/mozStorageAsyncStatementExecution.cpp
+++ b/storage/mozStorageAsyncStatementExecution.cpp
@@ -51,18 +51,17 @@ typedef AsyncExecuteStatements::Statemen
  * Notifies a callback with a result set.
  */
 class CallbackResultNotifier : public Runnable
 {
 public:
   CallbackResultNotifier(mozIStorageStatementCallback *aCallback,
                          mozIStorageResultSet *aResults,
                          AsyncExecuteStatements *aEventStatus) :
-      Runnable("storage::CallbackResultNotifier")
-    , mCallback(aCallback)
+      mCallback(aCallback)
     , mResults(aResults)
     , mEventStatus(aEventStatus)
   {
   }
 
   NS_IMETHOD Run() override
   {
     NS_ASSERTION(mCallback, "Trying to notify about results without a callback!");
@@ -89,18 +88,17 @@ private:
  * Notifies the calling thread that an error has occurred.
  */
 class ErrorNotifier : public Runnable
 {
 public:
   ErrorNotifier(mozIStorageStatementCallback *aCallback,
                 mozIStorageError *aErrorObj,
                 AsyncExecuteStatements *aEventStatus) :
-      Runnable("storage::ErrorNotifier")
-    , mCallback(aCallback)
+      mCallback(aCallback)
     , mErrorObj(aErrorObj)
     , mEventStatus(aEventStatus)
   {
   }
 
   NS_IMETHOD Run() override
   {
     if (mEventStatus->shouldNotify() && mCallback) {
@@ -130,18 +128,17 @@ class CompletionNotifier : public Runnab
 public:
   /**
    * This takes ownership of the callback and the StatementData.  They are
    * released on the thread this is dispatched to (which should always be the
    * calling thread).
    */
   CompletionNotifier(mozIStorageStatementCallback *aCallback,
                      ExecutionState aReason)
-    : Runnable("storage::CompletionNotifier")
-    , mCallback(aCallback)
+    : mCallback(aCallback)
     , mReason(aReason)
   {
   }
 
   NS_IMETHOD Run() override
   {
     if (mCallback) {
       (void)mCallback->HandleCompletion(mReason);
--- a/storage/mozStorageConnection.cpp
+++ b/storage/mozStorageConnection.cpp
@@ -441,18 +441,17 @@ public:
    * @param aCallback A callback to trigger once initialization
    *                  is complete. This event will be called on
    *                  aClone->threadOpenedOn.
    */
   AsyncInitializeClone(Connection* aConnection,
                        Connection* aClone,
                        const bool aReadOnly,
                        mozIStorageCompletionCallback* aCallback)
-    : Runnable("storage::AsyncInitializeClone")
-    , mConnection(aConnection)
+    : mConnection(aConnection)
     , mClone(aClone)
     , mReadOnly(aReadOnly)
     , mCallback(aCallback)
   {
     MOZ_ASSERT(NS_IsMainThread());
   }
 
   NS_IMETHOD Run() override {
--- a/storage/mozStorageConnection.h
+++ b/storage/mozStorageConnection.h
@@ -393,18 +393,17 @@ public:
    * @param aValue The result to pass to the callback. It must
    *               already be owned by the main thread.
    * @param aCallback The callback. It must already be owned by the
    *                  main thread.
    */
   CallbackComplete(nsresult aStatus,
                    nsISupports* aValue,
                    already_AddRefed<mozIStorageCompletionCallback> aCallback)
-    : Runnable("storage::CallbackComplete")
-    , mStatus(aStatus)
+    : mStatus(aStatus)
     , mValue(aValue)
     , mCallback(aCallback)
   {
   }
 
   NS_IMETHOD Run() override {
     MOZ_ASSERT(NS_IsMainThread());
     nsresult rv = mCallback->Complete(mStatus, mValue);
--- a/toolkit/components/telemetry/Histograms.json
+++ b/toolkit/components/telemetry/Histograms.json
@@ -10629,20 +10629,10 @@
     "expires_in_version": "58",
     "kind": "linear",
     "low": 1000,
     "high": 90000,
     "n_buckets": 91,
     "bug_numbers": [1314220],
     "description": "The time duration from tab's media was blocked to unblocked. Now we record from 1 to 90 seconds, but the record by milliseconds, so the bucket is like [1000ms, 2000ms], [2000ms, 3000ms], e.t.c.",
     "releaseChannelCollection": "opt-out"
-  },
-  "MAIN_THREAD_RUNNABLE_MS": {
-    "alert_emails": ["wmccloskey@mozilla.com"],
-    "expires_in_version": "60",
-    "kind": "exponential",
-    "keyed": true,
-    "high": 10000,
-    "n_buckets": 10,
-    "bug_numbers": [1331804],
-    "description": "The time a given main thread runnable took to run (in milliseconds). The key comes from the runnables nsINamed::name value."
   }
 }
--- a/widget/nsBaseAppShell.cpp
+++ b/widget/nsBaseAppShell.cpp
@@ -303,17 +303,17 @@ nsBaseAppShell::OnProcessNextEvent(nsITh
 }
 
 bool
 nsBaseAppShell::DispatchDummyEvent(nsIThread* aTarget)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
   if (!mDummyEvent)
-    mDummyEvent = new mozilla::Runnable("DummyEvent");
+    mDummyEvent = new mozilla::Runnable();
 
   return NS_SUCCEEDED(aTarget->Dispatch(mDummyEvent, NS_DISPATCH_NORMAL));
 }
 
 void
 nsBaseAppShell::IncrementEventloopNestingLevel()
 {
   ++mEventloopNestingLevel;
--- a/xpcom/io/nsStreamUtils.cpp
+++ b/xpcom/io/nsStreamUtils.cpp
@@ -33,18 +33,17 @@ class nsInputStreamReadyEvent final
   : public CancelableRunnable
   , public nsIInputStreamCallback
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   nsInputStreamReadyEvent(nsIInputStreamCallback* aCallback,
                           nsIEventTarget* aTarget)
-    : CancelableRunnable("nsInputStreamReadyEvent")
-    , mCallback(aCallback)
+    : mCallback(aCallback)
     , mTarget(aTarget)
   {
   }
 
 private:
   ~nsInputStreamReadyEvent()
   {
     if (!mCallback) {
@@ -124,18 +123,17 @@ class nsOutputStreamReadyEvent final
   : public CancelableRunnable
   , public nsIOutputStreamCallback
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   nsOutputStreamReadyEvent(nsIOutputStreamCallback* aCallback,
                            nsIEventTarget* aTarget)
-    : CancelableRunnable("nsOutputStreamReadyEvent")
-    , mCallback(aCallback)
+    : mCallback(aCallback)
     , mTarget(aTarget)
   {
   }
 
 private:
   ~nsOutputStreamReadyEvent()
   {
     if (!mCallback) {
@@ -238,18 +236,17 @@ class nsAStreamCopier
   : public nsIInputStreamCallback
   , public nsIOutputStreamCallback
   , public CancelableRunnable
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   nsAStreamCopier()
-    : CancelableRunnable("nsAStreamCopier")
-    , mLock("nsAStreamCopier.mLock")
+    : mLock("nsAStreamCopier.mLock")
     , mCallback(nullptr)
     , mProgressCallback(nullptr)
     , mClosure(nullptr)
     , mChunkSize(0)
     , mEventInProcess(false)
     , mEventIsPending(false)
     , mCloseSource(true)
     , mCloseSink(true)
--- a/xpcom/threads/ThrottledEventQueue.cpp
+++ b/xpcom/threads/ThrottledEventQueue.cpp
@@ -64,27 +64,21 @@ class ThrottledEventQueue::Inner final :
     RefPtr<Inner> mInner;
 
   public:
     explicit Executor(Inner* aInner)
       : mInner(aInner)
     { }
 
     NS_IMETHODIMP
-    Run() override
+    Run()
     {
       mInner->ExecuteRunnable();
       return NS_OK;
     }
-
-    NS_IMETHODIMP
-    GetName(nsACString& aName) override
-    {
-      return mInner->CurrentName(aName);
-    }
   };
 
   mutable Mutex mMutex;
   mutable CondVar mIdleCondVar;
 
   mozilla::CondVar mEventsAvailable;
 
   // any thread, protected by mutex
@@ -114,49 +108,16 @@ class ThrottledEventQueue::Inner final :
   }
 
   ~Inner()
   {
     MOZ_ASSERT(!mExecutor);
     MOZ_ASSERT(mShutdownStarted);
   }
 
-  nsresult
-  CurrentName(nsACString& aName)
-  {
-    nsCOMPtr<nsIRunnable> event;
-
-#ifdef DEBUG
-    bool currentThread = false;
-    mBaseTarget->IsOnCurrentThread(&currentThread);
-    MOZ_ASSERT(currentThread);
-#endif
-
-    {
-      MutexAutoLock lock(mMutex);
-
-      // We only check the name of an executor runnable when we know there is something
-      // in the queue, so this should never fail.
-      MOZ_ALWAYS_TRUE(mEventQueue.PeekEvent(getter_AddRefs(event), lock));
-    }
-
-    if (nsCOMPtr<nsINamed> named = do_QueryInterface(event)) {
-      // Increase mExecutionDepth here so that GetName is allowed to call
-      // IsOnCurrentThread on us and have it be true (in the case when we are on
-      // the right thread).
-      mExecutionDepth++;
-      nsresult rv = named->GetName(aName);
-      mExecutionDepth--;
-      return rv;
-    }
-
-    aName.AssignLiteral("non-nsINamed ThrottledEventQueue runnable");
-    return NS_OK;
-  }
-
   void
   ExecuteRunnable()
   {
     // Any thread
     nsCOMPtr<nsIRunnable> event;
     bool shouldShutdown = false;
 
 #ifdef DEBUG
--- a/xpcom/threads/nsEventQueue.cpp
+++ b/xpcom/threads/nsEventQueue.cpp
@@ -37,35 +37,16 @@ nsEventQueue::~nsEventQueue()
                "Non-empty event queue being destroyed; events being leaked.");
 
   if (mHead) {
     FreePage(mHead);
   }
 }
 
 bool
-nsEventQueue::PeekEvent(nsIRunnable** aEvent, MutexAutoLock& aProofOfLock)
-{
-  MOZ_ASSERT(aEvent);
-  *aEvent = nullptr;
-
-  if (IsEmpty()) {
-    return false;
-  }
-
-  MOZ_ASSERT(mOffsetHead < EVENTS_PER_PAGE);
-  MOZ_ASSERT_IF(mHead == mTail, mOffsetHead <= mOffsetTail);
-  NS_ADDREF(*aEvent = mHead->mEvents[mOffsetHead]);
-
-  MOZ_ASSERT(*aEvent);
-
-  return true;
-}
-
-bool
 nsEventQueue::GetEvent(bool aMayWait, nsIRunnable** aResult,
                        MutexAutoLock& aProofOfLock)
 {
   if (aResult) {
     *aResult = nullptr;
   }
 
   while (IsEmpty()) {
--- a/xpcom/threads/nsEventQueue.h
+++ b/xpcom/threads/nsEventQueue.h
@@ -34,20 +34,16 @@ public:
 
   // This method adds a new event to the pending event queue.  The queue holds
   // a strong reference to the event after this method returns.  This method
   // cannot fail.
   void PutEvent(nsIRunnable* aEvent, MutexAutoLock& aProofOfLock);
   void PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
                 MutexAutoLock& aProofOfLock);
 
-  // Return the first event in the queue without popping it. Returns whether the
-  // queue was empty or not. aEvent is set to null if the queue was empty.
-  bool PeekEvent(nsIRunnable** aEvent, MutexAutoLock& aProofOfLock);
-
   // This method gets an event from the event queue.  If mayWait is true, then
   // the method will block the calling thread until an event is available.  If
   // the event is null, then the method returns immediately indicating whether
   // or not an event is pending.  When the resulting event is non-null, the
   // caller is responsible for releasing the event object.  This method does
   // not alter the reference count of the resulting event.
   bool GetEvent(bool aMayWait, nsIRunnable** aEvent,
                 MutexAutoLock& aProofOfLock);
--- a/xpcom/threads/nsINamed.idl
+++ b/xpcom/threads/nsINamed.idl
@@ -11,22 +11,14 @@
 
 [scriptable, uuid(0c5fe7de-7e83-4d0d-a8a6-4a6518b9a7b3)]
 interface nsINamed : nsISupports
 {
     /*
      * A string describing the purpose of the runnable/timer/whatever. Useful
      * for debugging. This attribute is read-only, but you can change it to a
      * compile-time string literal with setName.
-     *
-     * WARNING: This attribute will be included in telemetry, so it should
-     * never contain privacy sensitive information.
      */
     readonly attribute ACString name;
 
-    /*
-     * Note: The string you pass in should be a compile-time literal.
-     *
-     * WARNING: This value will be included in telemetry, so it should
-     * never contain privacy sensitive information.
-     */
+    /* Note: The string you pass in should be a compile-time literal. */
     [noscript] void setName(in string aName);
 };
--- a/xpcom/threads/nsITimer.idl
+++ b/xpcom/threads/nsITimer.idl
@@ -24,24 +24,21 @@ typedef void (*nsTimerCallbackFunc) (nsI
 
 /**
  * The signature of the timer name callback function passed to
  * initWithNameableFuncCallback.
  * This is the function that will get called when timer profiling is enabled
  * via the "TimerFirings" log module.
  *
  * @param aTimer the timer which has expired
- * @param aAnonymize whether the name should avoid including privacy sensitive info
  * @param aClosure opaque parameter passed to initWithFuncCallback
  * @param aBuf a buffer in which to put the name
  * @param aLen the length of the buffer
  */
-typedef void (*nsTimerNameCallbackFunc) (nsITimer *aTimer,
-                                         bool aAnonymize,
-                                         void *aClosure,
+typedef void (*nsTimerNameCallbackFunc) (nsITimer *aTimer, void *aClosure,
                                          char *aBuf, size_t aLen);
 %}
 
 native nsTimerCallbackFunc(nsTimerCallbackFunc);
 native nsTimerNameCallbackFunc(nsTimerNameCallbackFunc);
 
 /**
  * The callback interface for timers.
--- a/xpcom/threads/nsProxyRelease.h
+++ b/xpcom/threads/nsProxyRelease.h
@@ -24,17 +24,17 @@
 
 namespace detail {
 
 template<typename T>
 class ProxyReleaseEvent : public mozilla::Runnable
 {
 public:
   explicit ProxyReleaseEvent(already_AddRefed<T> aDoomed)
-  : Runnable("ProxyReleaseEvent"), mDoomed(aDoomed.take()) {}
+  : mDoomed(aDoomed.take()) {}
 
   NS_IMETHOD Run() override
   {
     NS_IF_RELEASE(mDoomed);
     return NS_OK;
   }
 
 private:
--- a/xpcom/threads/nsThread.cpp
+++ b/xpcom/threads/nsThread.cpp
@@ -26,17 +26,16 @@
 #include "nsIObserverService.h"
 #include "mozilla/HangMonitor.h"
 #include "mozilla/IOInterposer.h"
 #include "mozilla/ipc/MessageChannel.h"
 #include "mozilla/ipc/BackgroundChild.h"
 #include "mozilla/Services.h"
 #include "nsXPCOMPrivate.h"
 #include "mozilla/ChaosMode.h"
-#include "mozilla/Telemetry.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/Unused.h"
 #include "mozilla/dom/ScriptSettings.h"
 #include "nsIIdlePeriod.h"
 #include "nsIIncrementalRunnable.h"
 #include "nsThreadSyncDispatch.h"
 #include "LeakRefPtr.h"
 #include "GeckoProfiler.h"
@@ -191,18 +190,17 @@ NS_IMPL_CI_INTERFACE_GETTER(nsThread, ns
                             nsIEventTarget, nsISupportsPriority)
 
 //-----------------------------------------------------------------------------
 
 class nsThreadStartupEvent : public Runnable
 {
 public:
   nsThreadStartupEvent()
-    : Runnable("nsThreadStartupEvent")
-    , mMon("nsThreadStartupEvent.mMon")
+    : mMon("nsThreadStartupEvent.mMon")
     , mInitialized(false)
   {
   }
 
   // This method does not return until the thread startup object is in the
   // completion state.
   void Wait()
   {
@@ -331,18 +329,17 @@ struct nsThreadShutdownContext
 // This event is responsible for notifying nsThread::Shutdown that it is time
 // to call PR_JoinThread. It implements nsICancelableRunnable so that it can
 // run on a DOM Worker thread (where all events must implement
 // nsICancelableRunnable.)
 class nsThreadShutdownAckEvent : public CancelableRunnable
 {
 public:
   explicit nsThreadShutdownAckEvent(NotNull<nsThreadShutdownContext*> aCtx)
-    : CancelableRunnable("nsThreadShutdownAckEvent")
-    , mShutdownContext(aCtx)
+    : mShutdownContext(aCtx)
   {
   }
   NS_IMETHOD Run() override
   {
     mShutdownContext->mTerminatingThread->ShutdownComplete(mShutdownContext);
     return NS_OK;
   }
   nsresult Cancel() override
@@ -356,18 +353,17 @@ private:
 };
 
 // This event is responsible for setting mShutdownContext
 class nsThreadShutdownEvent : public Runnable
 {
 public:
   nsThreadShutdownEvent(NotNull<nsThread*> aThr,
                         NotNull<nsThreadShutdownContext*> aCtx)
-    : Runnable("nsThreadShutdownEvent")
-    , mThread(aThr)
+    : mThread(aThr)
     , mShutdownContext(aCtx)
   {
   }
   NS_IMETHOD Run() override
   {
     mThread->mShutdownContext = mShutdownContext;
     MessageLoop::current()->Quit();
     return NS_OK;
@@ -1233,33 +1229,18 @@ nsThread::ProcessNextEvent(bool aMayWait
       MutexAutoLock lock(mLock);
       GetEvent(reallyWait, getter_AddRefs(event), lock);
     }
 
     *aResult = (event.get() != nullptr);
 
     if (event) {
       LOG(("THRD(%p) running [%p]\n", this, event.get()));
-#ifndef RELEASE_OR_BETA
-      Maybe<Telemetry::AutoTimer<Telemetry::MAIN_THREAD_RUNNABLE_MS>> timer;
-#endif
       if (MAIN_THREAD == mIsMainThread) {
         HangMonitor::NotifyActivity();
-
-#ifndef RELEASE_OR_BETA
-        nsCString name;
-        if (nsCOMPtr<nsINamed> named = do_QueryInterface(event)) {
-          if (NS_FAILED(named->GetName(name))) {
-            name.AssignLiteral("GetName failed");
-          }
-        } else {
-          name.AssignLiteral("non-nsINamed runnable");
-        }
-        timer.emplace(name);
-#endif
       }
       event->Run();
     } else if (aMayWait) {
       MOZ_ASSERT(ShuttingDown(),
                  "This should only happen when shutting down");
       rv = NS_ERROR_UNEXPECTED;
     }
   }
--- a/xpcom/threads/nsThreadUtils.cpp
+++ b/xpcom/threads/nsThreadUtils.cpp
@@ -52,21 +52,17 @@ Runnable::Run()
 }
 
 NS_IMETHODIMP
 Runnable::GetName(nsACString& aName)
 {
 #ifdef RELEASE_OR_BETA
   aName.Truncate();
 #else
-  if (mName) {
-    aName.AssignASCII(mName);
-  } else {
-    aName.Truncate();
-  }
+  aName.AssignASCII(mName);
 #endif
   return NS_OK;
 }
 
 nsresult
 Runnable::SetName(const char* aName)
 {
 #ifndef RELEASE_OR_BETA
--- a/xpcom/threads/nsThreadUtils.h
+++ b/xpcom/threads/nsThreadUtils.h
@@ -232,22 +232,16 @@ class Runnable : public nsIRunnable, pub
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIRUNNABLE
   NS_DECL_NSINAMED
 
   Runnable() {}
 
-#ifdef RELEASE_OR_BETA
-  explicit Runnable(const char* aName) {}
-#else
-  explicit Runnable(const char* aName) : mName(aName) {}
-#endif
-
 protected:
   virtual ~Runnable() {}
 private:
   Runnable(const Runnable&) = delete;
   Runnable& operator=(const Runnable&) = delete;
   Runnable& operator=(const Runnable&&) = delete;
 
 #ifndef RELEASE_OR_BETA
@@ -260,17 +254,16 @@ class CancelableRunnable : public Runnab
                            public nsICancelableRunnable
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   // nsICancelableRunnable
   virtual nsresult Cancel() override;
 
   CancelableRunnable() {}
-  explicit CancelableRunnable(const char* aName) : Runnable(aName) {}
 
 protected:
   virtual ~CancelableRunnable() {}
 private:
   CancelableRunnable(const CancelableRunnable&) = delete;
   CancelableRunnable& operator=(const CancelableRunnable&) = delete;
   CancelableRunnable& operator=(const CancelableRunnable&&) = delete;
 };
--- a/xpcom/threads/nsTimerImpl.cpp
+++ b/xpcom/threads/nsTimerImpl.cpp
@@ -543,17 +543,17 @@ nsTimerImpl::LogFiring(CallbackType aCal
       const char* name;
       static const size_t buflen = 1024;
       char buf[buflen];
 
       if (mName.is<NameString>()) {
         name = mName.as<NameString>();
 
       } else if (mName.is<NameFunc>()) {
-        mName.as<NameFunc>()(mITimer, /* aAnonymize = */ false, mClosure, buf, buflen);
+        mName.as<NameFunc>()(mITimer, mClosure, buf, buflen);
         name = buf;
 
       } else {
         MOZ_ASSERT(mName.is<NameNothing>());
 #ifdef USE_DLADDR
         annotation = "[from dladdr] ";
 
         Dl_info info;
@@ -654,42 +654,38 @@ nsTimerImpl::GetName(nsACString& aName)
 {
   switch (mCallbackType) {
     case CallbackType::Function:
       if (mName.is<NameString>()) {
         aName.Assign(mName.as<NameString>());
       } else if (mName.is<NameFunc>()) {
         static const size_t buflen = 1024;
         char buf[buflen];
-        mName.as<NameFunc>()(mITimer, /* aAnonymize = */ true, mClosure, buf, buflen);
+        mName.as<NameFunc>()(mITimer, mClosure, buf, buflen);
         aName.Assign(buf);
       } else {
         MOZ_ASSERT(mName.is<NameNothing>());
-        aName.AssignLiteral("Anonymous callback timer");
+        aName.Truncate();
       }
       break;
 
     case CallbackType::Interface:
       if (nsCOMPtr<nsINamed> named = do_QueryInterface(mCallback.i)) {
         named->GetName(aName);
-      } else {
-        aName.AssignLiteral("Anonymous interface timer");
       }
       break;
 
     case CallbackType::Observer:
       if (nsCOMPtr<nsINamed> named = do_QueryInterface(mCallback.o)) {
         named->GetName(aName);
-      } else {
-        aName.AssignLiteral("Anonymous observer timer");
       }
       break;
 
     case CallbackType::Unknown:
-      aName.AssignLiteral("Anonymous timer");
+      aName.Truncate();
       break;
   }
 }
 
 nsTimer::~nsTimer()
 {
 }