Bug 1409664 - P9. Remove AutoTaskQueue and its use r=bryce

Summary: TaskQueue no longer requires an explicit call to BeginShutdown() as such we no longer have a need for AutoTaskQueue. Depends on D1621 Tags: #secure-revision Bug #: 1409664 Differential Revision: https://phabricator.services.mozilla.com/D1622
2018-06-07 14:50:10 +02:00 · 2018-06-07 14:50:10 +02:00 · d586f6f943
--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@ -6,7 +6,6 @@

 #include "MediaFormatReader.h"

-#include "AutoTaskQueue.h"
 #include "MediaData.h"
 #include "MediaInfo.h"
 #include "VideoFrameContainer.h"
@ -18,6 +17,7 @@
 #include "mozilla/Preferences.h"
 #include "mozilla/SharedThreadPool.h"
 #include "mozilla/StaticPrefs.h"
+#include "mozilla/TaskQueue.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/Unused.h"
 #include "nsContentUtils.h"
@ -921,9 +921,9 @@ class MediaFormatReader::DemuxerProxy

 public:
  explicit DemuxerProxy(MediaDataDemuxer* aDemuxer)
-    : mTaskQueue(new AutoTaskQueue(
-        GetMediaThreadPool(MediaThreadType::PLATFORM_DECODER),
-        "DemuxerProxy::mTaskQueue"))
+    : mTaskQueue(
+        new TaskQueue(GetMediaThreadPool(MediaThreadType::PLATFORM_DECODER),
+                      "DemuxerProxy::mTaskQueue"))
    , mData(new Data(aDemuxer))
  {
    MOZ_COUNT_CTOR(DemuxerProxy);
@ -1016,7 +1016,7 @@ public:
  }

 private:
