1 files changed, 47 insertions, 18 deletions

diff --git a/video/adaptation/quality_scaler_resource.h b/video/adaptation/quality_scaler_resource.h
index 30796c3db9..286413132a 100644
--- a/video/adaptation/quality_scaler_resource.h
+++ b/video/adaptation/quality_scaler_resource.h
@@ -12,26 +12,34 @@
 #define VIDEO_ADAPTATION_QUALITY_SCALER_RESOURCE_H_
 
 #include <memory>
+#include <queue>
 #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"
+#include "call/adaptation/adaptation_listener.h"
+#include "call/adaptation/degradation_preference_provider.h"
 #include "call/adaptation/resource_adaptation_processor_interface.h"
 #include "modules/video_coding/utility/quality_scaler.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.
-// TODO(hbos): Add unittests specific to this class, it is currently only tested
-// 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 QualityScalerResource : public Resource,
+class QualityScalerResource : public VideoStreamEncoderResource,
+                              public AdaptationListener,
                               public QualityScalerQpUsageHandlerInterface {
  public:
+  static rtc::scoped_refptr<QualityScalerResource> Create(
+      DegradationPreferenceProvider* degradation_preference_provider);
+
   explicit QualityScalerResource(
-      ResourceAdaptationProcessorInterface* adaptation_processor);
+      DegradationPreferenceProvider* degradation_preference_provider);
+  ~QualityScalerResource() override;
 
   bool is_started() const;
 
@@ -52,19 +60,40 @@ class QualityScalerResource : public Resource,
       rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface> callback)
       override;
 
-  std::string name() const override { return "QualityScalerResource"; }
-
-  // Resource implementation.
-  void OnAdaptationApplied(const VideoStreamInputState& input_state,
-                           const VideoSourceRestrictions& restrictions_before,
-                           const VideoSourceRestrictions& restrictions_after,
-                           const Resource& reason_resource) override;
+  // AdaptationListener implementation.
+  void OnAdaptationApplied(
+      const VideoStreamInputState& input_state,
+      const VideoSourceRestrictions& restrictions_before,
+      const VideoSourceRestrictions& restrictions_after,
+      rtc::scoped_refptr<Resource> reason_resource) override;
 
  private:
-  ResourceAdaptationProcessorInterface* const adaptation_processor_;
-  std::unique_ptr<QualityScaler> quality_scaler_;
-  rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface>
-      pending_qp_usage_callback_;
+  size_t QueuePendingCallback(
+      rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface>
+          callback);
+  void HandlePendingCallback(size_t callback_id, bool clear_qp_samples);
+  void AbortPendingCallbacks();
+
+  // Members accessed on the encoder queue.
+  std::unique_ptr<QualityScaler> quality_scaler_
+      RTC_GUARDED_BY(encoder_queue());
+  // The timestamp of the last time we reported underuse because this resource
+  // was disabled in order to prevent getting stuck with QP adaptations. Used to
+  // make sure underuse reporting is not too spammy.
+  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
+  // "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>>
+      pending_callbacks_ RTC_GUARDED_BY(encoder_queue());
+  DegradationPreferenceProvider* const degradation_preference_provider_;
+
+  // Members accessed on the adaptation queue.
+  bool clear_qp_samples_ RTC_GUARDED_BY(resource_adaptation_queue());
 };
 
 }  // namespace webrtc