diff --git a/call/adaptation/resource.cc b/call/adaptation/resource.cc
index e6974b1d9d..d599207860 100644
--- a/call/adaptation/resource.cc
+++ b/call/adaptation/resource.cc
@@ -10,32 +10,36 @@
 
 #include "call/adaptation/resource.h"
 
-#include "rtc_base/strings/string_builder.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
-namespace {
+ResourceListener::~ResourceListener() {}
 
-const char* ResourceUsageStateToString(ResourceUsageState usage_state) {
-  switch (usage_state) {
-    case ResourceUsageState::kOveruse:
-      return "overuse";
-    case ResourceUsageState::kStable:
-      return "stable";
-    case ResourceUsageState::kUnderuse:
-      return "underuse";
-  }
-}
-
-}  // namespace
+Resource::Resource() : usage_state_(ResourceUsageState::kStable) {}
 
 Resource::~Resource() {}
 
-std::string Resource::ToString() const {
-  rtc::StringBuilder sb;
-  sb << Name() << ": " << CurrentUsage() << " " << UsageUnitsOfMeasurement();
-  sb << " (" << ResourceUsageStateToString(CurrentUsageState()) << ")";
-  return sb.str();
+void Resource::RegisterListener(ResourceListener* listener) {
+  RTC_DCHECK(listener);
+  listeners_.push_back(listener);
+}
+
+ResourceUsageState Resource::usage_state() const {
+  return usage_state_;
+}
+
+ResourceListenerResponse Resource::OnResourceUsageStateMeasured(
+    ResourceUsageState usage_state) {
+  ResourceListenerResponse response = ResourceListenerResponse::kNothing;
+  usage_state_ = usage_state;
+  for (auto* listener : listeners_) {
+    ResourceListenerResponse listener_response =
+        listener->OnResourceUsageStateMeasured(*this);
+    if (listener_response != ResourceListenerResponse::kNothing)
+      response = listener_response;
+  }
+  return response;
 }
 
 }  // namespace webrtc
diff --git a/call/adaptation/resource.h b/call/adaptation/resource.h
index 0bd142168f..7e6855f7e7 100644
--- a/call/adaptation/resource.h
+++ b/call/adaptation/resource.h
@@ -11,10 +11,14 @@
 #ifndef CALL_ADAPTATION_RESOURCE_H_
 #define CALL_ADAPTATION_RESOURCE_H_
 