-  const RefPtr<AutoTaskQueue> mTaskQueue;
+  const RefPtr<TaskQueue> mTaskQueue;
  struct Data
  {
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Data)
@ -1049,7 +1049,7 @@ private:
 class MediaFormatReader::DemuxerProxy::Wrapper : public MediaTrackDemuxer
 {
 public:
-  Wrapper(MediaTrackDemuxer* aTrackDemuxer, AutoTaskQueue* aTaskQueue)
+  Wrapper(MediaTrackDemuxer* aTrackDemuxer, TaskQueue* aTaskQueue)
    : mMutex("TrackDemuxer Mutex")
    , mTaskQueue(aTaskQueue)
    , mGetSamplesMayBlock(aTrackDemuxer->GetSamplesMayBlock())
@ -1166,7 +1166,7 @@ public:

 private:
  Mutex mMutex;
-  const RefPtr<AutoTaskQueue> mTaskQueue;
+  const RefPtr<TaskQueue> mTaskQueue;
  const bool mGetSamplesMayBlock;
  const UniquePtr<TrackInfo> mInfo;
  // mTrackDemuxer is only ever accessed on demuxer's task queue.
@ -1220,7 +1220,7 @@ MediaFormatReader::DemuxerProxy::Init()
  using InitPromise = MediaDataDemuxer::InitPromise;

  RefPtr<Data> data = mData;
-  RefPtr<AutoTaskQueue> taskQueue = mTaskQueue;
+  RefPtr<TaskQueue> taskQueue = mTaskQueue;
  return InvokeAsync(mTaskQueue, __func__,
                     [data, taskQueue]() {
                       if (!data->mDemuxer) {
--- a/dom/media/gtest/TestMP4Demuxer.cpp
+++ b/dom/media/gtest/TestMP4Demuxer.cpp
@ -17,8 +17,6 @@
 using namespace mozilla;
 using media::TimeUnit;

-class AutoTaskQueue;
-
 #define DO_FAIL [binding]()->void { EXPECT_TRUE(false); binding->mTaskQueue->BeginShutdown(); }

 class MP4DemuxerBinding
--- a/dom/media/hls/HLSDemuxer.cpp
+++ b/dom/media/hls/HLSDemuxer.cpp
@ -132,8 +132,8 @@ private:
 };

 HLSDemuxer::HLSDemuxer(int aPlayerId)
-  : mTaskQueue(new AutoTaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK),
-                                 /* aSupportsTailDispatch = */ false))
+  : mTaskQueue(new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK),
+                             /* aSupportsTailDispatch = */ false))
 {
  MOZ_ASSERT(NS_IsMainThread());
  HLSDemuxerCallbacksSupport::Init();
--- a/dom/media/hls/HLSDemuxer.h
+++ b/dom/media/hls/HLSDemuxer.h
@ -7,7 +7,6 @@
 #if !defined(HLSDemuxer_h_)
 #define HLSDemuxer_h_

-#include "AutoTaskQueue.h"
 #include "GeneratedJNINatives.h"
 #include "GeneratedJNIWrappers.h"
 #include "MediaCodec.h"
@ -16,6 +15,7 @@
 #include "mozilla/Atomics.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/Mutex.h"
+#include "mozilla/TaskQueue.h"

 #include "VideoUtils.h"

@ -51,7 +51,7 @@ public:

  void NotifyDataArrived() override;

-  AutoTaskQueue* GetTaskQueue() const { return mTaskQueue; }
+  TaskQueue* GetTaskQueue() const { return mTaskQueue; }
  void OnInitialized(bool aHasAudio, bool aHasVideo);
  void OnError(int aErrorCode);

@ -62,7 +62,7 @@ private:
  ~HLSDemuxer();
  friend class HLSTrackDemuxer;

-  const RefPtr<AutoTaskQueue> mTaskQueue;
+  const RefPtr<TaskQueue> mTaskQueue;
  RefPtr<HLSTrackDemuxer> mAudioDemuxer;
  RefPtr<HLSTrackDemuxer> mVideoDemuxer;

--- a/dom/media/mediasource/AutoTaskQueue.h
+++ b/dom/media/mediasource/AutoTaskQueue.h
@ -1,73 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef MOZILLA_AUTOTASKQUEUE_H_
-#define MOZILLA_AUTOTASKQUEUE_H_
-
-#include "mozilla/RefPtr.h"
-#include "mozilla/SystemGroup.h"
-#include "mozilla/TaskQueue.h"
-
-class nsIEventTarget;
-
-namespace mozilla {
-
-// A convenience TaskQueue not requiring explicit shutdown.
-class AutoTaskQueue : public AbstractThread
-{
-public:
-  explicit AutoTaskQueue(already_AddRefed<nsIEventTarget> aPool,
-                         bool aSupportsTailDispatch = false)
-    : AbstractThread(aSupportsTailDispatch)
-    , mTaskQueue(new TaskQueue(std::move(aPool), aSupportsTailDispatch))
-    , mMonitor("AutoTaskQueue")
-  {
-  }
-
-  AutoTaskQueue(already_AddRefed<nsIEventTarget> aPool,
-                const char* aName,
-                bool aSupportsTailDispatch = false)
-    : AbstractThread(aSupportsTailDispatch)
-    , mTaskQueue(new TaskQueue(std::move(aPool), aName, aSupportsTailDispatch))
-    , mMonitor("AutoTaskQueue")
-  {
-  }
-
-  TaskDispatcher& TailDispatcher() override
-  {
-    return mTaskQueue->TailDispatcher();
-  }
-
-  MOZ_MUST_USE nsresult
-  Dispatch(already_AddRefed<nsIRunnable> aRunnable,
-           DispatchReason aReason = NormalDispatch) override
-  {
-    return mTaskQueue->Dispatch(std::move(aRunnable), aReason);
-  }
-
-  // Prevent a GCC warning about the other overload of Dispatch being hidden.
-  using AbstractThread::Dispatch;
-
-  // Blocks until all tasks finish executing.
-  void AwaitIdle() { mTaskQueue->AwaitIdle(); }
-
-  bool IsEmpty() { return mTaskQueue->IsEmpty(); }
-
-  // Returns true if the current thread is currently running a Runnable in
-  // the task queue.
-  bool IsCurrentThreadIn() override { return mTaskQueue->IsCurrentThreadIn(); }
-
-  mozilla::Monitor& Monitor() { return mMonitor; }
-
-private:
-  ~AutoTaskQueue() { mTaskQueue->BeginShutdown(); }
-  RefPtr<TaskQueue> mTaskQueue;
-  mozilla::Monitor mMonitor;
-};
-
-} // namespace mozilla
-
-#endif
--- a/dom/media/mediasource/MediaSourceDemuxer.cpp
+++ b/dom/media/mediasource/MediaSourceDemuxer.cpp
@ -24,8 +24,8 @@ using media::TimeUnit;
 using media::TimeIntervals;

 MediaSourceDemuxer::MediaSourceDemuxer(AbstractThread* aAbstractMainThread)
-  : mTaskQueue(new AutoTaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK),
-                                 "MediaSourceDemuxer::mTaskQueue"))
+  : mTaskQueue(new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK),
+                             "MediaSourceDemuxer::mTaskQueue"))
  , mMonitor("MediaSourceDemuxer")
 {
  MOZ_ASSERT(NS_IsMainThread());
--- a/dom/media/mediasource/MediaSourceDemuxer.h
+++ b/dom/media/mediasource/MediaSourceDemuxer.h
@ -7,15 +7,15 @@
 #if !defined(MediaSourceDemuxer_h_)
 #define MediaSourceDemuxer_h_

-#include "mozilla/Atomics.h"
-#include "mozilla/Maybe.h"
-#include "mozilla/Monitor.h"
-#include "AutoTaskQueue.h"
-
 #include "MediaDataDemuxer.h"
 #include "MediaResource.h"
 #include "MediaSource.h"
 #include "TrackBuffersManager.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/TaskQueue.h"
+

 namespace mozilla {

@ -49,7 +49,7 @@ public:
  /* interface for TrackBuffersManager */
  void AttachSourceBuffer(RefPtr<TrackBuffersManager>& aSourceBuffer);
  void DetachSourceBuffer(RefPtr<TrackBuffersManager>& aSourceBuffer);
-  AutoTaskQueue* GetTaskQueue() { return mTaskQueue; }
+  TaskQueue* GetTaskQueue() { return mTaskQueue; }
  void NotifyInitDataArrived();

  // Returns a string describing the state of the MediaSource internal
@ -78,7 +78,7 @@ private:
    return !GetTaskQueue() || GetTaskQueue()->IsCurrentThreadIn();
  }

-  RefPtr<AutoTaskQueue> mTaskQueue;
+  RefPtr<TaskQueue> mTaskQueue;
  nsTArray<RefPtr<MediaSourceTrackDemuxer>> mDemuxers;

  nsTArray<RefPtr<TrackBuffersManager>> mSourceBuffers;
--- a/dom/media/mediasource/TrackBuffersManager.cpp
+++ b/dom/media/mediasource/TrackBuffersManager.cpp
@ -177,7 +177,7 @@ TrackBuffersManager::QueueTask(SourceBufferTask* aTask)
  // The source buffer is a wrapped native, it would be unlinked twice and so
  // the TrackBuffersManager::Detach() would also be called twice. Since the
  // detach task has been done before, we could ignore this task.
-  RefPtr<AutoTaskQueue> taskQueue = GetTaskQueueSafe();
+  RefPtr<TaskQueue> taskQueue = GetTaskQueueSafe();
  if (!taskQueue) {
    MOZ_ASSERT(aTask->GetType() == SourceBufferTask::Type::Detach,
               "only detach task could happen here!");
--- a/dom/media/mediasource/TrackBuffersManager.h
+++ b/dom/media/mediasource/TrackBuffersManager.h
@ -11,7 +11,7 @@
 #include "mozilla/Maybe.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/NotNull.h"
-#include "AutoTaskQueue.h"
+#include "mozilla/TaskQueue.h"

 #include "MediaContainerType.h"
 #include "MediaData.h"
@ -465,7 +465,7 @@ private:
  TrackData mAudioTracks;

  // TaskQueue methods and objects.
-  RefPtr<AutoTaskQueue> GetTaskQueueSafe() const
+  RefPtr<TaskQueue> GetTaskQueueSafe() const
  {
    MutexAutoLock mut(mMutex);
    return mTaskQueue;
@ -473,7 +473,7 @@ private:
  NotNull<AbstractThread*> TaskQueueFromTaskQueue() const
  {
 #ifdef DEBUG
-    RefPtr<AutoTaskQueue> taskQueue = GetTaskQueueSafe();
+    RefPtr<TaskQueue> taskQueue = GetTaskQueueSafe();
    MOZ_ASSERT(taskQueue && taskQueue->IsCurrentThreadIn());
 #endif
    return WrapNotNull(mTaskQueue.get());
@ -533,7 +533,7 @@ private:
  // mTaskQueue is only ever written after construction on the task queue.
  // As such, it can be accessed while on task queue without the need for the
  // mutex.
-  RefPtr<AutoTaskQueue> mTaskQueue;
+  RefPtr<TaskQueue> mTaskQueue;
  // Stable audio and video track time ranges.
  media::TimeIntervals mVideoBufferedRanges;
  media::TimeIntervals mAudioBufferedRanges;
--- a/dom/media/mediasource/moz.build
+++ b/dom/media/mediasource/moz.build
@ -7,7 +7,6 @@ MOCHITEST_MANIFESTS += ['test/mochitest.ini']

 EXPORTS += [
    'AsyncEventRunner.h',
-    'AutoTaskQueue.h',
    'MediaSourceDecoder.h',
    'MediaSourceDemuxer.h',
    'SourceBufferAttributes.h',
--- a/dom/media/systemservices/MediaUtils.h
+++ b/dom/media/systemservices/MediaUtils.h
@ -7,12 +7,12 @@
 #ifndef mozilla_MediaUtils_h
 #define mozilla_MediaUtils_h

-#include "AutoTaskQueue.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/Monitor.h"
 #include "mozilla/MozPromise.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/SharedThreadPool.h"
+#include "mozilla/TaskQueue.h"
 #include "mozilla/UniquePtr.h"
 #include "nsCOMPtr.h"
 #include "nsIAsyncShutdown.h"
@ -438,10 +438,9 @@ Await(
  ResolveFunction&& aResolveFunction,
  RejectFunction&& aRejectFunction)
 {
-  RefPtr<AutoTaskQueue> taskQueue =
-    new AutoTaskQueue(std::move(aPool), "MozPromiseAwait");
-  // We can't use a Monitor allocated on the stack (see bug 1426067)
-  Monitor& mon = taskQueue->Monitor();
+  RefPtr<TaskQueue> taskQueue =
+    new TaskQueue(std::move(aPool), "MozPromiseAwait");
+  Monitor mon(__func__);
  bool done = false;

  aPromise->Then(taskQueue,
@ -471,10 +470,9 @@ typename MozPromise<ResolveValueType, RejectValueType, Excl>::
 Await(already_AddRefed<nsIEventTarget> aPool,
      RefPtr<MozPromise<ResolveValueType, RejectValueType, Excl>> aPromise)
 {
-  RefPtr<AutoTaskQueue> taskQueue =
-    new AutoTaskQueue(std::move(aPool), "MozPromiseAwait");
-  // We can't use a Monitor allocated on the stack (see bug 1426067)
-  Monitor& mon = taskQueue->Monitor();
+  RefPtr<TaskQueue> taskQueue =
+    new TaskQueue(std::move(aPool), "MozPromiseAwait");
+  Monitor mon(__func__);
  bool done = false;

  typename MozPromise<ResolveValueType, RejectValueType, Excl>::ResolveOrRejectValue val;
@ -518,10 +516,12 @@ AwaitAll(already_AddRefed<nsIEventTarget> aPool,
 {
  typedef MozPromise<ResolveValueType, RejectValueType, true> Promise;
  RefPtr<nsIEventTarget> pool = aPool;
-  RefPtr<AutoTaskQueue> taskQueue =
-    new AutoTaskQueue(do_AddRef(pool), "MozPromiseAwaitAll");
-  RefPtr<typename Promise::AllPromiseType> p = Promise::All(taskQueue, aPromises);
-  Await(pool.forget(), p, std::move(aResolveFunction), std::move(aRejectFunction));
+  RefPtr<TaskQueue> taskQueue =
+    new TaskQueue(do_AddRef(pool), "MozPromiseAwaitAll");
+  RefPtr<typename Promise::AllPromiseType> p =
+    Promise::All(taskQueue, aPromises);
+  Await(
+    pool.forget(), p, std::move(aResolveFunction), std::move(aRejectFunction));
 }

 // Note: only works with exclusive MozPromise, as Promise::All would attempt
@ -536,8 +536,8 @@ AwaitAll(already_AddRefed<nsIEventTarget> aPool,
 {
  typedef MozPromise<ResolveValueType, RejectValueType, true> Promise;
  RefPtr<nsIEventTarget> pool = aPool;
-  RefPtr<AutoTaskQueue> taskQueue =
-    new AutoTaskQueue(do_AddRef(pool), "MozPromiseAwaitAll");
+  RefPtr<TaskQueue> taskQueue =
+    new TaskQueue(do_AddRef(pool), "MozPromiseAwaitAll");
  RefPtr<typename Promise::AllPromiseType> p =
    Promise::All(taskQueue, aPromises);
  return Await(pool.forget(), p);
--- a/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
@ -12,7 +12,6 @@

 #include "AudioSegment.h"
 #include "AudioConverter.h"
-#include "AutoTaskQueue.h"
 #include "CSFLog.h"
 #include "DOMMediaStream.h"
 #include "ImageContainer.h"
@ -35,6 +34,7 @@
 #include "mozilla/Preferences.h"
 #include "mozilla/SharedThreadPool.h"
 #include "mozilla/Sprintf.h"
+#include "mozilla/TaskQueue.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/dom/RTCStatsReportBinding.h"
@ -116,8 +116,8 @@ public:
  VideoFrameConverter()
    : mLength(0)
    , mTaskQueue(
-        new AutoTaskQueue(GetMediaThreadPool(MediaThreadType::WEBRTC_DECODER),
-                          "VideoFrameConverter"))
+        new TaskQueue(GetMediaThreadPool(MediaThreadType::WEBRTC_DECODER),
+                      "VideoFrameConverter"))
    , mBufferPool(false, CONVERTER_BUFFER_POOL_SIZE)
    , mLastImage(-1) // -1 is not a guaranteed invalid serial. See bug 1262134.
 #ifdef DEBUG
@ -458,7 +458,7 @@ protected:
  }

  Atomic<int32_t, Relaxed> mLength;
-  const RefPtr<AutoTaskQueue> mTaskQueue;
+  const RefPtr<TaskQueue> mTaskQueue;
  webrtc::I420BufferPool mBufferPool;

  // Written and read from the queueing thread (normally MSG).
@ -486,8 +486,8 @@ public:
  explicit AudioProxyThread(AudioSessionConduit* aConduit)
    : mConduit(aConduit)
    , mTaskQueue(
-        new AutoTaskQueue(GetMediaThreadPool(MediaThreadType::WEBRTC_DECODER),
-                          "AudioProxy"))
+        new TaskQueue(GetMediaThreadPool(MediaThreadType::WEBRTC_DECODER),
+                      "AudioProxy"))
    , mAudioConverter(nullptr)
  {
    MOZ_ASSERT(mConduit);
@ -664,7 +664,7 @@ protected:
  }

  RefPtr<AudioSessionConduit> mConduit;
-  const RefPtr<AutoTaskQueue> mTaskQueue;
+  const RefPtr<TaskQueue> mTaskQueue;
  // Only accessed on mTaskQueue
  UniquePtr<AudioPacketizer<int16_t, int16_t>> mPacketizer;
  // A buffer to hold a single packet of audio.
@ -1978,8 +1978,8 @@ public:
              ? mSource->GraphRate()
              : WEBRTC_MAX_SAMPLE_RATE)
    , mTaskQueue(
-        new AutoTaskQueue(GetMediaThreadPool(MediaThreadType::WEBRTC_DECODER),
-                          "AudioPipelineListener"))
+        new TaskQueue(GetMediaThreadPool(MediaThreadType::WEBRTC_DECODER),
+                      "AudioPipelineListener"))
    , mLastLog(0)
  {
    AddTrackToSource(mRate);
@ -2101,7 +2101,7 @@ private:

  RefPtr<MediaSessionConduit> mConduit;
  const TrackRate mRate;
-  const RefPtr<AutoTaskQueue> mTaskQueue;
+  const RefPtr<TaskQueue> mTaskQueue;
  // Graph's current sampling rate
  TrackTicks mLastLog = 0; // mPlayedTicks when we last logged
 };