[Adaptation] Prep Resource for api/ move. Introduce VSE-Resource.

This CL is in preparation for moving Resource to the api/ folder. It
does not move it, but makes it such that the moving CL can be a pure
move.

In order to do this, we must stop depending on rtc_base/rtc::TaskQueue
in favor of api/webrtc::TaskQueueBase.

There are also other rtc_base/ dependencies that we do not want to
expose to the api/ folder, like critical sections and thread
annotations which are not publically exposed. To get around this, we
make Resource an abstract interface and move all of the base class
functionality into a new non-api/ class: VideoStreamEncoderResource.

The Resource now has Register/UnregisterAdaptationTaskQueue() methods.
By explicitly unregistering, we can ensure validity of the pointer even
if the Resource outlives the PeerConnection. While public interface
methods are only to be called on the adaptation task queue, posting to
the task queue happens off-queue, so a |lock_| is introduced to guard
it.

Bug: webrtc:11525
Change-Id: I50b3a30960cdec9032016c779b47001c01dad32f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176320
Reviewed-by: Evan Shrubsole <eshr@google.com>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31402}

12 files changed, 291 insertions, 62 deletions

diff --git a/video/adaptation/BUILD.gn b/video/adaptation/BUILD.gn
index 51e6a2d84e..e27e5b5297 100644
--- a/video/adaptation/BUILD.gn
+++ b/video/adaptation/BUILD.gn
@@ -16,6 +16,8 @@ rtc_library("video_adaptation") {
     "overuse_frame_detector.h",
     "quality_scaler_resource.cc",
     "quality_scaler_resource.h",
+    "video_stream_encoder_resource.cc",
+    "video_stream_encoder_resource.h",
     "video_stream_encoder_resource_manager.cc",
     "video_stream_encoder_resource_manager.h",
   ]
