Bug 1539815 - move inner queue creation into the PrioritizedEventQueue constructor; r=erahm

Outside code shouldn't have to care how many levels of priority
PrioritizedEventQueue manages.

Differential Revision: https://phabricator.services.mozilla.com/D25226

--HG--
extra : moz-landing-system : lando

xpcom/threads/MainThreadQueue.h

@@ -22,14 +22,7 @@ inline already_AddRefed<nsThread> CreateMainThread(
     SynchronizedQueueT** aSynchronizedQueue = nullptr) {
   using MainThreadQueueT = PrioritizedEventQueue<InnerQueueT>;
 
-  auto queue = MakeUnique<MainThreadQueueT>(
-      MakeUnique<InnerQueueT>(EventQueuePriority::High),
-      MakeUnique<InnerQueueT>(EventQueuePriority::Input),
-      MakeUnique<InnerQueueT>(EventQueuePriority::MediumHigh),
-      MakeUnique<InnerQueueT>(EventQueuePriority::Normal),
-      MakeUnique<InnerQueueT>(EventQueuePriority::DeferredTimers),
-      MakeUnique<InnerQueueT>(EventQueuePriority::Idle),
-      do_AddRef(aIdlePeriod));
+  auto queue = MakeUnique<MainThreadQueueT>(do_AddRef(aIdlePeriod));
 
   MainThreadQueueT* prioritized = queue.get();
 

xpcom/threads/PrioritizedEventQueue.cpp

@@ -14,29 +14,13 @@
 
 using namespace mozilla;
 
-template <class InnerQueueT>
-PrioritizedEventQueue<InnerQueueT>::PrioritizedEventQueue(
-    UniquePtr<InnerQueueT> aHighQueue, UniquePtr<InnerQueueT> aInputQueue,
-    UniquePtr<InnerQueueT> aMediumHighQueue,
-    UniquePtr<InnerQueueT> aNormalQueue,
-    UniquePtr<InnerQueueT> aDeferredTimersQueue,
-    UniquePtr<InnerQueueT> aIdleQueue,
-    already_AddRefed<nsIIdlePeriod> aIdlePeriod)
-    : mHighQueue(std::move(aHighQueue)),
-      mInputQueue(std::move(aInputQueue)),
-      mMediumHighQueue(std::move(aMediumHighQueue)),
-      mNormalQueue(std::move(aNormalQueue)),
-      mDeferredTimersQueue(std::move(aDeferredTimersQueue)),
-      mIdleQueue(std::move(aIdleQueue)),
-      mIdlePeriod(aIdlePeriod) {
-  static_assert(IsBaseOf<AbstractEventQueue, InnerQueueT>::value,
-                "InnerQueueT must be an AbstractEventQueue subclass");
-}
-
 template <class InnerQueueT>
 void PrioritizedEventQueue<InnerQueueT>::PutEvent(
     already_AddRefed<nsIRunnable>&& aEvent, EventQueuePriority aPriority,
     const MutexAutoLock& aProofOfLock) {
+  static_assert(IsBaseOf<AbstractEventQueue, InnerQueueT>::value,
+                "InnerQueueT must be an AbstractEventQueue subclass");
+
   // Double check the priority with a QI.
   RefPtr<nsIRunnable> event(aEvent);
   EventQueuePriority priority = aPriority;

xpcom/threads/PrioritizedEventQueue.h

@@ -40,13 +40,14 @@ class PrioritizedEventQueue final : public AbstractEventQueue {
  public:
   static const bool SupportsPrioritization = true;
 
-  PrioritizedEventQueue(UniquePtr<InnerQueueT> aHighQueue,
-                        UniquePtr<InnerQueueT> aInputQueue,
-                        UniquePtr<InnerQueueT> aMediumHighQueue,
-                        UniquePtr<InnerQueueT> aNormalQueue,
-                        UniquePtr<InnerQueueT> aDeferredTimersQueue,
-                        UniquePtr<InnerQueueT> aIdleQueue,
-                        already_AddRefed<nsIIdlePeriod> aIdlePeriod);
+  explicit PrioritizedEventQueue(already_AddRefed<nsIIdlePeriod> aIdlePeriod)
+    : mHighQueue(MakeUnique<InnerQueueT>(EventQueuePriority::High)),
+      mInputQueue(MakeUnique<InnerQueueT>(EventQueuePriority::Input)),
+      mMediumHighQueue(MakeUnique<InnerQueueT>(EventQueuePriority::MediumHigh)),
+      mNormalQueue(MakeUnique<InnerQueueT>(EventQueuePriority::Normal)),
+      mDeferredTimersQueue(MakeUnique<InnerQueueT>(EventQueuePriority::DeferredTimers)),
+      mIdleQueue(MakeUnique<InnerQueueT>(EventQueuePriority::Idle)),
+      mIdlePeriod(aIdlePeriod) {}
 
   void PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
                 EventQueuePriority aPriority,