[Adaptation] Make Resources reference counted and add more DCHECKs.

In a future CL, adaptation processing and stream encoder resource
management will happen on different task queues. When this is the case,
asynchronous tasks will be posted in both directions and some resources
will have internal states used on multiple threads.

This CL makes the Resource class reference counted in order to support
posting tasks to a different threads without risk of use-after-free
when a posted task is executed with a delay. This is preferred over
WeakPtr strategies because WeakPtrs are single-threaded and preferred
over raw pointer usage because the reference counted approach enables
more compile-time and run-time assurance. This is also "future proof";
when resources can be injected through public APIs, ownership needs to
be shared between libwebrtc and the application (e.g. Chrome).

To reduce the risk of making mistakes in the future CL, sequence
checkers and task queue DCHECKs are added as well as other DCHECKs to
make sure things have been cleaned up before destruction, e.g:
- Processor gets a sequence checker. It is entirely single-threaded.
- Processor must not have any attached listeners or resources on
  destruction.
- Resources must not have any listeners on destruction.
- The Manager, EncodeUsageResource and QualityScalerResource DCHECKs
  they are running on the encoder queue.
- TODOs are added illustrating where we want to add PostTasks in the
  future CL.

Lastly, upon VideoStreamEncoder::Stop() we delete the
ResourceAdaptationProcessor. Because the Processor is already used in
posted tasks, some if statements are added to ensure the Processor is
not used after destruction.

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

call/adaptation/BUILD.gn

@@ -29,14 +29,17 @@ rtc_library("resource_adaptation") {
   ]
   deps = [
     "../../api:rtp_parameters",
+    "../../api:scoped_refptr",
     "../../api/video:video_adaptation",
     "../../api/video:video_frame",
     "../../api/video:video_stream_encoder",
     "../../api/video_codecs:video_codecs_api",
     "../../modules/video_coding:video_coding_utility",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
+    "../../rtc_base:rtc_task_queue",
     "../../rtc_base/experiments:balanced_degradation_settings",
+    "../../rtc_base/synchronization:sequence_checker",
     "//third_party/abseil-cpp/absl/algorithm:container",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
@@ -56,6 +59,7 @@ if (rtc_include_tests) {
     deps = [
       ":resource_adaptation",
       ":resource_adaptation_test_utilities",
+      "../../api:scoped_refptr",
       "../../api/video:video_adaptation",
       "../../api/video_codecs:video_codecs_api",
       "../../rtc_base:checks",

call/adaptation/resource.cc

@@ -19,7 +19,10 @@ ResourceListener::~ResourceListener() {}
 
 Resource::Resource() : usage_state_(absl::nullopt), listener_(nullptr) {}
 
-Resource::~Resource() {}
+Resource::~Resource() {
+  RTC_DCHECK(!listener_)
+      << "There is a listener depending on a Resource being destroyed.";
+}
 
 void Resource::SetResourceListener(ResourceListener* listener) {
   // If you want to change listener you need to unregister the old listener by
@@ -40,21 +43,21 @@ bool Resource::IsAdaptationUpAllowed(
     const VideoStreamInputState& input_state,
     const VideoSourceRestrictions& restrictions_before,
     const VideoSourceRestrictions& restrictions_after,
-    const Resource& reason_resource) const {
+    rtc::scoped_refptr<Resource> reason_resource) const {
   return true;
 }
 
 void Resource::OnAdaptationApplied(
     const VideoStreamInputState& input_state,
     const VideoSourceRestrictions& restrictions_before,
     const VideoSourceRestrictions& restrictions_after,
-    const Resource& reason_resource) {}
+    rtc::scoped_refptr<Resource> reason_resource) {}
 
 void Resource::OnResourceUsageStateMeasured(ResourceUsageState usage_state) {
   usage_state_ = usage_state;
   if (!listener_)
     return;
-  listener_->OnResourceUsageStateMeasured(*this);
+  listener_->OnResourceUsageStateMeasured(this);
 }
 
 }  // namespace webrtc

call/adaptation/resource.h

@@ -15,8 +15,10 @@
 #include <vector>
 
 #include "absl/types/optional.h"
+#include "api/scoped_refptr.h"
 #include "call/adaptation/video_source_restrictions.h"
 #include "call/adaptation/video_stream_input_state.h"
+#include "rtc_base/ref_count.h"
 
 namespace webrtc {
 
@@ -34,15 +36,16 @@ class ResourceListener {
   virtual ~ResourceListener();
 
   // Informs the listener of a new measurement of resource usage. This means
-  // that |resource.usage_state()| is now up-to-date.
-  virtual void OnResourceUsageStateMeasured(const Resource& resource) = 0;
+  // that |resource->usage_state()| is now up-to-date.
+  virtual void OnResourceUsageStateMeasured(
+      rtc::scoped_refptr<Resource> resource) = 0;
 };
 
-class Resource {
+class Resource : public rtc::RefCountInterface {
  public:
   // By default, usage_state() is null until a measurement is made.
   Resource();
-  virtual ~Resource();
+  ~Resource() override;
 
   void SetResourceListener(ResourceListener* listener);
 
@@ -56,12 +59,12 @@ class Resource {
       const VideoStreamInputState& input_state,
       const VideoSourceRestrictions& restrictions_before,
       const VideoSourceRestrictions& restrictions_after,
-      const Resource& reason_resource) const;
+      rtc::scoped_refptr<Resource> reason_resource) const;
   virtual void OnAdaptationApplied(
       const VideoStreamInputState& input_state,
       const VideoSourceRestrictions& restrictions_before,
       const VideoSourceRestrictions& restrictions_after,
-      const Resource& reason_resource);
+      rtc::scoped_refptr<Resource> reason_resource);
 
   virtual std::string name() const = 0;