-#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
 
 namespace webrtc {
 
+class Resource;
+
 enum class ResourceUsageState {
   // Action is needed to minimze the load on this resource.
   kOveruse,
@@ -25,32 +29,71 @@ enum class ResourceUsageState {
   kUnderuse,
 };
 
+enum class ResourceListenerResponse {
+  kNothing,
+  // This response is only applicable to QualityScaler-based resources.
+  // It tells the QualityScaler to increase its QP measurement frequency.
+  //
+  // This is modelled after AdaptationObserverInterface::AdaptDown()'s return
+  // value. The method comment says "Returns false if a downgrade was requested
+  // but the request did not result in a new limiting resolution or fps."
+  // However the actual implementation seems to be: Return false if
+  // !has_input_video_ or if we use balanced degradation preference and we DID
+  // adapt frame rate but the difference between input frame rate and balanced
+  // settings' min fps is less than the balanced settings' min fps diff - in all
+  // other cases, return true whether or not adaptation happened.
+  //
+  // For QualityScaler-based resources, kQualityScalerShouldIncreaseFrequency
+  // maps to "return false" and kNothing maps to "return true".
+  //
+  // TODO(https://crbug.com/webrtc/11222): Remove this enum. Resource
+  // measurements and adaptation decisions need to be separated in order to
+  // support injectable adaptation modules, multi-stream aware adaptation and
+  // decision-making logic based on multiple resources.
+  kQualityScalerShouldIncreaseFrequency,
+};
+
+class ResourceListener {
+ public:
+  virtual ~ResourceListener();
+
+  // Informs the listener of a new measurement of resource usage. This means
+  // that |resource.usage_state()| is now up-to-date.
+  //
+  // The listener may influence the resource that signaled the measurement
+  // according to the returned ResourceListenerResponse enum.
+  virtual ResourceListenerResponse OnResourceUsageStateMeasured(
+      const Resource& resource) = 0;
+};
+
 // A Resource is something which can be measured as "overused", "stable" or
-// "underused". For example, if we are overusing CPU we may need to lower the
-// resolution of one of the streams. In other words, one of the ResourceConumers
-// - representing an encoder - needs to be reconfigured with a different
-// ResourceConsumerConfiguration - representing a different encoder setting.
+// "underused". When the resource usage changes, listeners of the resource are
+// informed.
 //
-// This is an abstract class used by the ResourceAdaptationProcessor to make
-// decisions about which configurations to use. How a resource is measured or
-// what measurements map to different ResourceUsageState values is
-// implementation-specific.
+// Implementations of this interface are responsible for performing resource
+// usage measurements and invoking OnResourceUsageStateMeasured().
 class Resource {
  public:
+  // By default, usage_state() is kStable until a measurement is made.
+  Resource();
   virtual ~Resource();
 
-  // Informational, not formally part of the decision-making process.
-  virtual std::string Name() const = 0;
-  virtual std::string UsageUnitsOfMeasurement() const = 0;
-  // Valid ranges are implementation-specific.
-  virtual double CurrentUsage() const = 0;
+  // TODO(https://crbug.com/webrtc/11222): Make it possible to unregister
+  // listeners and DCHECK that they're all unregistered in the destructor.
+  void RegisterListener(ResourceListener* listener);
 
-  // The current usage state of this resource. Used by the
-  // ResourceAdaptationProcessor to calculate the desired consumer
-  // configurations.
-  virtual ResourceUsageState CurrentUsageState() const = 0;
+  ResourceUsageState usage_state() const;
 
-  std::string ToString() const;
+ protected:
+  // Updates the usage state and informs all registered listeners.
+  // Returns the result of the last listener's OnResourceUsageStateMeasured()
+  // call that was not kNothing, else kNothing.
+  ResourceListenerResponse OnResourceUsageStateMeasured(
+      ResourceUsageState usage_state);
+
+ private:
+  ResourceUsageState usage_state_;
+  std::vector<ResourceListener*> listeners_;
 };
 
 }  // namespace webrtc
diff --git a/call/adaptation/resource_adaptation_processor.cc b/call/adaptation/resource_adaptation_processor.cc
index e4f209fe9d..151480cb4d 100644
--- a/call/adaptation/resource_adaptation_processor.cc
+++ b/call/adaptation/resource_adaptation_processor.cc
@@ -51,12 +51,11 @@ absl::optional<ConsumerConfigurationPair>
 ResourceAdaptationProcessor::FindNextConfiguration() {
   ResourceUsageState overall_usage = ResourceUsageState::kUnderuse;
   for (auto& resource : resources_) {
-    ResourceUsageState resource_usage = resource->CurrentUsageState();
-    if (resource_usage == ResourceUsageState::kStable) {
+    if (resource->usage_state() == ResourceUsageState::kStable) {
       // If any resource is "stable", we are not underusing.
       if (overall_usage == ResourceUsageState::kUnderuse)
         overall_usage = ResourceUsageState::kStable;
-    } else if (resource_usage == ResourceUsageState::kOveruse) {
+    } else if (resource->usage_state() == ResourceUsageState::kOveruse) {
       // If any resource is "overuse", we are overusing.
       overall_usage = ResourceUsageState::kOveruse;
       break;
diff --git a/call/adaptation/resource_adaptation_processor_unittest.cc b/call/adaptation/resource_adaptation_processor_unittest.cc
index 38f9fa1143..df99aed48b 100644
--- a/call/adaptation/resource_adaptation_processor_unittest.cc
+++ b/call/adaptation/resource_adaptation_processor_unittest.cc
@@ -189,8 +189,8 @@ TEST(ResourceAdaptationProcessorTest,
   // When the first resource is overused.
   EXPECT_TRUE(processor.FindNextConfiguration().has_value());
   // When the second resource is overused.
-  first_resource->set_usage(ResourceUsageState::kStable);
-  second_resource->set_usage(ResourceUsageState::kOveruse);
+  first_resource->set_usage_state(ResourceUsageState::kStable);
+  second_resource->set_usage_state(ResourceUsageState::kOveruse);
   EXPECT_TRUE(processor.FindNextConfiguration().has_value());
 }
 
@@ -207,7 +207,7 @@ TEST(ResourceAdaptationProcessorTest,
   // When only the first resource is underused.
   EXPECT_EQ(absl::nullopt, processor.FindNextConfiguration());
   // When all resources are underused.
-  second_resource->set_usage(ResourceUsageState::kUnderuse);
+  second_resource->set_usage_state(ResourceUsageState::kUnderuse);
   EXPECT_TRUE(processor.FindNextConfiguration().has_value());
 }
 
@@ -250,7 +250,7 @@ TEST(ResourceAdaptationProcessorTest,
   consumer->SetConfiguration(d);
 
   // We should expect to adapt up: d -> b -> c -> a
-  resource->set_usage(ResourceUsageState::kUnderuse);
+  resource->set_usage_state(ResourceUsageState::kUnderuse);
   EXPECT_EQ(b, processor.FindNextConfiguration()->configuration);
   consumer->SetConfiguration(b);
   EXPECT_EQ(c, processor.FindNextConfiguration()->configuration);
diff --git a/call/adaptation/test/fake_resource.cc b/call/adaptation/test/fake_resource.cc
index 363fc26fe7..b3fe7643ca 100644
--- a/call/adaptation/test/fake_resource.cc
+++ b/call/adaptation/test/fake_resource.cc
@@ -14,39 +14,14 @@
 
 namespace webrtc {
 
-FakeResource::FakeResource(std::string name, ResourceUsageState usage)
-    : name_(std::move(name)), usage_(usage) {}
-
-FakeResource::FakeResource(ResourceUsageState usage)
-    : FakeResource("UnnamedResource", usage) {}
+FakeResource::FakeResource(ResourceUsageState usage_state) : Resource() {
+  set_usage_state(usage_state);
+}
 
 FakeResource::~FakeResource() {}
 
-void FakeResource::set_usage(ResourceUsageState usage) {
-  usage_ = usage;
-}
-
-std::string FakeResource::Name() const {
-  return name_;
-}
-
-std::string FakeResource::UsageUnitsOfMeasurement() const {
-  return "%";
-}
-
-double FakeResource::CurrentUsage() const {
-  switch (usage_) {
-    case ResourceUsageState::kOveruse:
-      return 1.2;
-    case ResourceUsageState::kStable:
-      return 0.8;
-    case ResourceUsageState::kUnderuse:
-      return 0.4;
-  }
-}
-
-ResourceUsageState FakeResource::CurrentUsageState() const {
-  return usage_;
+void FakeResource::set_usage_state(ResourceUsageState usage_state) {
+  OnResourceUsageStateMeasured(usage_state);
 }
 
 }  // namespace webrtc
diff --git a/call/adaptation/test/fake_resource.h b/call/adaptation/test/fake_resource.h
index 60291af6ae..62825c44f1 100644
--- a/call/adaptation/test/fake_resource.h
+++ b/call/adaptation/test/fake_resource.h
@@ -17,26 +17,13 @@
 
 namespace webrtc {
 
-// Fake resource used for testing. ResourceUsageState is controlled with a
-// setter. The arbitrarily chosen unit of measurement is percentage, with the
-// following current usage reported based on the current usage: kOveruse = 120%,
-// kStable = 80% and kUnderuse = 40%.
+// Fake resource used for testing.
 class FakeResource : public Resource {
  public:
-  FakeResource(std::string name, ResourceUsageState usage);
-  explicit FakeResource(ResourceUsageState usage);
+  explicit FakeResource(ResourceUsageState usage_state);
   ~FakeResource() override;
 
-  void set_usage(ResourceUsageState usage);
-
-  std::string Name() const override;
-  std::string UsageUnitsOfMeasurement() const override;
-  double CurrentUsage() const override;
-  ResourceUsageState CurrentUsageState() const override;
-
- private:
-  std::string name_;
-  ResourceUsageState usage_;
+  void set_usage_state(ResourceUsageState usage_state);
 };
 
 }  // namespace webrtc
diff --git a/modules/video_coding/utility/quality_scaler.h b/modules/video_coding/utility/quality_scaler.h
index 9556a58358..29d7ad7b11 100644
--- a/modules/video_coding/utility/quality_scaler.h
+++ b/modules/video_coding/utility/quality_scaler.h
@@ -28,6 +28,11 @@ namespace webrtc {
 
 // An interface for signaling requests to limit or increase the resolution or
 // framerate of the captured video stream.
+// TODO(hbos): Can we remove AdaptationObserverInterface in favor of
+// ResourceUsageListener? If we need to adapt that is because of resource usage.
+// A multi-stream and multi-resource aware solution needs to sparate the notion
+// of being resource constrained from the decision to downgrade a specific
+// stream.
 class AdaptationObserverInterface {
  public:
   // Indicates if the adaptation is due to overuse of the CPU resources, or if
diff --git a/video/overuse_frame_detector_resource_adaptation_module.cc b/video/overuse_frame_detector_resource_adaptation_module.cc
index 5671607739..7f7041631a 100644
--- a/video/overuse_frame_detector_resource_adaptation_module.cc
+++ b/video/overuse_frame_detector_resource_adaptation_module.cc
@@ -20,6 +20,7 @@
 #include "absl/base/macros.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/video/video_source_interface.h"
+#include "call/adaptation/resource.h"
 #include "call/adaptation/video_source_restrictions.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
@@ -74,15 +75,14 @@ const int kMaxInitialFramedrop = 4;
 
 // Handles interaction with the OveruseDetector.
 class OveruseFrameDetectorResourceAdaptationModule::EncodeUsageResource
-    : public AdaptationObserverInterface {
+    : public Resource,
+      public AdaptationObserverInterface {
  public:
-  EncodeUsageResource(OveruseFrameDetectorResourceAdaptationModule* module,
-                      std::unique_ptr<OveruseFrameDetector> overuse_detector)
-      : module_(module),
-        overuse_detector_(std::move(overuse_detector)),
+  explicit EncodeUsageResource(
+      std::unique_ptr<OveruseFrameDetector> overuse_detector)
+      : overuse_detector_(std::move(overuse_detector)),
         is_started_(false),
         target_frame_rate_(absl::nullopt) {
-    RTC_DCHECK(module_);
     RTC_DCHECK(overuse_detector_);
   }
 
@@ -125,13 +125,16 @@ class OveruseFrameDetectorResourceAdaptationModule::EncodeUsageResource
   }
 
   // AdaptationObserverInterface implementation.
+  // TODO(https://crbug.com/webrtc/11222, 11172): This resource also needs to
+  // signal when its stable to support multi-stream aware modules.
   void AdaptUp(AdaptReason reason) override {
     RTC_DCHECK_EQ(reason, AdaptReason::kCpu);
-    module_->OnResourceUnderuse(reason);
+    OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
   }
   bool AdaptDown(AdaptReason reason) override {
     RTC_DCHECK_EQ(reason, AdaptReason::kCpu);
-    return module_->OnResourceOveruse(reason);
+    return OnResourceUsageStateMeasured(ResourceUsageState::kOveruse) !=
+           ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
   }
 
  private:
@@ -141,7 +144,6 @@ class OveruseFrameDetectorResourceAdaptationModule::EncodeUsageResource
                : std::numeric_limits<int>::max();
   }
 
-  OveruseFrameDetectorResourceAdaptationModule* const module_;
   const std::unique_ptr<OveruseFrameDetector> overuse_detector_;
   bool is_started_;
   absl::optional<double> target_frame_rate_;
@@ -149,13 +151,10 @@ class OveruseFrameDetectorResourceAdaptationModule::EncodeUsageResource
 
 // Handles interaction with the QualityScaler.
 class OveruseFrameDetectorResourceAdaptationModule::QualityScalerResource
-    : public AdaptationObserverInterface {
+    : public Resource,
+      public AdaptationObserverInterface {
  public:
-  explicit QualityScalerResource(
-      OveruseFrameDetectorResourceAdaptationModule* module)
-      : module_(module), quality_scaler_(nullptr) {
-    RTC_DCHECK(module_);
-  }
+  QualityScalerResource() : quality_scaler_(nullptr) {}
 
   bool is_started() const { return quality_scaler_.get(); }
   // TODO(https://crbug.com/webrtc/11222): Don't expose the quality scaler.
@@ -199,17 +198,19 @@ class OveruseFrameDetectorResourceAdaptationModule::QualityScalerResource
   }
 
   // AdaptationObserverInterface implementation.
+  // TODO(https://crbug.com/webrtc/11222, 11172): This resource also needs to
+  // signal when its stable to support multi-stream aware modules.
   void AdaptUp(AdaptReason reason) override {
     RTC_DCHECK_EQ(reason, AdaptReason::kQuality);
-    module_->OnResourceUnderuse(reason);
+    OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
   }
   bool AdaptDown(AdaptReason reason) override {
     RTC_DCHECK_EQ(reason, AdaptReason::kQuality);
-    return module_->OnResourceOveruse(reason);
+    return OnResourceUsageStateMeasured(ResourceUsageState::kOveruse) !=
+           ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
   }
 
  private:
-  OveruseFrameDetectorResourceAdaptationModule* const module_;
   std::unique_ptr<QualityScaler> quality_scaler_;
 };
 
@@ -483,9 +484,8 @@ OveruseFrameDetectorResourceAdaptationModule::
       last_adaptation_request_(absl::nullopt),
       source_restrictor_(std::make_unique<VideoSourceRestrictor>()),
       encode_usage_resource_(
-          std::make_unique<EncodeUsageResource>(this,
-                                                std::move(overuse_detector))),
-      quality_scaler_resource_(std::make_unique<QualityScalerResource>(this)),
+          std::make_unique<EncodeUsageResource>(std::move(overuse_detector))),
+      quality_scaler_resource_(std::make_unique<QualityScalerResource>()),
       quality_scaling_experiment_enabled_(QualityScalingExperiment::Enabled()),
       last_input_frame_size_(absl::nullopt),
       target_frame_rate_(absl::nullopt),
@@ -498,6 +498,8 @@ OveruseFrameDetectorResourceAdaptationModule::
       initial_framedrop_(0) {
   RTC_DCHECK(adaptation_listener_);
   RTC_DCHECK(encoder_stats_observer_);
+  encode_usage_resource_->RegisterListener(this);
+  quality_scaler_resource_->RegisterListener(this);
 }
 
 OveruseFrameDetectorResourceAdaptationModule::
@@ -718,6 +720,46 @@ void OveruseFrameDetectorResourceAdaptationModule::ConfigureQualityScaler(
       GetActiveCounts(AdaptationObserverInterface::AdaptReason::kQuality));
 }
 
+ResourceListenerResponse
+OveruseFrameDetectorResourceAdaptationModule::OnResourceUsageStateMeasured(
+    const Resource& resource) {
+  // If we didn't have this dependency on AdaptReason the module could be
+  // listening to other types of Resources.
+  RTC_DCHECK(&resource == encode_usage_resource_.get() ||
+             &resource == quality_scaler_resource_.get());
+  AdaptationObserverInterface::AdaptReason reason =
+      &resource == encode_usage_resource_.get()
+          ? AdaptationObserverInterface::AdaptReason::kCpu
+          : AdaptationObserverInterface::AdaptReason::kQuality;
+  switch (resource.usage_state()) {
+    case ResourceUsageState::kOveruse:
+      return OnResourceOveruse(reason);
+    case ResourceUsageState::kStable:
+      // Do nothing.
+      //
+      // This module has two resources: |encoude_usage_resource_| and
+      // |quality_scaler_resource_|. A smarter adaptation module might not
+      // attempt to adapt up unless ALL resources were underused, but this
+      // module acts on each resource's measurement in isolation - without
+      // taking the current usage of any other resource into account.
+      return ResourceListenerResponse::kNothing;
+    case ResourceUsageState::kUnderuse:
+      OnResourceUnderuse(reason);
+      return ResourceListenerResponse::kNothing;
+  }
+}
+
+void OveruseFrameDetectorResourceAdaptationModule::OnResourceUnderuseForTesting(
+    AdaptationObserverInterface::AdaptReason reason) {
+  OnResourceUnderuse(reason);
+}
+
+bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruseForTesting(
+    AdaptationObserverInterface::AdaptReason reason) {
+  return OnResourceOveruse(reason) !=
+         ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
+}
+
 void OveruseFrameDetectorResourceAdaptationModule::OnResourceUnderuse(
     AdaptationObserverInterface::AdaptReason reason) {
   if (!has_input_video_)
@@ -832,10 +874,11 @@ void OveruseFrameDetectorResourceAdaptationModule::OnResourceUnderuse(
   RTC_LOG(LS_INFO) << adapt_counter.ToString();
 }
 
-bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
+ResourceListenerResponse
+OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
     AdaptationObserverInterface::AdaptReason reason) {
   if (!has_input_video_)
-    return false;
+    return ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
   AdaptationRequest adaptation_request = {
       LastInputFrameSizeOrDefault(),
       encoder_stats_observer_->GetInputFrameRate(),
@@ -845,8 +888,6 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
       last_adaptation_request_ &&
       last_adaptation_request_->mode_ == AdaptationRequest::Mode::kAdaptDown;
 
-  bool did_adapt = true;
-
   switch (EffectiveDegradataionPreference()) {
     case DegradationPreference::BALANCED:
       break;
@@ -856,7 +897,7 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
               last_adaptation_request_->input_pixel_count_) {
         // Don't request lower resolution if the current resolution is not
         // lower than the last time we asked for the resolution to be lowered.
-        return true;
+        return ResourceListenerResponse::kNothing;
       }
       break;
     case DegradationPreference::MAINTAIN_RESOLUTION:
@@ -869,13 +910,15 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
         // we have to estimate, and can fluctuate naturally over time, don't
         // make the same kind of limitations as for resolution, but trust the
         // overuse detector to not trigger too often.
-        return true;
+        return ResourceListenerResponse::kNothing;
       }
       break;
     case DegradationPreference::DISABLED:
-      return true;
+      return ResourceListenerResponse::kNothing;
   }
 
+  ResourceListenerResponse response = ResourceListenerResponse::kNothing;
+
   switch (EffectiveDegradataionPreference()) {
     case DegradationPreference::BALANCED: {
       // Try scale down framerate, if lower.
@@ -889,7 +932,8 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
         if (min_diff && adaptation_request.framerate_fps_ > 0) {
           int fps_diff = adaptation_request.framerate_fps_ - fps;
           if (fps_diff < min_diff.value()) {
-            did_adapt = false;
+            response =
+                ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
           }
         }
         break;
@@ -909,7 +953,7 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
               &min_pixels_reached)) {
         if (min_pixels_reached)
           encoder_stats_observer_->OnMinPixelLimitReached();
-        return true;
+        return ResourceListenerResponse::kNothing;
       }
       GetAdaptCounter().IncrementResolution(reason);
       break;
@@ -920,7 +964,7 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
           source_restrictor_->RequestFramerateLowerThan(
               adaptation_request.framerate_fps_);
       if (requested_framerate == -1)
-        return true;
+        return ResourceListenerResponse::kNothing;
       GetAdaptCounter().IncrementFramerate(reason);
       break;
     }
@@ -937,7 +981,7 @@ bool OveruseFrameDetectorResourceAdaptationModule::OnResourceOveruse(
   UpdateAdaptationStats(reason);
 
   RTC_LOG(LS_INFO) << GetConstAdaptCounter().ToString();
-  return did_adapt;
+  return response;
 }
 
 // TODO(pbos): Lower these thresholds (to closer to 100%) when we handle
diff --git a/video/overuse_frame_detector_resource_adaptation_module.h b/video/overuse_frame_detector_resource_adaptation_module.h
index 437510be2c..3deb2f7813 100644
--- a/video/overuse_frame_detector_resource_adaptation_module.h
+++ b/video/overuse_frame_detector_resource_adaptation_module.h
@@ -25,6 +25,7 @@
 #include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/video_encoder_config.h"
+#include "call/adaptation/resource.h"
 #include "call/adaptation/resource_adaptation_module_interface.h"
 #include "rtc_base/experiments/balanced_degradation_settings.h"
 #include "rtc_base/experiments/quality_rampup_experiment.h"
@@ -51,7 +52,8 @@ class VideoStreamEncoder;
 // generic interface in VideoStreamEncoder, unblocking other modules from being
 // implemented and used.
 class OveruseFrameDetectorResourceAdaptationModule
-    : public ResourceAdaptationModuleInterface {
+    : public ResourceAdaptationModuleInterface,
+      public ResourceListener {
  public:
   // The module can be constructed on any sequence, but must be initialized and
   // used on a single sequence, e.g. the encoder queue.
@@ -102,14 +104,23 @@ class OveruseFrameDetectorResourceAdaptationModule
   // (https://crbug.com/webrtc/11338)
   void ConfigureQualityScaler(const VideoEncoder::EncoderInfo& encoder_info);
 
-  // Signal that a resource (kCpu or kQuality) is overused or underused. This is
-  // currently used by EncodeUsageResource, QualityScalerResource and testing.
-  // TODO(https://crbug.com/webrtc/11222): Make use of ResourceUsageState and
-  // implement resources per call/adaptation/resource.h. When adaptation happens
-  // because a resource is in specific usage state, get rid of these explicit
-  // triggers.
-  void OnResourceUnderuse(AdaptationObserverInterface::AdaptReason reason);
-  bool OnResourceOveruse(AdaptationObserverInterface::AdaptReason reason);
+  // ResourceUsageListener implementation.
+  ResourceListenerResponse OnResourceUsageStateMeasured(
+      const Resource& resource) override;
+
+  // Public versions of OnResourceUnderuse/OnResourceOveruse only used for
+  // testing.
+  // TODO(https://crbug.com/webrtc/11222): Control overuse/underuse from testing
+  // by injecting fake resources and remove these methods.
+  void OnResourceUnderuseForTesting(
+      AdaptationObserverInterface::AdaptReason reason);
+  // Returns false if OnResourceOveruse() returns
+  // ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency.
+  // TODO(https://crbug.com/webrtc/11222): Get rid of the
+  // ResourceListenerResponse enum and the boolean return value of
+  // AdaptationObserverInterface::AdaptDown() that this method mimics.
+  bool OnResourceOveruseForTesting(
+      AdaptationObserverInterface::AdaptReason reason);
 
  private:
   class EncodeUsageResource;
@@ -132,6 +143,10 @@ class OveruseFrameDetectorResourceAdaptationModule
     int64_t set_start_bitrate_time_ms_ = 0;
   };
 
+  void OnResourceUnderuse(AdaptationObserverInterface::AdaptReason reason);
+  ResourceListenerResponse OnResourceOveruse(
+      AdaptationObserverInterface::AdaptReason reason);
+
   CpuOveruseOptions GetCpuOveruseOptions() const;
   VideoCodecType GetVideoCodecTypeOrGeneric() const;
   int LastInputFrameSizeOrDefault() const;
diff --git a/video/overuse_frame_detector_unittest.cc b/video/overuse_frame_detector_unittest.cc
index 432cc271bd..ad6119007b 100644
--- a/video/overuse_frame_detector_unittest.cc
+++ b/video/overuse_frame_detector_unittest.cc
@@ -49,11 +49,11 @@ class CpuOveruseObserverImpl : public AdaptationObserverInterface {
   CpuOveruseObserverImpl() : overuse_(0), normaluse_(0) {}
   virtual ~CpuOveruseObserverImpl() {}
 
-  bool AdaptDown(AdaptReason) {
+  bool AdaptDown(AdaptReason) override {
     ++overuse_;
     return true;
   }
-  void AdaptUp(AdaptReason) { ++normaluse_; }
+  void AdaptUp(AdaptReason) override { ++normaluse_; }
 
   int overuse_;
   int normaluse_;
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index a8fbac9de9..1ae4856b73 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1580,13 +1580,13 @@ bool VideoStreamEncoder::DropDueToSize(uint32_t pixel_count) const {
 void VideoStreamEncoder::OnResourceUnderuseForTesting(
     AdaptationObserverInterface::AdaptReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
-  resource_adaptation_module_->OnResourceUnderuse(reason);
+  resource_adaptation_module_->OnResourceUnderuseForTesting(reason);
 }
 
 bool VideoStreamEncoder::OnResourceOveruseForTesting(
     AdaptationObserverInterface::AdaptReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
-  return resource_adaptation_module_->OnResourceOveruse(reason);
+  return resource_adaptation_module_->OnResourceOveruseForTesting(reason);
 }
 
 void VideoStreamEncoder::OnVideoSourceRestrictionsUpdated(