[Adaptation] Remove ResourceAdaptation queue from VideoStreamEncoderResources

Since the degradation preference can be fetch from the thread safe
provider, this removed the need to have 2 queues.

Bug: None
Change-Id: I94cb8b7d3d2950acfe0ad0a6d46edc038ed8e286
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/177523
Commit-Queue: Evan Shrubsole <eshr@google.com>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31898}

video/adaptation/encode_usage_resource.cc

@@ -13,7 +13,6 @@
 #include <limits>
 #include <utility>
 
-#include "api/video/video_adaptation_reason.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/ref_counted_object.h"
 
@@ -89,24 +88,12 @@ void EncodeUsageResource::OnEncodeCompleted(
 
 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.
-  MaybePostTaskToResourceAdaptationQueue(
-      [this_ref = rtc::scoped_refptr<EncodeUsageResource>(this)] {
-        RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
-        this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
-      });
+  OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
 }
 
 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.
-  MaybePostTaskToResourceAdaptationQueue(
-      [this_ref = rtc::scoped_refptr<EncodeUsageResource>(this)] {
-        RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
-        this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kOveruse);
-      });
+  OnResourceUsageStateMeasured(ResourceUsageState::kOveruse);
 }
 
 int EncodeUsageResource::TargetFrameRateAsInt() {

video/adaptation/quality_scaler_resource.cc

@@ -96,12 +96,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;
-      MaybePostTaskToResourceAdaptationQueue(
-          [this_ref = rtc::scoped_refptr<QualityScalerResource>(this)] {
-            RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
-            this_ref->OnResourceUsageStateMeasured(
-                ResourceUsageState::kUnderuse);
-          });
+      OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
     }
   }
 }
@@ -122,28 +117,11 @@ void QualityScalerResource::OnFrameDropped(
 }
 
 void QualityScalerResource::OnReportQpUsageHigh() {
-  RTC_DCHECK_RUN_ON(encoder_queue());
-  // Reference counting guarantees that this object is still alive by the time
-  // the task is executed.
-  MaybePostTaskToResourceAdaptationQueue(
-      [this_ref = rtc::scoped_refptr<QualityScalerResource>(this)] {
-        RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
-        // If this OnResourceUsageStateMeasured() triggers an adaptation,
-        // OnAdaptationApplied() will occur between this line and the next. This
-        // allows modifying |clear_qp_samples_| based on the adaptation.
-        this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kOveruse);
-      });
+  OnResourceUsageStateMeasured(ResourceUsageState::kOveruse);
 }
 
 void QualityScalerResource::OnReportQpUsageLow() {
-  RTC_DCHECK_RUN_ON(encoder_queue());
-  // Reference counting guarantees that this object is still alive by the time
-  // the task is executed.
-  MaybePostTaskToResourceAdaptationQueue(
-      [this_ref = rtc::scoped_refptr<QualityScalerResource>(this)] {
-        RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue());
-        this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
-      });
+  OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
 }
 
 }  // namespace webrtc

video/adaptation/quality_scaler_resource_unittest.cc

@@ -13,12 +13,9 @@
 #include <memory>
 
 #include "absl/types/optional.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/video_codecs/video_encoder.h"
 #include "call/adaptation/test/mock_resource_listener.h"