@@ -44,6 +46,7 @@ rtc_library("video_adaptation") {
     "../../rtc_base/experiments:quality_scaler_settings",
     "../../rtc_base/synchronization:sequence_checker",
     "../../rtc_base/task_utils:repeating_task",
+    "../../rtc_base/task_utils:to_queued_task",
     "../../system_wrappers:field_trial",
     "../../system_wrappers:system_wrappers",
     "//third_party/abseil-cpp/absl/algorithm:container",
diff --git a/video/adaptation/encode_usage_resource.cc b/video/adaptation/encode_usage_resource.cc
index 49531a3aa4..d6f2334fa1 100644
--- a/video/adaptation/encode_usage_resource.cc
+++ b/video/adaptation/encode_usage_resource.cc
@@ -15,18 +15,28 @@
 
 #include "api/video/video_adaptation_reason.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/ref_counted_object.h"
 
 namespace webrtc {
 
+// static
+rtc::scoped_refptr<EncodeUsageResource> EncodeUsageResource::Create(
+    std::unique_ptr<OveruseFrameDetector> overuse_detector) {
+  return new rtc::RefCountedObject<EncodeUsageResource>(
+      std::move(overuse_detector));
+}
+
 EncodeUsageResource::EncodeUsageResource(
     std::unique_ptr<OveruseFrameDetector> overuse_detector)
-    : rtc::RefCountedObject<Resource>(),
+    : VideoStreamEncoderResource("EncoderUsageResource"),
       overuse_detector_(std::move(overuse_detector)),
       is_started_(false),
       target_frame_rate_(absl::nullopt) {
   RTC_DCHECK(overuse_detector_);
 }
 
+EncodeUsageResource::~EncodeUsageResource() {}
+
 bool EncodeUsageResource::is_started() const {
   RTC_DCHECK_RUN_ON(encoder_queue());
   return is_started_;
@@ -81,7 +91,7 @@ void EncodeUsageResource::AdaptUp() {
   RTC_DCHECK_RUN_ON(encoder_queue());
   // Reference counting guarantees that this object is still alive by the time
   // the task is executed.
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref = rtc::scoped_refptr<EncodeUsageResource>(this)] {
         RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
         this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
@@ -92,7 +102,7 @@ void EncodeUsageResource::AdaptDown() {
   RTC_DCHECK_RUN_ON(encoder_queue());
   // Reference counting guarantees that this object is still alive by the time
   // the task is executed.
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref = rtc::scoped_refptr<EncodeUsageResource>(this)] {
         RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
         this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kOveruse);
diff --git a/video/adaptation/encode_usage_resource.h b/video/adaptation/encode_usage_resource.h
index 3c6f02b243..6fcd0ebd97 100644
--- a/video/adaptation/encode_usage_resource.h
+++ b/video/adaptation/encode_usage_resource.h
@@ -15,11 +15,13 @@
 #include <string>
 
 #include "absl/types/optional.h"
+#include "api/scoped_refptr.h"
 #include "api/video/video_adaptation_reason.h"
 #include "call/adaptation/resource.h"
 #include "rtc_base/ref_counted_object.h"
 #include "rtc_base/task_queue.h"
 #include "video/adaptation/overuse_frame_detector.h"
+#include "video/adaptation/video_stream_encoder_resource.h"
 
 namespace webrtc {
 
@@ -28,11 +30,15 @@ namespace webrtc {
 // indirectly by usage in the ResourceAdaptationProcessor (which is only tested
 // because of its usage in VideoStreamEncoder); all tests are currently in
 // video_stream_encoder_unittest.cc.
-class EncodeUsageResource : public rtc::RefCountedObject<Resource>,
+class EncodeUsageResource : public VideoStreamEncoderResource,
                             public OveruseFrameDetectorObserverInterface {
  public:
+  static rtc::scoped_refptr<EncodeUsageResource> Create(
+      std::unique_ptr<OveruseFrameDetector> overuse_detector);
+
   explicit EncodeUsageResource(
       std::unique_ptr<OveruseFrameDetector> overuse_detector);
+  ~EncodeUsageResource() override;
 
   bool is_started() const;
 
@@ -51,8 +57,6 @@ class EncodeUsageResource : public rtc::RefCountedObject<Resource>,
   void AdaptUp() override;
   void AdaptDown() override;
 
-  std::string name() const override { return "EncoderUsageResource"; }
-
  private:
   int TargetFrameRateAsInt();
 
diff --git a/video/adaptation/quality_scaler_resource.cc b/video/adaptation/quality_scaler_resource.cc
index c88bfa208f..514a2d765f 100644
--- a/video/adaptation/quality_scaler_resource.cc
+++ b/video/adaptation/quality_scaler_resource.cc
@@ -13,6 +13,8 @@
 #include <utility>
 
 #include "rtc_base/experiments/balanced_degradation_settings.h"
+#include "rtc_base/ref_counted_object.h"
+#include "rtc_base/task_utils/to_queued_task.h"
 #include "rtc_base/time_utils.h"
 
 namespace webrtc {
@@ -23,8 +25,13 @@ const int64_t kUnderuseDueToDisabledCooldownMs = 1000;
 
 }  // namespace
 
+// static
+rtc::scoped_refptr<QualityScalerResource> QualityScalerResource::Create() {
+  return new rtc::RefCountedObject<QualityScalerResource>();
+}
+
 QualityScalerResource::QualityScalerResource()
-    : rtc::RefCountedObject<Resource>(),
+    : VideoStreamEncoderResource("QualityScalerResource"),
       quality_scaler_(nullptr),
       last_underuse_due_to_disabled_timestamp_ms_(absl::nullopt),
       num_handled_callbacks_(0),
@@ -95,7 +102,7 @@ void QualityScalerResource::OnEncodeCompleted(const EncodedImage& encoded_image,
         timestamp_ms - last_underuse_due_to_disabled_timestamp_ms_.value() >=
             kUnderuseDueToDisabledCooldownMs) {
       last_underuse_due_to_disabled_timestamp_ms_ = timestamp_ms;
-      resource_adaptation_queue()->PostTask(
+      MaybePostTaskToResourceAdaptationQueue(
           [this_ref = rtc::scoped_refptr<QualityScalerResource>(this)] {
             RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
             this_ref->OnResourceUsageStateMeasured(
@@ -126,7 +133,7 @@ void QualityScalerResource::OnReportQpUsageHigh(
   size_t callback_id = QueuePendingCallback(callback);
   // Reference counting guarantees that this object is still alive by the time
   // the task is executed.
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref = rtc::scoped_refptr<QualityScalerResource>(this),
        callback_id] {
         RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
@@ -146,7 +153,7 @@ void QualityScalerResource::OnReportQpUsageLow(
   size_t callback_id = QueuePendingCallback(callback);
   // Reference counting guarantees that this object is still alive by the time
   // the task is executed.
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref = rtc::scoped_refptr<QualityScalerResource>(this),
        callback_id] {
         RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
@@ -206,8 +213,8 @@ void QualityScalerResource::HandlePendingCallback(size_t callback_id,
   // Reference counting guarantees that this object is still alive by the time
   // the task is executed.
   encoder_queue()->PostTask(
-      [this_ref = rtc::scoped_refptr<QualityScalerResource>(this), callback_id,
-       clear_qp_samples] {
+      ToQueuedTask([this_ref = rtc::scoped_refptr<QualityScalerResource>(this),
+                    callback_id, clear_qp_samples] {
         RTC_DCHECK_RUN_ON(this_ref->encoder_queue());
         if (this_ref->num_handled_callbacks_ >= callback_id) {
           // The callback with this ID has already been handled.
@@ -220,7 +227,7 @@ void QualityScalerResource::HandlePendingCallback(size_t callback_id,
             clear_qp_samples);
         ++this_ref->num_handled_callbacks_;
         this_ref->pending_callbacks_.pop();
-      });
+      }));
 }
 
 void QualityScalerResource::AbortPendingCallbacks() {
diff --git a/video/adaptation/quality_scaler_resource.h b/video/adaptation/quality_scaler_resource.h
index 2632f2e124..43e99e7ed1 100644
--- a/video/adaptation/quality_scaler_resource.h
+++ b/video/adaptation/quality_scaler_resource.h
@@ -16,6 +16,7 @@
 #include <string>
 
 #include "absl/types/optional.h"
+#include "api/scoped_refptr.h"
 #include "api/video/video_adaptation_reason.h"
 #include "api/video_codecs/video_encoder.h"
 #include "call/adaptation/resource.h"
@@ -24,13 +25,16 @@
 #include "rtc_base/critical_section.h"
 #include "rtc_base/ref_counted_object.h"
 #include "rtc_base/task_queue.h"
+#include "video/adaptation/video_stream_encoder_resource.h"
 
 namespace webrtc {
 
 // Handles interaction with the QualityScaler.
-class QualityScalerResource : public rtc::RefCountedObject<Resource>,
+class QualityScalerResource : public VideoStreamEncoderResource,
                               public QualityScalerQpUsageHandlerInterface {
  public:
+  static rtc::scoped_refptr<QualityScalerResource> Create();
+
   QualityScalerResource();
   ~QualityScalerResource() override;
 
@@ -56,9 +60,7 @@ class QualityScalerResource : public rtc::RefCountedObject<Resource>,
       rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface> callback)
       override;
 
-  std::string name() const override { return "QualityScalerResource"; }
-
-  // Resource implementation.
+  // VideoStreamEncoderResource implementation.
   void OnAdaptationApplied(
       const VideoStreamInputState& input_state,
       const VideoSourceRestrictions& restrictions_before,
@@ -81,9 +83,9 @@ class QualityScalerResource : public rtc::RefCountedObject<Resource>,
   absl::optional<int64_t> last_underuse_due_to_disabled_timestamp_ms_
       RTC_GUARDED_BY(encoder_queue());
   // Every OnReportQpUsageHigh/Low() operation has a callback that MUST be
-  // invoked on the |encoder_queue_|. Because usage measurements are reported on
-  // the |encoder_queue_| but handled by the processor on the the
-  // |resource_adaptation_queue_|, handling a measurement entails a task queue
+  // invoked on the encoder_queue(). Because usage measurements are reported on
+  // the encoder_queue() but handled by the processor on the the
+  // resource_adaptation_queue_(), handling a measurement entails a task queue
   // "ping" round-trip. Multiple callbacks in-flight is thus possible.
   size_t num_handled_callbacks_ RTC_GUARDED_BY(encoder_queue());
   std::queue<rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface>>
diff --git a/video/adaptation/quality_scaler_resource_unittest.cc b/video/adaptation/quality_scaler_resource_unittest.cc
index 66f4e13870..e2098d71b7 100644
--- a/video/adaptation/quality_scaler_resource_unittest.cc
+++ b/video/adaptation/quality_scaler_resource_unittest.cc
@@ -74,9 +74,10 @@ class QualityScalerResourceTest : public ::testing::Test {
         encoder_queue_(task_queue_factory_->CreateTaskQueue(
             "EncoderQueue",
             TaskQueueFactory::Priority::NORMAL)),
-        quality_scaler_resource_(new QualityScalerResource()) {
-    quality_scaler_resource_->Initialize(&encoder_queue_,
-                                         &resource_adaptation_queue_);
+        quality_scaler_resource_(QualityScalerResource::Create()) {
+    quality_scaler_resource_->RegisterEncoderTaskQueue(encoder_queue_.Get());
+    quality_scaler_resource_->RegisterAdaptationTaskQueue(
+        resource_adaptation_queue_.Get());
     rtc::Event event;
     encoder_queue_.PostTask([this, &event] {
       quality_scaler_resource_->StartCheckForOveruse(
diff --git a/video/adaptation/video_stream_encoder_resource.cc b/video/adaptation/video_stream_encoder_resource.cc
new file mode 100644
index 0000000000..db5a15534c
--- /dev/null
+++ b/video/adaptation/video_stream_encoder_resource.cc
@@ -0,0 +1,112 @@
+/*
+ *  Copyright 2020 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "video/adaptation/video_stream_encoder_resource.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace webrtc {
+
+VideoStreamEncoderResource::VideoStreamEncoderResource(std::string name)
+    : lock_(),
+      name_(std::move(name)),
+      encoder_queue_(nullptr),
+      resource_adaptation_queue_(nullptr),
+      usage_state_(absl::nullopt),
+      listener_(nullptr) {}
+
+VideoStreamEncoderResource::~VideoStreamEncoderResource() {
+  RTC_DCHECK(!listener_)
+      << "There is a listener depending on a VideoStreamEncoderResource being "
+      << "destroyed.";
+}
+
+void VideoStreamEncoderResource::RegisterEncoderTaskQueue(
+    TaskQueueBase* encoder_queue) {
+  RTC_DCHECK(!encoder_queue_);
+  RTC_DCHECK(encoder_queue);
+  encoder_queue_ = encoder_queue;
+}
+
+void VideoStreamEncoderResource::RegisterAdaptationTaskQueue(
+    TaskQueueBase* resource_adaptation_queue) {
+  rtc::CritScope crit(&lock_);
+  RTC_DCHECK(!resource_adaptation_queue_);
+  RTC_DCHECK(resource_adaptation_queue);
+  resource_adaptation_queue_ = resource_adaptation_queue;
+}
+
+void VideoStreamEncoderResource::UnregisterAdaptationTaskQueue() {
+  rtc::CritScope crit(&lock_);
+  RTC_DCHECK(resource_adaptation_queue_);
+  RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
+  resource_adaptation_queue_ = nullptr;
+}
+
+void VideoStreamEncoderResource::SetResourceListener(
+    ResourceListener* listener) {
+  RTC_DCHECK_RUN_ON(resource_adaptation_queue());
+  // If you want to change listener you need to unregister the old listener by
+  // setting it to null first.
+  RTC_DCHECK(!listener_ || !listener) << "A listener is already set";
+  listener_ = listener;
+}
+
+std::string VideoStreamEncoderResource::Name() const {
+  return name_;
+}
+
+absl::optional<ResourceUsageState> VideoStreamEncoderResource::UsageState()
+    const {
+  RTC_DCHECK_RUN_ON(resource_adaptation_queue());
+  return usage_state_;
+}
+
+void VideoStreamEncoderResource::ClearUsageState() {
+  RTC_DCHECK_RUN_ON(resource_adaptation_queue());
+  usage_state_ = absl::nullopt;
+}
+
+bool VideoStreamEncoderResource::IsAdaptationUpAllowed(
+    const VideoStreamInputState& input_state,
+    const VideoSourceRestrictions& restrictions_before,
+    const VideoSourceRestrictions& restrictions_after,
+    rtc::scoped_refptr<Resource> reason_resource) const {
+  return true;
+}
+
+void VideoStreamEncoderResource::OnAdaptationApplied(
+    const VideoStreamInputState& input_state,
+    const VideoSourceRestrictions& restrictions_before,
+    const VideoSourceRestrictions& restrictions_after,
+    rtc::scoped_refptr<Resource> reason_resource) {}
+
+void VideoStreamEncoderResource::OnResourceUsageStateMeasured(
+    ResourceUsageState usage_state) {
+  RTC_DCHECK_RUN_ON(resource_adaptation_queue());
+  usage_state_ = usage_state;
+  if (listener_) {
+    listener_->OnResourceUsageStateMeasured(this);
+  }
+}
+
+TaskQueueBase* VideoStreamEncoderResource::encoder_queue() const {
+  return encoder_queue_;
+}
+
+TaskQueueBase* VideoStreamEncoderResource::resource_adaptation_queue() const {
+  rtc::CritScope crit(&lock_);
+  RTC_DCHECK(resource_adaptation_queue_);
+  RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
+  return resource_adaptation_queue_;
+}
+
+}  // namespace webrtc
diff --git a/video/adaptation/video_stream_encoder_resource.h b/video/adaptation/video_stream_encoder_resource.h
new file mode 100644
index 0000000000..fe66040512
--- /dev/null
+++ b/video/adaptation/video_stream_encoder_resource.h
@@ -0,0 +1,86 @@
+/*
+ *  Copyright 2020 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_H_
+#define VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/task_queue/task_queue_base.h"
+#include "call/adaptation/resource.h"
+#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/sequence_checker.h"
+
+namespace webrtc {
+
+class VideoStreamEncoderResource : public Resource {
+ public:
+  ~VideoStreamEncoderResource() override;
+
+  // Registering task queues must be performed as part of initialization.
+  void RegisterEncoderTaskQueue(TaskQueueBase* encoder_queue);
+
+  // Resource implementation.
+  void RegisterAdaptationTaskQueue(
+      TaskQueueBase* resource_adaptation_queue) override;
+  void UnregisterAdaptationTaskQueue() override;
+  void SetResourceListener(ResourceListener* listener) override;
+  std::string Name() const override;
+  absl::optional<ResourceUsageState> UsageState() const override;
+  void ClearUsageState() override;
+  // Default implementations, may be overriden again by child classes.
+  bool IsAdaptationUpAllowed(
+      const VideoStreamInputState& input_state,
+      const VideoSourceRestrictions& restrictions_before,
+      const VideoSourceRestrictions& restrictions_after,
+      rtc::scoped_refptr<Resource> reason_resource) const override;
+  void OnAdaptationApplied(
+      const VideoStreamInputState& input_state,
+      const VideoSourceRestrictions& restrictions_before,
+      const VideoSourceRestrictions& restrictions_after,
+      rtc::scoped_refptr<Resource> reason_resource) override;
+
+ protected:
+  explicit VideoStreamEncoderResource(std::string name);
+
+  void OnResourceUsageStateMeasured(ResourceUsageState usage_state);
+
+  // The caller is responsible for ensuring the task queue is still valid.
+  TaskQueueBase* encoder_queue() const;
+  // Validity of returned pointer is ensured by only allowing this method to be
+  // called on the adaptation task queue. Designed for use with RTC_GUARDED_BY.
+  // For posting from a different queue, use
+  // MaybePostTaskToResourceAdaptationQueue() instead, which only posts if the
+  // task queue is currently registered.
+  TaskQueueBase* resource_adaptation_queue() const;
+  template <typename Closure>
+  void MaybePostTaskToResourceAdaptationQueue(Closure&& closure) {
+    rtc::CritScope crit(&lock_);
+    if (!resource_adaptation_queue_)
+      return;
+    resource_adaptation_queue_->PostTask(ToQueuedTask(closure));
+  }
+
+ private:
+  rtc::CriticalSection lock_;
+  const std::string name_;
+  // Treated as const after initialization.
+  TaskQueueBase* encoder_queue_;
+  TaskQueueBase* resource_adaptation_queue_ RTC_GUARDED_BY(lock_);
+  absl::optional<ResourceUsageState> usage_state_
+      RTC_GUARDED_BY(resource_adaptation_queue());
+  ResourceListener* listener_ RTC_GUARDED_BY(resource_adaptation_queue());
+};
+
+}  // namespace webrtc
+
+#endif  // VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_H_
diff --git a/video/adaptation/video_stream_encoder_resource_manager.cc b/video/adaptation/video_stream_encoder_resource_manager.cc
index b309dd3455..c88c6333e2 100644
--- a/video/adaptation/video_stream_encoder_resource_manager.cc
+++ b/video/adaptation/video_stream_encoder_resource_manager.cc
@@ -26,6 +26,7 @@
 #include "call/adaptation/video_source_restrictions.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
+#include "rtc_base/ref_counted_object.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/time_utils.h"
 
@@ -140,7 +141,8 @@ class VideoStreamEncoderResourceManager::InitialFrameDropper {
 
 VideoStreamEncoderResourceManager::PreventAdaptUpDueToActiveCounts::
     PreventAdaptUpDueToActiveCounts(VideoStreamEncoderResourceManager* manager)
-    : rtc::RefCountedObject<Resource>(),
+    : rtc::RefCountedObject<VideoStreamEncoderResource>(
+          "PreventAdaptUpDueToActiveCounts"),
       manager_(manager),
       adaptation_processor_(nullptr) {}
 
@@ -187,7 +189,8 @@ VideoStreamEncoderResourceManager::
     PreventIncreaseResolutionDueToBitrateResource::
         PreventIncreaseResolutionDueToBitrateResource(
             VideoStreamEncoderResourceManager* manager)
-    : rtc::RefCountedObject<Resource>(),
+    : rtc::RefCountedObject<VideoStreamEncoderResource>(
+          "PreventIncreaseResolutionDueToBitrateResource"),
       manager_(manager),
       encoder_settings_(absl::nullopt),
       encoder_target_bitrate_bps_(absl::nullopt) {}
@@ -196,7 +199,7 @@ void VideoStreamEncoderResourceManager::
     PreventIncreaseResolutionDueToBitrateResource::OnEncoderSettingsUpdated(
         absl::optional<EncoderSettings> encoder_settings) {
   RTC_DCHECK_RUN_ON(encoder_queue());
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref =
            rtc::scoped_refptr<PreventIncreaseResolutionDueToBitrateResource>(
                this),
@@ -211,7 +214,7 @@ void VideoStreamEncoderResourceManager::
         OnEncoderTargetBitrateUpdated(
             absl::optional<uint32_t> encoder_target_bitrate_bps) {
   RTC_DCHECK_RUN_ON(encoder_queue());
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref =
            rtc::scoped_refptr<PreventIncreaseResolutionDueToBitrateResource>(
                this),
@@ -258,7 +261,8 @@ bool VideoStreamEncoderResourceManager::
 
 VideoStreamEncoderResourceManager::PreventAdaptUpInBalancedResource::
     PreventAdaptUpInBalancedResource(VideoStreamEncoderResourceManager* manager)
-    : rtc::RefCountedObject<Resource>(),
+    : rtc::RefCountedObject<VideoStreamEncoderResource>(
+          "PreventAdaptUpInBalancedResource"),
       manager_(manager),
       adaptation_processor_(nullptr),
       encoder_target_bitrate_bps_(absl::nullopt) {}
@@ -274,7 +278,7 @@ void VideoStreamEncoderResourceManager::PreventAdaptUpInBalancedResource::
     OnEncoderTargetBitrateUpdated(
         absl::optional<uint32_t> encoder_target_bitrate_bps) {
   RTC_DCHECK_RUN_ON(encoder_queue());
-  resource_adaptation_queue()->PostTask(
+  MaybePostTaskToResourceAdaptationQueue(
       [this_ref = rtc::scoped_refptr<PreventAdaptUpInBalancedResource>(this),
        encoder_target_bitrate_bps] {
         RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
@@ -328,8 +332,8 @@ VideoStreamEncoderResourceManager::VideoStreamEncoderResourceManager(
       prevent_adapt_up_in_balanced_resource_(
           new PreventAdaptUpInBalancedResource(this)),
       encode_usage_resource_(
-          new EncodeUsageResource(std::move(overuse_detector))),
-      quality_scaler_resource_(new QualityScalerResource()),
+          EncodeUsageResource::Create(std::move(overuse_detector))),
+      quality_scaler_resource_(QualityScalerResource::Create()),
       encoder_queue_(nullptr),
       resource_adaptation_queue_(nullptr),
       input_state_provider_(input_state_provider),
@@ -370,16 +374,24 @@ void VideoStreamEncoderResourceManager::Initialize(
   RTC_DCHECK(resource_adaptation_queue);
   encoder_queue_ = encoder_queue;
   resource_adaptation_queue_ = resource_adaptation_queue;
-  prevent_adapt_up_due_to_active_counts_->Initialize(
-      encoder_queue_, resource_adaptation_queue_);
-  prevent_increase_resolution_due_to_bitrate_resource_->Initialize(
-      encoder_queue_, resource_adaptation_queue_);
-  prevent_adapt_up_in_balanced_resource_->Initialize(
-      encoder_queue_, resource_adaptation_queue_);
-  encode_usage_resource_->Initialize(encoder_queue_,
-                                     resource_adaptation_queue_);
-  quality_scaler_resource_->Initialize(encoder_queue_,
-                                       resource_adaptation_queue_);
+  prevent_adapt_up_due_to_active_counts_->RegisterEncoderTaskQueue(
+      encoder_queue_->Get());
+  prevent_adapt_up_due_to_active_counts_->RegisterAdaptationTaskQueue(
+      resource_adaptation_queue_->Get());
+  prevent_increase_resolution_due_to_bitrate_resource_
+      ->RegisterEncoderTaskQueue(encoder_queue_->Get());
+  prevent_increase_resolution_due_to_bitrate_resource_
+      ->RegisterAdaptationTaskQueue(resource_adaptation_queue_->Get());
+  prevent_adapt_up_in_balanced_resource_->RegisterEncoderTaskQueue(
+      encoder_queue_->Get());
+  prevent_adapt_up_in_balanced_resource_->RegisterAdaptationTaskQueue(
+      resource_adaptation_queue_->Get());
+  encode_usage_resource_->RegisterEncoderTaskQueue(encoder_queue_->Get());
+  encode_usage_resource_->RegisterAdaptationTaskQueue(
+      resource_adaptation_queue_->Get());
+  quality_scaler_resource_->RegisterEncoderTaskQueue(encoder_queue_->Get());
+  quality_scaler_resource_->RegisterAdaptationTaskQueue(
+      resource_adaptation_queue_->Get());
 }
 
 void VideoStreamEncoderResourceManager::SetAdaptationProcessor(
@@ -428,7 +440,7 @@ void VideoStreamEncoderResourceManager::MapResourceToReason(
                              [resource](const ResourceAndReason& r) {
                                return r.resource == resource;
                              }) == resources_.end())
-      << "Resource " << resource->name() << " already was inserted";
+      << "Resource " << resource->Name() << " already was inserted";
   resources_.emplace_back(resource, reason);
 }
 
@@ -616,7 +628,7 @@ VideoAdaptationReason VideoStreamEncoderResourceManager::GetReasonFromResource(
         return r.resource == resource;
       });
   RTC_DCHECK(registered_resource != resources_.end())
-      << resource->name() << " not found.";
+      << resource->Name() << " not found.";
   return registered_resource->reason;
 }
 
diff --git a/video/adaptation/video_stream_encoder_resource_manager.h b/video/adaptation/video_stream_encoder_resource_manager.h
index d028e5049a..4563b74212 100644
--- a/video/adaptation/video_stream_encoder_resource_manager.h
+++ b/video/adaptation/video_stream_encoder_resource_manager.h
@@ -43,6 +43,7 @@
 #include "video/adaptation/encode_usage_resource.h"
 #include "video/adaptation/overuse_frame_detector.h"
 #include "video/adaptation/quality_scaler_resource.h"
+#include "video/adaptation/video_stream_encoder_resource.h"
 
 namespace webrtc {
 
@@ -178,7 +179,7 @@ class VideoStreamEncoderResourceManager
   // Does not trigger adaptations, only prevents adapting up based on
   // |active_counts_|.
   class PreventAdaptUpDueToActiveCounts final
-      : public rtc::RefCountedObject<Resource> {
+      : public rtc::RefCountedObject<VideoStreamEncoderResource> {
    public:
     explicit PreventAdaptUpDueToActiveCounts(
         VideoStreamEncoderResourceManager* manager);
@@ -188,9 +189,6 @@ class VideoStreamEncoderResourceManager
         ResourceAdaptationProcessorInterface* adaptation_processor);
 
     // Resource overrides.
-    std::string name() const override {
-      return "PreventAdaptUpDueToActiveCounts";
-    }
     bool IsAdaptationUpAllowed(
         const VideoStreamInputState& input_state,
         const VideoSourceRestrictions& restrictions_before,
@@ -207,7 +205,7 @@ class VideoStreamEncoderResourceManager
 
   // Does not trigger adaptations, only prevents adapting up resolution.
   class PreventIncreaseResolutionDueToBitrateResource final
-      : public rtc::RefCountedObject<Resource> {
+      : public rtc::RefCountedObject<VideoStreamEncoderResource> {
    public:
     explicit PreventIncreaseResolutionDueToBitrateResource(
         VideoStreamEncoderResourceManager* manager);
@@ -219,9 +217,6 @@ class VideoStreamEncoderResourceManager
         absl::optional<uint32_t> encoder_target_bitrate_bps);
 
     // Resource overrides.
-    std::string name() const override {
-      return "PreventIncreaseResolutionDueToBitrateResource";
-    }
     bool IsAdaptationUpAllowed(
         const VideoStreamInputState& input_state,
         const VideoSourceRestrictions& restrictions_before,
@@ -240,7 +235,7 @@ class VideoStreamEncoderResourceManager
 
   // Does not trigger adaptations, only prevents adapting up in BALANCED.
   class PreventAdaptUpInBalancedResource final
-      : public rtc::RefCountedObject<Resource> {
+      : public rtc::RefCountedObject<VideoStreamEncoderResource> {
    public:
     explicit PreventAdaptUpInBalancedResource(
         VideoStreamEncoderResourceManager* manager);
@@ -252,9 +247,6 @@ class VideoStreamEncoderResourceManager
         absl::optional<uint32_t> encoder_target_bitrate_bps);
 
     // Resource overrides.
-    std::string name() const override {
-      return "PreventAdaptUpInBalancedResource";
-    }
     bool IsAdaptationUpAllowed(
         const VideoStreamInputState& input_state,
         const VideoSourceRestrictions& restrictions_before,
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 6d148cd62a..95c6055970 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1698,7 +1698,7 @@ void VideoStreamEncoder::OnVideoSourceRestrictionsUpdated(
     const VideoAdaptationCounters& adaptation_counters,
     rtc::scoped_refptr<Resource> reason) {
   RTC_DCHECK_RUN_ON(&resource_adaptation_queue_);
-  std::string resource_name = reason ? reason->name() : "<null>";
+  std::string resource_name = reason ? reason->Name() : "<null>";
   RTC_LOG(INFO) << "Updating sink restrictions from " << resource_name << " to "
                 << restrictions.ToString();
   video_source_sink_controller_.SetRestrictions(std::move(restrictions));
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 277c00b701..69a966bff7 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -316,12 +316,12 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
                                overuse_detector_proxy_ =
                                    new CpuOveruseDetectorProxy(stats_proxy)),
                            task_queue_factory),
-        fake_cpu_resource_(new FakeResource("FakeResource[CPU]")),
-        fake_quality_resource_(new FakeResource("FakeResource[QP]")) {
-    fake_cpu_resource_->Initialize(encoder_queue(),
-                                   resource_adaptation_queue());
-    fake_quality_resource_->Initialize(encoder_queue(),
-                                       resource_adaptation_queue());
+        fake_cpu_resource_(FakeResource::Create("FakeResource[CPU]")),
+        fake_quality_resource_(FakeResource::Create("FakeResource[QP]")) {
+    fake_cpu_resource_->RegisterAdaptationTaskQueue(
+        resource_adaptation_queue()->Get());
+    fake_quality_resource_->RegisterAdaptationTaskQueue(
+        resource_adaptation_queue()->Get());
     InjectAdaptationResource(fake_quality_resource_,
                              VideoAdaptationReason::kQuality);
     InjectAdaptationResource(fake_cpu_resource_, VideoAdaptationReason::kCpu);