Clean resource_adaptation_processor_unittest use of TaskQueueForTest

Use the current task queue in the test instead.

R=hbos@webrtc.org

Bug: None
Change-Id: I266796df3de675a808bcf2da08901411fadc86ae
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414
Commit-Queue: Evan Shrubsole <eshr@google.com>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31439}

call/adaptation/resource_adaptation_processor_unittest.cc

@@ -84,8 +84,7 @@ class VideoSourceRestrictionsListenerForTesting
 class ResourceAdaptationProcessorTest : public ::testing::Test {
  public:
   ResourceAdaptationProcessorTest()
-      : resource_adaptation_queue_("ResourceAdaptationQueue"),
+      : frame_rate_provider_(),
-        frame_rate_provider_(),
         input_state_provider_(&frame_rate_provider_),
         resource_(FakeResource::Create("FakeResource")),
         other_resource_(FakeResource::Create("OtherFakeResource")),
@@ -94,26 +93,17 @@ class ResourceAdaptationProcessorTest : public ::testing::Test {
         processor_(std::make_unique<ResourceAdaptationProcessor>(
             &input_state_provider_,
             /*encoder_stats_observer=*/&frame_rate_provider_)) {
-    resource_adaptation_queue_.SendTask(
+    processor_->SetResourceAdaptationQueue(TaskQueueBase::Current());
-        [this] {
-          processor_->SetResourceAdaptationQueue(
-              resource_adaptation_queue_.Get());
     processor_->AddRestrictionsListener(&restrictions_listener_);
     processor_->AddResource(resource_);
     processor_->AddResource(other_resource_);
     processor_->AddAdaptationConstraint(&adaptation_constraint_);
     processor_->AddAdaptationListener(&adaptation_listener_);
-        },
-        RTC_FROM_HERE);
   }
   ~ResourceAdaptationProcessorTest() override {
-    resource_adaptation_queue_.SendTask(
-        [this] {
     if (processor_) {
       DestroyProcessor();
     }
-        },
-        RTC_FROM_HERE);
   }
 
   void SetInputStates(bool has_input, int fps, int frame_size) {
@@ -131,7 +121,6 @@ class ResourceAdaptationProcessorTest : public ::testing::Test {
   }
 
   void DestroyProcessor() {
-    RTC_DCHECK_RUN_ON(&resource_adaptation_queue_);
     processor_->StopResourceAdaptation();
     processor_->RemoveRestrictionsListener(&restrictions_listener_);
     processor_->RemoveResource(resource_);
@@ -142,7 +131,6 @@ class ResourceAdaptationProcessorTest : public ::testing::Test {
   }
 
  protected:
-  TaskQueueForTest resource_adaptation_queue_;
   FakeFrameRateProvider frame_rate_provider_;
   VideoStreamInputStateProvider input_state_provider_;
   rtc::scoped_refptr<FakeResource> resource_;
@@ -156,8 +144,6 @@ class ResourceAdaptationProcessorTest : public ::testing::Test {
 }  // namespace
 
 TEST_F(ResourceAdaptationProcessorTest, DisabledByDefault) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   EXPECT_EQ(DegradationPreference::DISABLED,
             processor_->degradation_preference());
   EXPECT_EQ(DegradationPreference::DISABLED,
@@ -167,13 +153,9 @@ TEST_F(ResourceAdaptationProcessorTest, DisabledByDefault) {
   // Adaptation does not happen when disabled.
   resource_->SetUsageState(ResourceUsageState::kOveruse);
   EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -187,8 +169,6 @@ TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
   resource_->SetUsageState(ResourceUsageState::kOveruse);
   EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
   // Note: frame rate cannot be missing, if unset it is 0.
-      },
-      RTC_FROM_HERE);
 }
 
 // These tests verify that restrictions are applied, but not exactly how much
@@ -197,25 +177,18 @@ TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
 // restrictions. For that, see video_stream_adapter_unittest.cc.
 TEST_F(ResourceAdaptationProcessorTest,
        OveruseTriggersRestrictingResolutionInMaintainFrameRate) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
   SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
   resource_->SetUsageState(ResourceUsageState::kOveruse);
   EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
-        EXPECT_TRUE(restrictions_listener_.restrictions()
+  EXPECT_TRUE(
-                        .max_pixels_per_frame()
+      restrictions_listener_.restrictions().max_pixels_per_frame().has_value());
-                        .has_value());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        OveruseTriggersRestrictingFrameRateInMaintainResolution) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_RESOLUTION);
   processor_->StartResourceAdaptation();
@@ -224,14 +197,10 @@ TEST_F(ResourceAdaptationProcessorTest,
   EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
   EXPECT_TRUE(
       restrictions_listener_.restrictions().max_frame_rate().has_value());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        OveruseTriggersRestrictingFrameRateAndResolutionInBalanced) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(DegradationPreference::BALANCED);
   processor_->StartResourceAdaptation();
   SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@@ -244,18 +213,13 @@ TEST_F(ResourceAdaptationProcessorTest,
     EXPECT_EQ(i + 1, restrictions_listener_.restrictions_updated_count());
     RestrictSource(restrictions_listener_.restrictions());
   }
-        EXPECT_TRUE(restrictions_listener_.restrictions()
+  EXPECT_TRUE(
-                        .max_pixels_per_frame()
+      restrictions_listener_.restrictions().max_pixels_per_frame().has_value());
-                        .has_value());
   EXPECT_TRUE(
       restrictions_listener_.restrictions().max_frame_rate().has_value());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest, AwaitingPreviousAdaptation) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -266,26 +230,18 @@ TEST_F(ResourceAdaptationProcessorTest, AwaitingPreviousAdaptation) {
   // due to "awaiting previous adaptation". This prevents "double-adapt".
   resource_->SetUsageState(ResourceUsageState::kOveruse);
   EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest, CannotAdaptUpWhenUnrestricted) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
   SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
   resource_->SetUsageState(ResourceUsageState::kUnderuse);
   EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest, UnderuseTakesUsBackToUnrestricted) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -295,15 +251,10 @@ TEST_F(ResourceAdaptationProcessorTest, UnderuseTakesUsBackToUnrestricted) {
   RestrictSource(restrictions_listener_.restrictions());
   resource_->SetUsageState(ResourceUsageState::kUnderuse);
   EXPECT_EQ(2u, restrictions_listener_.restrictions_updated_count());
-        EXPECT_EQ(VideoSourceRestrictions(),
+  EXPECT_EQ(VideoSourceRestrictions(), restrictions_listener_.restrictions());
-                  restrictions_listener_.restrictions());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest, ResourcesCanPreventAdaptingUp) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -316,14 +267,10 @@ TEST_F(ResourceAdaptationProcessorTest, ResourcesCanPreventAdaptingUp) {
   adaptation_constraint_.set_is_adaptation_up_allowed(false);
   resource_->SetUsageState(ResourceUsageState::kUnderuse);
   EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        ResourcesCanNotAdaptUpIfNeverAdaptedDown) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -335,14 +282,10 @@ TEST_F(ResourceAdaptationProcessorTest,
   // Other resource signals under-use
   other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
   EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        ResourcesCanNotAdaptUpIfNotAdaptedDownAfterReset) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -360,14 +303,10 @@ TEST_F(ResourceAdaptationProcessorTest,
   // up should be disallowed.
   resource_->SetUsageState(ResourceUsageState::kUnderuse);
   EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        MultipleResourcesCanTriggerMultipleAdaptations) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -396,27 +335,19 @@ TEST_F(ResourceAdaptationProcessorTest,
   other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
   EXPECT_EQ(0, restrictions_listener_.adaptation_counters().Total());
   RestrictSource(restrictions_listener_.restrictions());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest, AdaptingTriggersOnAdaptationApplied) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
   SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
   resource_->SetUsageState(ResourceUsageState::kOveruse);
   EXPECT_EQ(1u, adaptation_listener_.num_adaptations_applied());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        AdaptsDownWhenOtherResourceIsAlwaysUnderused) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