-#include "rtc_base/event.h"
-#include "rtc_base/location.h"
-#include "rtc_base/task_queue.h"
-#include "rtc_base/task_queue_for_test.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 
@@ -44,36 +41,21 @@ class FakeDegradationPreferenceProvider : public DegradationPreferenceProvider {
 class QualityScalerResourceTest : public ::testing::Test {
  public:
   QualityScalerResourceTest()
-      : resource_adaptation_queue_("ResourceAdaptationQueue",
-                                   TaskQueueFactory::Priority::NORMAL),
-        encoder_queue_("EncoderQueue", TaskQueueFactory::Priority::NORMAL),
-        quality_scaler_resource_(
+      : quality_scaler_resource_(
             QualityScalerResource::Create(&degradation_preference_provider_)) {
-    quality_scaler_resource_->RegisterEncoderTaskQueue(encoder_queue_.Get());
-    quality_scaler_resource_->RegisterAdaptationTaskQueue(
-        resource_adaptation_queue_.Get());
-    encoder_queue_.SendTask(
-        [this] {
-          quality_scaler_resource_->SetResourceListener(
-              &fake_resource_listener_);
+    quality_scaler_resource_->RegisterEncoderTaskQueue(
+        TaskQueueBase::Current());
+    quality_scaler_resource_->SetResourceListener(&fake_resource_listener_);
     quality_scaler_resource_->StartCheckForOveruse(
         VideoEncoder::QpThresholds());
-        },
-        RTC_FROM_HERE);
   }
 
   ~QualityScalerResourceTest() override {
-    encoder_queue_.SendTask(
-        [this] {
     quality_scaler_resource_->StopCheckForOveruse();
     quality_scaler_resource_->SetResourceListener(nullptr);
-        },
-        RTC_FROM_HERE);
   }
 
  protected:
-  TaskQueueForTest resource_adaptation_queue_;
-  TaskQueueForTest encoder_queue_;
   StrictMock<MockResourceListener> fake_resource_listener_;
   FakeDegradationPreferenceProvider degradation_preference_provider_;
   rtc::scoped_refptr<QualityScalerResource> quality_scaler_resource_;
@@ -83,22 +65,14 @@ TEST_F(QualityScalerResourceTest, ReportQpHigh) {
   EXPECT_CALL(fake_resource_listener_,
               OnResourceUsageStateMeasured(Eq(quality_scaler_resource_),
                                            Eq(ResourceUsageState::kOveruse)));
-  encoder_queue_.SendTask(
-      [this] { quality_scaler_resource_->OnReportQpUsageHigh(); },
-      RTC_FROM_HERE);
-  // Wait for adapt queue to clear since that signals the resource listener.
-  resource_adaptation_queue_.WaitForPreviouslyPostedTasks();
+  quality_scaler_resource_->OnReportQpUsageHigh();
 }
 
 TEST_F(QualityScalerResourceTest, ReportQpLow) {
   EXPECT_CALL(fake_resource_listener_,
               OnResourceUsageStateMeasured(Eq(quality_scaler_resource_),
                                            Eq(ResourceUsageState::kUnderuse)));
-  encoder_queue_.SendTask(
-      [this] { quality_scaler_resource_->OnReportQpUsageLow(); },
-      RTC_FROM_HERE);
-  // Wait for adapt queue to clear since that signals the resource listener.
-  resource_adaptation_queue_.WaitForPreviouslyPostedTasks();
+  quality_scaler_resource_->OnReportQpUsageLow();
 }
 
 }  // namespace webrtc

video/adaptation/video_stream_encoder_resource.cc

@@ -19,7 +19,6 @@ VideoStreamEncoderResource::VideoStreamEncoderResource(std::string name)
     : lock_(),
       name_(std::move(name)),
       encoder_queue_(nullptr),
-      resource_adaptation_queue_(nullptr),
       listener_(nullptr) {}
 
 VideoStreamEncoderResource::~VideoStreamEncoderResource() {
@@ -35,26 +34,11 @@ void VideoStreamEncoderResource::RegisterEncoderTaskQueue(
   encoder_queue_ = encoder_queue;
 }
 
-void VideoStreamEncoderResource::RegisterAdaptationTaskQueue(
-    TaskQueueBase* resource_adaptation_queue) {
-  MutexLock lock(&lock_);
-  RTC_DCHECK(!resource_adaptation_queue_);
-  RTC_DCHECK(resource_adaptation_queue);
-  resource_adaptation_queue_ = resource_adaptation_queue;
-}
-
-void VideoStreamEncoderResource::UnregisterAdaptationTaskQueue() {
-  MutexLock lock(&lock_);
-  RTC_DCHECK(resource_adaptation_queue_);
-  RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
-  resource_adaptation_queue_ = nullptr;
-}
-
 void VideoStreamEncoderResource::SetResourceListener(
     ResourceListener* listener) {
   // If you want to change listener you need to unregister the old listener by
   // setting it to null first.
-  MutexLock crit(&listener_lock_);
+  MutexLock crit(&lock_);
   RTC_DCHECK(!listener_ || !listener) << "A listener is already set";
   listener_ = listener;
 }
@@ -65,7 +49,7 @@ std::string VideoStreamEncoderResource::Name() const {
 
 void VideoStreamEncoderResource::OnResourceUsageStateMeasured(
     ResourceUsageState usage_state) {
-  MutexLock crit(&listener_lock_);
+  MutexLock crit(&lock_);
   if (listener_) {
     listener_->OnResourceUsageStateMeasured(this, usage_state);
   }
@@ -75,11 +59,4 @@ TaskQueueBase* VideoStreamEncoderResource::encoder_queue() const {
   return encoder_queue_;
 }
 
-TaskQueueBase* VideoStreamEncoderResource::resource_adaptation_queue() const {
-  MutexLock lock(&lock_);
-  RTC_DCHECK(resource_adaptation_queue_);
-  RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
-  return resource_adaptation_queue_;
-}
-
 }  // namespace webrtc

video/adaptation/video_stream_encoder_resource.h

@@ -34,16 +34,6 @@ class VideoStreamEncoderResource : public Resource {
   std::string Name() const override;
   void SetResourceListener(ResourceListener* listener) override;
 
-  // Provides a pointer to the adaptation task queue. After this call, all
-  // methods defined in this interface, including
-  // UnregisterAdaptationTaskQueue() MUST be invoked on the adaptation task
-  // queue. Registering the adaptation task queue may, however, happen off the
-  // adaptation task queue.
-  void RegisterAdaptationTaskQueue(TaskQueueBase* resource_adaptation_queue);
-  // Signals that the adaptation task queue is no longer safe to use. No
-  // assumptions must be made as to whether or not tasks in-flight will run.
-  void UnregisterAdaptationTaskQueue();
-
  protected:
   explicit VideoStreamEncoderResource(std::string name);
 
@@ -51,28 +41,13 @@ class VideoStreamEncoderResource : public Resource {
 
   // 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) {
-    MutexLock lock(&lock_);
-    if (!resource_adaptation_queue_)
-      return;
-    resource_adaptation_queue_->PostTask(ToQueuedTask(closure));
-  }
 
  private:
   mutable Mutex lock_;
   const std::string name_;
   // Treated as const after initialization.
   TaskQueueBase* encoder_queue_;
-  TaskQueueBase* resource_adaptation_queue_ RTC_GUARDED_BY(lock_);
-  mutable Mutex listener_lock_;
-  ResourceListener* listener_ RTC_GUARDED_BY(listener_lock_);
+  ResourceListener* listener_ RTC_GUARDED_BY(lock_);
 };
 
 }  // namespace webrtc

video/adaptation/video_stream_encoder_resource_manager.cc

@@ -312,11 +312,7 @@ void VideoStreamEncoderResourceManager::Initialize(
   bitrate_constraint_->SetAdaptationQueue(resource_adaptation_queue_->Get());
   balanced_constraint_->SetAdaptationQueue(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(