@@ -435,47 +366,43 @@ TEST_F(ResourceAdaptationProcessorTest,
   // Doesn't adapt up because adaptation is due to another resource.
   EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
   RestrictSource(restrictions_listener_.restrictions());
-      },
-      RTC_FROM_HERE);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        TriggerOveruseNotOnAdaptationTaskQueue) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
   SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
-      },
+
-      RTC_FROM_HERE);
+  TaskQueueForTest resource_task_queue("ResourceTaskQueue");
-  resource_->SetUsageState(ResourceUsageState::kOveruse);
+  resource_task_queue.PostTask(ToQueuedTask(
+      [&]() { resource_->SetUsageState(ResourceUsageState::kOveruse); }));
+
   EXPECT_EQ_WAIT(1u, restrictions_listener_.restrictions_updated_count(),
                  kDefaultTimeoutMs);
 }
 
 TEST_F(ResourceAdaptationProcessorTest,
        DestroyProcessorWhileResourceListenerDelegateHasTaskInFlight) {
-  resource_adaptation_queue_.SendTask(
-      [this] {
   processor_->SetDegradationPreference(
       DegradationPreference::MAINTAIN_FRAMERATE);
   processor_->StartResourceAdaptation();
   SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
-      },
+
-      RTC_FROM_HERE);
+  // Wait for |resource_| to signal oversue first so we know that the delegate
-  // Block the destruction of the processor. This ensures that the adaptation
+  // has passed it on to the processor's task queue.
-  // queue is blocked until the ResourceListenerDelegate has had time to post
+  rtc::Event resource_event;
-  // its task.
+  TaskQueueForTest resource_task_queue("ResourceTaskQueue");
-  rtc::Event destroy_processor_event;
+  resource_task_queue.PostTask(ToQueuedTask([&]() {
-  resource_adaptation_queue_.PostTask([this, &destroy_processor_event] {
-    destroy_processor_event.Wait(rtc::Event::kForever);
-    DestroyProcessor();
-  });
     resource_->SetUsageState(ResourceUsageState::kOveruse);
-  // Unblock destruction and delegate task.
+    resource_event.Set();
-  destroy_processor_event.Set();
+  }));
-  resource_adaptation_queue_.WaitForPreviouslyPostedTasks();
+
+  EXPECT_TRUE(resource_event.Wait(kDefaultTimeoutMs));
+  // Now destroy the processor while handling the overuse is in flight.
+  DestroyProcessor();
+
   // Because the processor was destroyed by the time the delegate's task ran,
   // the overuse signal must not have been handled.
   EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());