diff --git a/api/video/BUILD.gn b/api/video/BUILD.gn
index eb9e919..290c2f2 100644
--- a/api/video/BUILD.gn
+++ b/api/video/BUILD.gn
@@ -234,6 +234,7 @@
   sources = [
     "video_adaptation_counters.cc",
     "video_adaptation_counters.h",
+    "video_adaptation_reason.h",
   ]
 
   deps = [ "../../rtc_base:checks" ]
diff --git a/api/video/video_adaptation_reason.h b/api/video/video_adaptation_reason.h
new file mode 100644
index 0000000..3b7fc36
--- /dev/null
+++ b/api/video/video_adaptation_reason.h
@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2020 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef API_VIDEO_VIDEO_ADAPTATION_REASON_H_
+#define API_VIDEO_VIDEO_ADAPTATION_REASON_H_
+
+namespace webrtc {
+
+enum class VideoAdaptationReason { kQuality, kCpu };
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_VIDEO_ADAPTATION_REASON_H_
diff --git a/api/video/video_stream_encoder_observer.h b/api/video/video_stream_encoder_observer.h
index ab889bc..e027755 100644
--- a/api/video/video_stream_encoder_observer.h
+++ b/api/video/video_stream_encoder_observer.h
@@ -16,6 +16,7 @@
 
 #include "absl/types/optional.h"
 #include "api/video/video_adaptation_counters.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_bitrate_allocation.h"
 #include "api/video/video_codec_constants.h"
 #include "api/video_codecs/video_encoder.h"
@@ -39,14 +40,6 @@
 
 class VideoStreamEncoderObserver : public CpuOveruseMetricsObserver {
  public:
-  // TODO(nisse): There are too many enums to represent this. Besides
-  // this one, see AdaptationObserverInterface::AdaptReason and
-  // WebRtcVideoChannel::AdaptReason.
-  enum class AdaptationReason {
-    kCpu,
-    kQuality,
-  };
-
   struct AdaptationSettings {
     AdaptationSettings()
         : resolution_scaling_enabled(false), framerate_scaling_enabled(false) {}
@@ -90,7 +83,7 @@
       const std::vector<VideoStream>& streams) = 0;
 
   virtual void OnAdaptationChanged(
-      AdaptationReason reason,
+      VideoAdaptationReason reason,
       const VideoAdaptationCounters& cpu_steps,
       const VideoAdaptationCounters& quality_steps) = 0;
   virtual void ClearAdaptationStats() = 0;
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index 0183a3a..3b97cac 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -83,6 +83,7 @@
     "../../api:array_view",
     "../../api:scoped_refptr",
     "../../api/video:encoded_image",
+    "../../api/video:video_adaptation",
     "../../api/video:video_bitrate_allocation",
     "../../api/video:video_bitrate_allocator_factory",
     "../../rtc_base:deprecation",
@@ -153,6 +154,7 @@
     "../../api/units:time_delta",
     "../../api/video:builtin_video_bitrate_allocator_factory",
     "../../api/video:encoded_frame",
+    "../../api/video:video_adaptation",
     "../../api/video:video_bitrate_allocator",
     "../../api/video:video_frame",
     "../../api/video:video_frame_i420",
@@ -303,6 +305,7 @@
     "..:module_api",
     "../../api/video:encoded_frame",
     "../../api/video:encoded_image",
+    "../../api/video:video_adaptation",
     "../../api/video:video_bitrate_allocation",
     "../../api/video:video_bitrate_allocator",
     "../../api/video_codecs:video_codecs_api",
@@ -914,6 +917,7 @@
       "../../api/task_queue:default_task_queue_factory",
       "../../api/test/video:function_video_factory",
       "../../api/video:builtin_video_bitrate_allocator_factory",
+      "../../api/video:video_adaptation",
       "../../api/video:video_bitrate_allocation",
       "../../api/video:video_bitrate_allocator",
       "../../api/video:video_bitrate_allocator_factory",
diff --git a/modules/video_coding/utility/quality_scaler.cc b/modules/video_coding/utility/quality_scaler.cc
index 7e55d31..c3d8b2e 100644
--- a/modules/video_coding/utility/quality_scaler.cc
+++ b/modules/video_coding/utility/quality_scaler.cc
@@ -13,6 +13,7 @@
 #include <memory>
 #include <utility>
 
+#include "api/video/video_adaptation_reason.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/experiments/quality_scaler_settings.h"
 #include "rtc_base/logging.h"
@@ -234,15 +235,14 @@
 void QualityScaler::ReportQpLow() {
   RTC_DCHECK_RUN_ON(&task_checker_);
   ClearSamples();
-  observer_->AdaptUp(AdaptationObserverInterface::AdaptReason::kQuality);
+  observer_->AdaptUp(VideoAdaptationReason::kQuality);
   adapt_called_ = true;
 }
 
 void QualityScaler::ReportQpHigh() {
   RTC_DCHECK_RUN_ON(&task_checker_);
 
-  if (observer_->AdaptDown(
-          AdaptationObserverInterface::AdaptReason::kQuality)) {
+  if (observer_->AdaptDown(VideoAdaptationReason::kQuality)) {
     ClearSamples();
   } else {
     adapt_failed_ = true;
diff --git a/modules/video_coding/utility/quality_scaler.h b/modules/video_coding/utility/quality_scaler.h
index 29d7ad7..d6fd599 100644
--- a/modules/video_coding/utility/quality_scaler.h
+++ b/modules/video_coding/utility/quality_scaler.h
@@ -17,6 +17,7 @@
 #include <memory>
 
 #include "absl/types/optional.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video_codecs/video_encoder.h"
 #include "rtc_base/experiments/quality_scaling_experiment.h"
 #include "rtc_base/numerics/moving_average.h"
@@ -35,16 +36,12 @@
 // stream.
 class AdaptationObserverInterface {
  public:
-  // Indicates if the adaptation is due to overuse of the CPU resources, or if
-  // the quality of the encoded frames have dropped too low.
-  enum AdaptReason : size_t { kQuality = 0, kCpu = 1 };
-  static const size_t kScaleReasonSize = 2;
   // Called to signal that we can handle larger or more frequent frames.
-  virtual void AdaptUp(AdaptReason reason) = 0;
+  virtual void AdaptUp(VideoAdaptationReason reason) = 0;
   // Called to signal that the source should reduce the resolution or framerate.
   // Returns false if a downgrade was requested but the request did not result
   // in a new limiting resolution or fps.
-  virtual bool AdaptDown(AdaptReason reason) = 0;
+  virtual bool AdaptDown(VideoAdaptationReason reason) = 0;
 
  protected:
   virtual ~AdaptationObserverInterface() {}
diff --git a/modules/video_coding/utility/quality_scaler_unittest.cc b/modules/video_coding/utility/quality_scaler_unittest.cc
index 6f16dc8..a000504 100644
--- a/modules/video_coding/utility/quality_scaler_unittest.cc
+++ b/modules/video_coding/utility/quality_scaler_unittest.cc
@@ -13,6 +13,7 @@
 #include <memory>
 #include <string>
 
+#include "api/video/video_adaptation_reason.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_queue_for_test.h"
@@ -32,11 +33,11 @@
  public:
   virtual ~MockAdaptationObserver() {}
 
-  void AdaptUp(AdaptReason r) override {
+  void AdaptUp(VideoAdaptationReason r) override {
     adapt_up_events_++;
     event.Set();
   }
-  bool AdaptDown(AdaptReason r) override {
+  bool AdaptDown(VideoAdaptationReason r) override {
     adapt_down_events_++;
     event.Set();
     return true;
diff --git a/video/BUILD.gn b/video/BUILD.gn
index 9d26ee2..f8ad66b 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -199,6 +199,7 @@
     "../api/task_queue:task_queue",
     "../api/units:data_rate",
     "../api/video:encoded_image",
+    "../api/video:video_adaptation",
     "../api/video:video_bitrate_allocation",
     "../api/video:video_bitrate_allocator",
     "../api/video:video_bitrate_allocator_factory",
@@ -548,6 +549,7 @@
       "../api/units:timestamp",
       "../api/video:builtin_video_bitrate_allocator_factory",
       "../api/video:encoded_image",
+      "../api/video:video_adaptation",
       "../api/video:video_bitrate_allocation",
       "../api/video:video_frame",
       "../api/video:video_frame_i420",
diff --git a/video/adaptation/encode_usage_resource.cc b/video/adaptation/encode_usage_resource.cc
index 385a8b9..45cba1a 100644
--- a/video/adaptation/encode_usage_resource.cc
+++ b/video/adaptation/encode_usage_resource.cc
@@ -13,6 +13,7 @@
 #include <limits>
 #include <utility>
 
+#include "api/video/video_adaptation_reason.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
@@ -65,13 +66,13 @@
                                encode_duration_us);
 }
 
-void EncodeUsageResource::AdaptUp(AdaptReason reason) {
-  RTC_DCHECK_EQ(reason, AdaptReason::kCpu);
+void EncodeUsageResource::AdaptUp(VideoAdaptationReason reason) {
+  RTC_DCHECK_EQ(reason, VideoAdaptationReason::kCpu);
   OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
 }
 
-bool EncodeUsageResource::AdaptDown(AdaptReason reason) {
-  RTC_DCHECK_EQ(reason, AdaptReason::kCpu);
+bool EncodeUsageResource::AdaptDown(VideoAdaptationReason reason) {
+  RTC_DCHECK_EQ(reason, VideoAdaptationReason::kCpu);
   return OnResourceUsageStateMeasured(ResourceUsageState::kOveruse) !=
          ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
 }
diff --git a/video/adaptation/encode_usage_resource.h b/video/adaptation/encode_usage_resource.h
index e626c2f..6c1827d 100644
--- a/video/adaptation/encode_usage_resource.h
+++ b/video/adaptation/encode_usage_resource.h
@@ -15,6 +15,7 @@
 #include <string>
 
 #include "absl/types/optional.h"
+#include "api/video/video_adaptation_reason.h"
 #include "call/adaptation/resource.h"
 #include "modules/video_coding/utility/quality_scaler.h"
 #include "video/adaptation/overuse_frame_detector.h"
@@ -48,8 +49,8 @@
   // 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;
-  bool AdaptDown(AdaptReason reason) override;
+  void AdaptUp(VideoAdaptationReason reason) override;
+  bool AdaptDown(VideoAdaptationReason reason) override;
 
   std::string name() const override { return "EncoderUsageResource"; }
 
diff --git a/video/adaptation/overuse_frame_detector.cc b/video/adaptation/overuse_frame_detector.cc
index 64b6768..abd6f95 100644
--- a/video/adaptation/overuse_frame_detector.cc
+++ b/video/adaptation/overuse_frame_detector.cc
@@ -20,6 +20,7 @@
 #include <string>
 #include <utility>
 
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_frame.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -64,7 +65,7 @@
 const int kMinFramerate = 7;
 const int kMaxFramerate = 30;
 
-const auto kScaleReasonCpu = AdaptationObserverInterface::AdaptReason::kCpu;
+const auto kScaleReasonCpu = VideoAdaptationReason::kCpu;
 
 // Class for calculating the processing usage on the send-side (the average
 // processing time of a frame divided by the average time difference between
diff --git a/video/adaptation/overuse_frame_detector_unittest.cc b/video/adaptation/overuse_frame_detector_unittest.cc
index 5ace2f2..d3eeb53 100644
--- a/video/adaptation/overuse_frame_detector_unittest.cc
+++ b/video/adaptation/overuse_frame_detector_unittest.cc
@@ -14,6 +14,7 @@
 
 #include "api/video/encoded_image.h"
 #include "api/video/i420_buffer.h"
+#include "api/video/video_adaptation_reason.h"
 #include "modules/video_coding/utility/quality_scaler.h"
 #include "rtc_base/event.h"
 #include "rtc_base/fake_clock.h"
@@ -40,8 +41,8 @@
   MockCpuOveruseObserver() {}
   virtual ~MockCpuOveruseObserver() {}
 
-  MOCK_METHOD1(AdaptUp, void(AdaptReason));
-  MOCK_METHOD1(AdaptDown, bool(AdaptReason));
+  MOCK_METHOD1(AdaptUp, void(VideoAdaptationReason));
+  MOCK_METHOD1(AdaptDown, bool(VideoAdaptationReason));
 };
 
 class CpuOveruseObserverImpl : public AdaptationObserverInterface {
@@ -49,11 +50,11 @@
   CpuOveruseObserverImpl() : overuse_(0), normaluse_(0) {}
   virtual ~CpuOveruseObserverImpl() {}
 
-  bool AdaptDown(AdaptReason) override {
+  bool AdaptDown(VideoAdaptationReason) override {
     ++overuse_;
     return true;
   }
-  void AdaptUp(AdaptReason) override { ++normaluse_; }
+  void AdaptUp(VideoAdaptationReason) override { ++normaluse_; }
 
   int overuse_;
   int normaluse_;
@@ -235,7 +236,7 @@
   std::unique_ptr<OveruseFrameDetectorUnderTest> overuse_detector_;
   int encode_usage_percent_ = -1;
 
-  static const auto reason_ = AdaptationObserverInterface::AdaptReason::kCpu;
+  static const auto reason_ = VideoAdaptationReason::kCpu;
 };
 
 // UsagePercent() > high_encode_usage_threshold_percent => overuse.
diff --git a/video/adaptation/quality_scaler_resource.cc b/video/adaptation/quality_scaler_resource.cc
index 489c035..1d5f7dd 100644
--- a/video/adaptation/quality_scaler_resource.cc
+++ b/video/adaptation/quality_scaler_resource.cc
@@ -62,13 +62,13 @@
   }
 }
 
-void QualityScalerResource::AdaptUp(AdaptReason reason) {
-  RTC_DCHECK_EQ(reason, AdaptReason::kQuality);
+void QualityScalerResource::AdaptUp(VideoAdaptationReason reason) {
+  RTC_DCHECK_EQ(reason, VideoAdaptationReason::kQuality);
   OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
 }
 
-bool QualityScalerResource::AdaptDown(AdaptReason reason) {
-  RTC_DCHECK_EQ(reason, AdaptReason::kQuality);
+bool QualityScalerResource::AdaptDown(VideoAdaptationReason reason) {
+  RTC_DCHECK_EQ(reason, VideoAdaptationReason::kQuality);
   return OnResourceUsageStateMeasured(ResourceUsageState::kOveruse) !=
          ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
 }
diff --git a/video/adaptation/quality_scaler_resource.h b/video/adaptation/quality_scaler_resource.h
index 7708710..77bb606 100644
--- a/video/adaptation/quality_scaler_resource.h
+++ b/video/adaptation/quality_scaler_resource.h
@@ -14,6 +14,7 @@
 #include <memory>
 #include <string>
 
+#include "api/video/video_adaptation_reason.h"
 #include "api/video_codecs/video_encoder.h"
 #include "call/adaptation/resource.h"
 #include "modules/video_coding/utility/quality_scaler.h"
@@ -46,8 +47,8 @@
   // 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;
-  bool AdaptDown(AdaptReason reason) override;
+  void AdaptUp(VideoAdaptationReason reason) override;
+  bool AdaptDown(VideoAdaptationReason reason) override;
 
   std::string name() const override { return "QualityScalerResource"; }
 
diff --git a/video/adaptation/resource_adaptation_processor.cc b/video/adaptation/resource_adaptation_processor.cc
index 26d1adc..440f96f 100644
--- a/video/adaptation/resource_adaptation_processor.cc
+++ b/video/adaptation/resource_adaptation_processor.cc
@@ -19,6 +19,7 @@
 #include "absl/algorithm/container.h"
 #include "absl/base/macros.h"
 #include "api/task_queue/task_queue_base.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_source_interface.h"
 #include "call/adaptation/resource.h"
 #include "call/adaptation/video_source_restrictions.h"
@@ -93,13 +94,21 @@
   return counters;
 }
 
-VideoStreamEncoderObserver::AdaptationReason ToAdaptationReason(
-    AdaptationObserverInterface::AdaptReason reason) {
+std::string ToString(VideoAdaptationReason reason) {
   switch (reason) {
-    case AdaptationObserverInterface::kQuality:
-      return VideoStreamEncoderObserver::AdaptationReason::kQuality;
-    case AdaptationObserverInterface::kCpu:
-      return VideoStreamEncoderObserver::AdaptationReason::kCpu;
+    case VideoAdaptationReason::kQuality:
+      return "quality";
+    case VideoAdaptationReason::kCpu:
+      return "cpu";
+  }
+}
+
+VideoAdaptationReason OtherReason(VideoAdaptationReason reason) {
+  switch (reason) {
+    case VideoAdaptationReason::kQuality:
+      return VideoAdaptationReason::kCpu;
+    case VideoAdaptationReason::kCpu:
+      return VideoAdaptationReason::kQuality;
   }
 }
 
@@ -205,10 +214,8 @@
       active_counts_() {
   RTC_DCHECK(adaptation_listener_);
   RTC_DCHECK(encoder_stats_observer_);
-  AddResource(encode_usage_resource_.get(),
-              AdaptationObserverInterface::AdaptReason::kCpu);
-  AddResource(quality_scaler_resource_.get(),
-              AdaptationObserverInterface::AdaptReason::kQuality);
+  AddResource(encode_usage_resource_.get(), VideoAdaptationReason::kCpu);
+  AddResource(quality_scaler_resource_.get(), VideoAdaptationReason::kQuality);
 }
 
 ResourceAdaptationProcessor::~ResourceAdaptationProcessor() {
@@ -240,12 +247,11 @@
 }
 
 void ResourceAdaptationProcessor::AddResource(Resource* resource) {
-  return AddResource(resource, AdaptationObserverInterface::AdaptReason::kCpu);
+  return AddResource(resource, VideoAdaptationReason::kCpu);
 }
 
-void ResourceAdaptationProcessor::AddResource(
-    Resource* resource,
-    AdaptationObserverInterface::AdaptReason reason) {
+void ResourceAdaptationProcessor::AddResource(Resource* resource,
+                                              VideoAdaptationReason reason) {
   RTC_DCHECK(resource);
   RTC_DCHECK(absl::c_find_if(resources_,
                              [resource](const ResourceAndReason& r) {
@@ -268,7 +274,7 @@
   if (stream_adapter_->SetDegradationPreference(degradation_preference) ==
       VideoStreamAdapter::SetDegradationPreferenceResult::
           kRestrictionsCleared) {
-    active_counts_.fill(VideoAdaptationCounters());
+    ResetActiveCounts();
     encoder_stats_observer_->ClearAdaptationStats();
   }
   MaybeUpdateVideoSourceRestrictions();
@@ -305,7 +311,7 @@
 
 void ResourceAdaptationProcessor::ResetVideoSourceRestrictions() {
   stream_adapter_->ClearRestrictions();
-  active_counts_.fill(VideoAdaptationCounters());
+  ResetActiveCounts();
   encoder_stats_observer_->ClearAdaptationStats();
   MaybeUpdateVideoSourceRestrictions();
 }
@@ -317,12 +323,12 @@
 void ResourceAdaptationProcessor::OnFrameDroppedDueToSize() {
   VideoAdaptationCounters counters_before =
       stream_adapter_->adaptation_counters();
-  OnResourceOveruse(AdaptationObserverInterface::AdaptReason::kQuality);
+  OnResourceOveruse(VideoAdaptationReason::kQuality);
   if (degradation_preference() == DegradationPreference::BALANCED &&
       stream_adapter_->adaptation_counters().fps_adaptations >
           counters_before.fps_adaptations) {
     // Adapt framerate in same step as resolution.
-    OnResourceOveruse(AdaptationObserverInterface::AdaptReason::kQuality);
+    OnResourceOveruse(VideoAdaptationReason::kQuality);
   }
   if (stream_adapter_->adaptation_counters().resolution_adaptations >
       counters_before.resolution_adaptations) {
@@ -428,8 +434,7 @@
   RTC_DCHECK(registered_resource != resources_.end())
       << resource.name() << " not found.";
 
-  const AdaptationObserverInterface::AdaptReason reason =
-      registered_resource->reason;
+  const VideoAdaptationReason reason = registered_resource->reason;
   switch (resource.usage_state()) {
     case ResourceUsageState::kOveruse:
       return OnResourceOveruse(reason);
@@ -449,7 +454,7 @@
 }
 
 void ResourceAdaptationProcessor::OnResourceUnderuse(
-    AdaptationObserverInterface::AdaptReason reason) {
+    VideoAdaptationReason reason) {
   // We can't adapt up if we're already at the highest setting.
   // Note that this only includes counts relevant to the current degradation
   // preference. e.g. we previously adapted resolution, now prefer adpating fps,
@@ -489,7 +494,7 @@
 }
 
 ResourceListenerResponse ResourceAdaptationProcessor::OnResourceOveruse(
-    AdaptationObserverInterface::AdaptReason reason) {
+    VideoAdaptationReason reason) {
   if (!has_input_video_)
     return ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
   // Update video input states and encoder settings for accurate adaptation.
@@ -643,22 +648,19 @@
   RTC_DCHECK_GE(other_active->fps_adaptations, 0);
 }
 
-// TODO(nisse): Delete, once AdaptReason and AdaptationReason are merged.
 void ResourceAdaptationProcessor::UpdateAdaptationStats(
-    AdaptationObserverInterface::AdaptReason reason) {
+    VideoAdaptationReason reason) {
   // Update active counts
   VideoAdaptationCounters& active_count = active_counts_[reason];
-  VideoAdaptationCounters& other_active = active_counts_[(reason + 1) % 2];
+  VideoAdaptationCounters& other_active = active_counts_[OtherReason(reason)];
   const VideoAdaptationCounters total_counts =
       stream_adapter_->adaptation_counters();
 
   OnAdaptationCountChanged(total_counts, &active_count, &other_active);
 
   encoder_stats_observer_->OnAdaptationChanged(
-      ToAdaptationReason(reason),
-      std::get<AdaptationObserverInterface::AdaptReason::kCpu>(active_counts_),
-      std::get<AdaptationObserverInterface::AdaptReason::kQuality>(
-          active_counts_));
+      reason, active_counts_[VideoAdaptationReason::kCpu],
+      active_counts_[VideoAdaptationReason::kQuality]);
 }
 
 void ResourceAdaptationProcessor::UpdateStatsAdaptationSettings() const {
@@ -710,9 +712,9 @@
   // TODO(https://crbug.com/webrtc/11392): See if we can rely on the total
   // counts or the stats, and not the active counts.
   const VideoAdaptationCounters& qp_counts =
-      std::get<AdaptationObserverInterface::kQuality>(active_counts_);
+      active_counts_[VideoAdaptationReason::kQuality];
   const VideoAdaptationCounters& cpu_counts =
-      std::get<AdaptationObserverInterface::kCpu>(active_counts_);
+      active_counts_[VideoAdaptationReason::kCpu];
   if (try_quality_rampup && qp_counts.resolution_adaptations > 0 &&
       cpu_counts.Total() == 0) {
     RTC_LOG(LS_INFO) << "Reset quality limitations.";
@@ -721,18 +723,25 @@
   }
 }
 
+void ResourceAdaptationProcessor::ResetActiveCounts() {
+  active_counts_.clear();
+  active_counts_[VideoAdaptationReason::kCpu] = VideoAdaptationCounters();
+  active_counts_[VideoAdaptationReason::kQuality] = VideoAdaptationCounters();
+}
+
 std::string ResourceAdaptationProcessor::ActiveCountsToString() const {
+  RTC_DCHECK_EQ(2, active_counts_.size());
   rtc::StringBuilder ss;
 
   ss << "Downgrade counts: fps: {";
-  for (size_t reason = 0; reason < active_counts_.size(); ++reason) {
-    ss << (reason ? " cpu" : "quality") << ":";
-    ss << active_counts_[reason].fps_adaptations;
+  for (auto& reason_count : active_counts_) {
+    ss << ToString(reason_count.first) << ":";
+    ss << reason_count.second.fps_adaptations;
   }
   ss << "}, resolution {";
-  for (size_t reason = 0; reason < active_counts_.size(); ++reason) {
-    ss << (reason ? " cpu" : "quality") << ":";
-    ss << active_counts_[reason].resolution_adaptations;
+  for (auto& reason_count : active_counts_) {
+    ss << ToString(reason_count.first) << ":";
+    ss << reason_count.second.resolution_adaptations;
   }
   ss << "}";
 
diff --git a/video/adaptation/resource_adaptation_processor.h b/video/adaptation/resource_adaptation_processor.h
index aaaf5fb..922c624 100644
--- a/video/adaptation/resource_adaptation_processor.h
+++ b/video/adaptation/resource_adaptation_processor.h
@@ -14,12 +14,14 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "absl/types/optional.h"
 #include "api/rtp_parameters.h"
 #include "api/video/video_adaptation_counters.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_frame.h"
 #include "api/video/video_source_interface.h"
 #include "api/video/video_stream_encoder_observer.h"
@@ -78,8 +80,7 @@
   void StopResourceAdaptation() override;
   // Uses a default AdaptReason of kCpu.
   void AddResource(Resource* resource) override;
-  void AddResource(Resource* resource,
-                   AdaptationObserverInterface::AdaptReason reason);
+  void AddResource(Resource* resource, VideoAdaptationReason reason);
   void SetHasInputVideo(bool has_input_video) override;
   void SetDegradationPreference(
       DegradationPreference degradation_preference) override;
@@ -134,9 +135,8 @@
 
   // Performs the adaptation by getting the next target, applying it and
   // informing listeners of the new VideoSourceRestriction and adapt counters.
-  void OnResourceUnderuse(AdaptationObserverInterface::AdaptReason reason);
-  ResourceListenerResponse OnResourceOveruse(
-      AdaptationObserverInterface::AdaptReason reason);
+  void OnResourceUnderuse(VideoAdaptationReason reason);
+  ResourceListenerResponse OnResourceOveruse(VideoAdaptationReason reason);
 
   CpuOveruseOptions GetCpuOveruseOptions() const;
   int LastInputFrameSizeOrDefault() const;
@@ -154,7 +154,7 @@
   void UpdateQualityScalerSettings(
       absl::optional<VideoEncoder::QpThresholds> qp_thresholds);
 
-  void UpdateAdaptationStats(AdaptationObserverInterface::AdaptReason reason);
+  void UpdateAdaptationStats(VideoAdaptationReason reason);
   void UpdateStatsAdaptationSettings() const;
 
   // Checks to see if we should execute the quality rampup experiment. The
@@ -165,6 +165,7 @@
   void MaybePerformQualityRampupExperiment();
   void ResetVideoSourceRestrictions();
 
+  void ResetActiveCounts();
   std::string ActiveCountsToString() const;
 
   ResourceAdaptationProcessorListener* const adaptation_listener_;
@@ -199,13 +200,12 @@
   // Ties a resource to a reason for statistical reporting. This AdaptReason is
   // also used by this module to make decisions about how to adapt up/down.
   struct ResourceAndReason {
-    ResourceAndReason(Resource* resource,
-                      AdaptationObserverInterface::AdaptReason reason)
+    ResourceAndReason(Resource* resource, VideoAdaptationReason reason)
         : resource(resource), reason(reason) {}
     virtual ~ResourceAndReason() = default;
 
     Resource* const resource;
-    const AdaptationObserverInterface::AdaptReason reason;
+    const VideoAdaptationReason reason;
   };
   std::vector<ResourceAndReason> resources_;
   // One AdaptationCounter for each reason, tracking the number of times we have
@@ -215,8 +215,7 @@
   // encoder_stats_observer_; Counters used for deciding if the video resolution
   // or framerate is currently restricted, and if so, why, on a per degradation
   // preference basis.
-  std::array<VideoAdaptationCounters,
-             AdaptationObserverInterface::kScaleReasonSize>
+  std::unordered_map<VideoAdaptationReason, VideoAdaptationCounters>
       active_counts_;
 };
 
diff --git a/video/adaptation/video_stream_adapter.cc b/video/adaptation/video_stream_adapter.cc
index 6aef432..566f67d 100644
--- a/video/adaptation/video_stream_adapter.cc
+++ b/video/adaptation/video_stream_adapter.cc
@@ -15,6 +15,7 @@
 #include <utility>
 
 #include "absl/types/optional.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video_codecs/video_encoder.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/logging.h"
@@ -385,7 +386,7 @@
 }
 
 Adaptation VideoStreamAdapter::GetAdaptationUp(
-    AdaptationObserverInterface::AdaptReason reason) const {
+    VideoAdaptationReason reason) const {
   // Don't adapt if we don't have sufficient input.
   if (input_mode_ == VideoInputMode::kNoVideo) {
     return Adaptation(adaptation_validation_id_,
@@ -403,7 +404,7 @@
   }
   // Don't adapt if BalancedDegradationSettings applies and determines this will
   // exceed bitrate constraints.
-  if (reason == AdaptationObserverInterface::AdaptReason::kQuality &&
+  if (reason == VideoAdaptationReason::kQuality &&
       EffectiveDegradationPreference() == DegradationPreference::BALANCED &&
       !balanced_settings_.CanAdaptUp(
           GetVideoCodecTypeOrGeneric(encoder_settings_), input_pixels_,
@@ -426,7 +427,7 @@
       }
       // Fall-through to maybe-adapting resolution, unless |balanced_settings_|
       // forbids it based on bitrate.
-      if (reason == AdaptationObserverInterface::AdaptReason::kQuality &&
+      if (reason == VideoAdaptationReason::kQuality &&
           !balanced_settings_.CanAdaptUpResolution(
               GetVideoCodecTypeOrGeneric(encoder_settings_), input_pixels_,
               encoder_target_bitrate_bps_.value_or(0))) {
@@ -439,7 +440,7 @@
     case DegradationPreference::MAINTAIN_FRAMERATE: {
       // Don't adapt resolution if CanAdaptUpResolution() forbids it based on
       // bitrate and limits specified by encoder capabilities.
-      if (reason == AdaptationObserverInterface::AdaptReason::kQuality &&
+      if (reason == VideoAdaptationReason::kQuality &&
           !CanAdaptUpResolution(encoder_settings_, encoder_target_bitrate_bps_,
                                 input_pixels_)) {
         return Adaptation(adaptation_validation_id_,
diff --git a/video/adaptation/video_stream_adapter.h b/video/adaptation/video_stream_adapter.h
index 073b5ab..30f95d0 100644
--- a/video/adaptation/video_stream_adapter.h
+++ b/video/adaptation/video_stream_adapter.h
@@ -16,6 +16,7 @@
 #include "absl/types/optional.h"
 #include "api/rtp_parameters.h"
 #include "api/video/video_adaptation_counters.h"
+#include "api/video/video_adaptation_reason.h"
 #include "call/adaptation/encoder_settings.h"
 #include "call/adaptation/resource.h"
 #include "call/adaptation/video_source_restrictions.h"
@@ -160,8 +161,7 @@
 
   // Returns an adaptation that we are guaranteed to be able to apply, or a
   // status code indicating the reason why we cannot adapt.
-  Adaptation GetAdaptationUp(
-      AdaptationObserverInterface::AdaptReason reason) const;
+  Adaptation GetAdaptationUp(VideoAdaptationReason reason) const;
   Adaptation GetAdaptationDown() const;
   // Returns the restrictions that result from applying the adaptation, without
   // actually applying it. If the adaptation is not valid, current restrictions
diff --git a/video/adaptation/video_stream_adapter_unittest.cc b/video/adaptation/video_stream_adapter_unittest.cc
index 46f662b..c85446b 100644
--- a/video/adaptation/video_stream_adapter_unittest.cc
+++ b/video/adaptation/video_stream_adapter_unittest.cc
@@ -14,6 +14,7 @@
 #include <utility>
 
 #include "absl/types/optional.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/video_encoder_config.h"
@@ -31,7 +32,7 @@
 
 // GetAdaptationUp() requires an AdaptReason. This is only used in edge cases,
 // so most tests don't care what reason is used.
-const auto kReasonDontCare = AdaptationObserverInterface::AdaptReason::kQuality;
+const auto kReasonDontCare = VideoAdaptationReason::kQuality;
 
 const int kBalancedHighResolutionPixels = 1280 * 720;
 const int kBalancedHighFrameRateFps = 30;
@@ -636,11 +637,8 @@
   // TODO(hbos): Why would the reason matter? If the signal was kCpu then the
   // current code allows us to violate this bitrate constraint. This does not
   // make any sense: either we are limited or we are not, end of story.
-  EXPECT_EQ(
-      Adaptation::Status::kIsBitrateConstrained,
-      adapter
-          .GetAdaptationUp(AdaptationObserverInterface::AdaptReason::kQuality)
-          .status());
+  EXPECT_EQ(Adaptation::Status::kIsBitrateConstrained,
+            adapter.GetAdaptationUp(VideoAdaptationReason::kQuality).status());
 }
 
 TEST(VideoStreamAdapterTest, PeekNextRestrictions) {
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index b973275..1cb059d 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -1098,7 +1098,7 @@
 }
 
 void SendStatisticsProxy::OnAdaptationChanged(
-    AdaptationReason reason,
+    VideoAdaptationReason reason,
     const VideoAdaptationCounters& cpu_counters,
     const VideoAdaptationCounters& quality_counters) {
   rtc::CritScope lock(&crit_);
@@ -1107,10 +1107,10 @@
   adaptations_.set_cpu_counts(cpu_counters);
   adaptations_.set_quality_counts(quality_counters);
   switch (reason) {
-    case AdaptationReason::kCpu:
+    case VideoAdaptationReason::kCpu:
       ++stats_.number_of_cpu_adapt_changes;
       break;
-    case AdaptationReason::kQuality:
+    case VideoAdaptationReason::kQuality:
       TryUpdateInitialQualityResolutionAdaptUp(
           receiver.resolution_adaptations,
           adaptations_.MaskedQualityCounts().resolution_adaptations);
diff --git a/video/send_statistics_proxy.h b/video/send_statistics_proxy.h
index 1bd79d8..08717ca 100644
--- a/video/send_statistics_proxy.h
+++ b/video/send_statistics_proxy.h
@@ -71,7 +71,7 @@
 
   // Adaptation stats.
   void OnAdaptationChanged(
-      AdaptationReason reason,
+      VideoAdaptationReason reason,
       const VideoAdaptationCounters& cpu_counters,
       const VideoAdaptationCounters& quality_counters) override;
   void ClearAdaptationStats() override;
diff --git a/video/send_statistics_proxy_unittest.cc b/video/send_statistics_proxy_unittest.cc
index aad9b3d..b69dfad 100644
--- a/video/send_statistics_proxy_unittest.cc
+++ b/video/send_statistics_proxy_unittest.cc
@@ -18,6 +18,7 @@
 
 #include "absl/algorithm/container.h"
 #include "api/units/timestamp.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_bitrate_allocation.h"
 #include "api/video/video_codec_type.h"
 #include "api/video_codecs/video_codec.h"
@@ -449,31 +450,27 @@
   cpu_counts.fps_adaptations = 1;
   cpu_counts.resolution_adaptations = 0;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
   cpu_counts.fps_adaptations = 0;
   cpu_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
   cpu_counts.fps_adaptations = 1;
   statistics_proxy_->UpdateAdaptationSettings(kResolutionScalingDisabled,
                                               kResolutionScalingDisabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
   statistics_proxy_->UpdateAdaptationSettings(kScalingDisabled,
                                               kScalingDisabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
 }
@@ -486,31 +483,27 @@
   quality_counts.fps_adaptations = 1;
   quality_counts.resolution_adaptations = 0;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   quality_counts.fps_adaptations = 0;
   quality_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
   quality_counts.fps_adaptations = 1;
   statistics_proxy_->UpdateAdaptationSettings(kResolutionScalingDisabled,
                                               kResolutionScalingDisabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   statistics_proxy_->UpdateAdaptationSettings(kScalingDisabled,
                                               kScalingDisabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
 }
@@ -522,17 +515,15 @@
   EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
 
   cpu_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_EQ(1, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
 
   cpu_counts.resolution_adaptations = 2;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_EQ(2, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
@@ -546,17 +537,15 @@
   EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
 
   quality_counts.fps_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   EXPECT_EQ(1, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
 
   quality_counts.fps_adaptations = 0;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
   EXPECT_EQ(2, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
@@ -571,21 +560,17 @@
   EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
 
   quality_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   quality_counts.fps_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   cpu_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   cpu_counts.fps_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   // We have 1 fps and resolution reduction for both cpu and quality
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
@@ -686,9 +671,8 @@
   VideoAdaptationCounters quality_counts;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   // Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_.reset();
   EXPECT_METRIC_EQ(
@@ -705,9 +689,8 @@
   VideoAdaptationCounters quality_counts;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   // Adapt changes: 1 (1 initial) = 0, elapsed time: 10 sec => 0 per minute.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_.reset();
@@ -726,19 +709,16 @@
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   // Adapt changes: 3 (2 initial) = 1, elapsed time: 10 sec => 6 per minute.
   quality_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   quality_counts.resolution_adaptations = 2;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   quality_counts.resolution_adaptations = 3;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_.reset();
   EXPECT_METRIC_EQ(
@@ -755,9 +735,8 @@
   VideoAdaptationCounters quality_counts;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   // Adapt changes: 1 (2 initial) = 1, elapsed time: 10 sec => 6 per minute.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   fake_clock_.AdvanceTimeMilliseconds(10000);
@@ -778,39 +757,31 @@
   statistics_proxy_->ClearAdaptationStats();
   // Adapt changes: 8 (4 initial) = 4, elapsed time: 10 sec => 24 per minute.
   quality_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   quality_counts.resolution_adaptations = 2;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnInitialQualityResolutionAdaptDown();
   quality_counts.resolution_adaptations = 3;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   quality_counts.fps_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   quality_counts.fps_adaptations = 0;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   quality_counts.resolution_adaptations = 2;  // Initial resolution up.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   quality_counts.resolution_adaptations = 1;  // Initial resolution up.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   quality_counts.resolution_adaptations = 0;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
 
   fake_clock_.AdvanceTimeMilliseconds(10000);
   statistics_proxy_.reset();
@@ -840,13 +811,11 @@
   statistics_proxy_->UpdateAdaptationSettings(kResolutionScalingDisabled,
                                               kResolutionScalingDisabled);
   fake_clock_.AdvanceTimeMilliseconds(9000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(6000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
 
   // Disable quality adaptation.
   statistics_proxy_->UpdateAdaptationSettings(kScalingDisabled,
@@ -858,9 +827,8 @@
   quality_counts.resolution_adaptations = 0;
   statistics_proxy_->UpdateAdaptationSettings(kFramerateScalingDisabled,
                                               kFramerateScalingDisabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
 
   // Disable quality adaptation.
@@ -908,12 +876,10 @@
   // Adapt changes: 2, elapsed time: 20 sec.
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   fake_clock_.AdvanceTimeMilliseconds(20000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
 
   // Suspend and resume video.
   statistics_proxy_->OnSuspendChange(true);
@@ -921,9 +887,8 @@
   statistics_proxy_->OnSuspendChange(false);
 
   // Adapt changes: 1, elapsed time: 10 sec.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(10000);
 
   // Adapt changes: 3, elapsed time: 30 sec => 6 per minute.
@@ -948,9 +913,8 @@
   // Adapt changes: 1, elapsed time: 20 sec.
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   fake_clock_.AdvanceTimeMilliseconds(10000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   // Video not suspended, stats time already started.
   statistics_proxy_->OnSuspendChange(false);
@@ -973,9 +937,8 @@
   cpu_counts.resolution_adaptations = 0;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
   fake_clock_.AdvanceTimeMilliseconds(10000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   // Adapt changes: 2, elapsed time: 30 sec => 4 per minute.
   statistics_proxy_.reset();
@@ -1002,9 +965,8 @@
   // Adapt changes: 1, elapsed time: 10 sec.
   statistics_proxy_->OnSuspendChange(false);
   fake_clock_.AdvanceTimeMilliseconds(10000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   // Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
   statistics_proxy_.reset();
@@ -1025,9 +987,8 @@
 
   // Adapt changes: 1, elapsed time: 10 sec.
   fake_clock_.AdvanceTimeMilliseconds(10000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   UpdateDataCounters(kFirstSsrc);
 
   // Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
@@ -1061,9 +1022,8 @@
 
   // Adapt changes: 1, elapsed time: 20 sec.
   fake_clock_.AdvanceTimeMilliseconds(10000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   // Adapt changes: 1, elapsed time: 20 sec => 3 per minute.
   statistics_proxy_.reset();
@@ -1082,13 +1042,11 @@
                                               kScalingDisabled);
 
   // Adapt changes: 2, elapsed time: 15 sec => 8 per minute.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(6000);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(9000);
 
   // Switch content type, real-time stats should be updated.
@@ -1108,18 +1066,14 @@
                                               kScalingDisabled);
 
   // Adapt changes: 4, elapsed time: 120 sec => 2 per minute.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(120000);
 
   statistics_proxy_.reset();
@@ -1141,9 +1095,8 @@
 
   cpu_counts.resolution_adaptations = 1;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   EXPECT_EQ(QualityLimitationReason::kCpu,
             statistics_proxy_->GetStats().quality_limitation_reason);
@@ -1157,9 +1110,8 @@
   cpu_counts.fps_adaptations = 1;
 
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   EXPECT_EQ(QualityLimitationReason::kCpu,
             statistics_proxy_->GetStats().quality_limitation_reason);
@@ -1173,9 +1125,8 @@
   quality_counts.resolution_adaptations = 1;
 
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
 
   EXPECT_EQ(QualityLimitationReason::kBandwidth,
             statistics_proxy_->GetStats().quality_limitation_reason);
@@ -1189,9 +1140,8 @@
   quality_counts.fps_adaptations = 1;
 
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
 
   EXPECT_EQ(QualityLimitationReason::kBandwidth,
             statistics_proxy_->GetStats().quality_limitation_reason);
@@ -1208,9 +1158,8 @@
 
   // Even if the last adaptation reason is kCpu, if the counters indicate being
   // both CPU and quality (=bandwidth) limited, kBandwidth takes precedence.
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   EXPECT_EQ(QualityLimitationReason::kBandwidth,
             statistics_proxy_->GetStats().quality_limitation_reason);
@@ -1224,14 +1173,12 @@
   // due to "none" being the default value.
   cpu_counts.resolution_adaptations = 1;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   // Go back to not being limited.
   cpu_counts.resolution_adaptations = 0;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   EXPECT_EQ(QualityLimitationReason::kNone,
             statistics_proxy_->GetStats().quality_limitation_reason);
@@ -1246,23 +1193,20 @@
   fake_clock_.AdvanceTimeMilliseconds(3000);
   // CPU limited for 2000 ms
   cpu_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(2000);
   // Bandwidth limited for 1000 ms
   cpu_counts.resolution_adaptations = 0;
   quality_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(1000);
   // CPU limited for another 2000 ms
   cpu_counts.resolution_adaptations = 1;
   quality_counts.resolution_adaptations = 0;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
   fake_clock_.AdvanceTimeMilliseconds(2000);
 
   auto quality_limitation_durations_ms =
@@ -1687,9 +1631,8 @@
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
 
   cpu_counts.resolution_adaptations = 1;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
+                                         cpu_counts, quality_counts);
 
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
@@ -2110,9 +2053,8 @@
   VideoAdaptationCounters quality_counts;
   quality_counts.resolution_adaptations = kDownscales;
   statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   EncodedImage encoded_image;
   encoded_image.SetSpatialIndex(0);
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
@@ -2159,17 +2101,15 @@
   quality_counts.resolution_adaptations = 1;
   statistics_proxy_->UpdateAdaptationSettings(kFramerateScalingDisabled,
                                               kFramerateScalingDisabled);
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
 
   // Adapt up.
   quality_counts.resolution_adaptations = 0;
-  statistics_proxy_->OnAdaptationChanged(
-      VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
-      quality_counts);
+  statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
+                                         cpu_counts, quality_counts);
   statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
   EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
 
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 6ce392f..38665d8 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -21,6 +21,7 @@
 #include "absl/types/optional.h"
 #include "api/video/encoded_image.h"
 #include "api/video/i420_buffer.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_bitrate_allocator_factory.h"
 #include "api/video/video_codec_constants.h"
 #include "api/video_codecs/video_encoder.h"
@@ -1917,7 +1918,7 @@
 }
 void VideoStreamEncoder::InjectAdaptationResource(
     Resource* resource,
-    AdaptationObserverInterface::AdaptReason reason) {
+    VideoAdaptationReason reason) {
   resource_adaptation_processor_->AddResource(resource, reason);
 }
 
diff --git a/video/video_stream_encoder.h b/video/video_stream_encoder.h
index 4963fb8..1d2dda1 100644
--- a/video/video_stream_encoder.h
+++ b/video/video_stream_encoder.h
@@ -112,7 +112,7 @@
   // Used for injected test resources.
   // TODO(eshr): Move all adaptation tests out of VideoStreamEncoder tests.
   void InjectAdaptationResource(Resource* resource,
-                                AdaptationObserverInterface::AdaptReason reason)
+                                VideoAdaptationReason reason)
       RTC_RUN_ON(&encoder_queue_);
 
  private:
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index d3baa37..44ac6e1 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -21,6 +21,7 @@
 #include "api/test/mock_video_encoder.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/i420_buffer.h"
+#include "api/video/video_adaptation_reason.h"
 #include "api/video/video_bitrate_allocation.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
@@ -48,7 +49,7 @@
 
 namespace webrtc {
 
-using ScaleReason = AdaptationObserverInterface::AdaptReason;
+using ScaleReason = VideoAdaptationReason;
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Field;
@@ -164,20 +165,18 @@
         fake_quality_resource_(
             std::make_unique<FakeResource>(ResourceUsageState::kStable,
                                            "FakeResource[QP]")) {
-    InjectAdaptationResource(
-        fake_quality_resource_.get(),
-        AdaptationObserverInterface::AdaptReason::kQuality);
+    InjectAdaptationResource(fake_quality_resource_.get(),
+                             VideoAdaptationReason::kQuality);
     InjectAdaptationResource(fake_cpu_resource_.get(),
-                             AdaptationObserverInterface::AdaptReason::kCpu);
+                             VideoAdaptationReason::kCpu);
   }
 
-  void PostTaskAndWait(bool down,
-                       AdaptationObserverInterface::AdaptReason reason) {
+  void PostTaskAndWait(bool down, VideoAdaptationReason reason) {
     PostTaskAndWait(down, reason, /*expected_results=*/true);
   }
 
   void PostTaskAndWait(bool down,
-                       AdaptationObserverInterface::AdaptReason reason,
+                       VideoAdaptationReason reason,
                        bool expected_results) {
     rtc::Event event;
     encoder_queue()->PostTask([this, &event, reason, down, expected_results] {
@@ -186,10 +185,10 @@
 
       FakeResource* resource = nullptr;
       switch (reason) {
-        case AdaptationObserverInterface::kQuality:
+        case VideoAdaptationReason::kQuality:
           resource = fake_quality_resource_.get();
           break;
-        case AdaptationObserverInterface::kCpu:
+        case VideoAdaptationReason::kCpu:
           resource = fake_cpu_resource_.get();
           break;
         default:
@@ -198,7 +197,7 @@
 
       resource->set_usage_state(usage_state);
       if (!expected_results) {
-        ASSERT_EQ(AdaptationObserverInterface::kQuality, reason)
+        ASSERT_EQ(VideoAdaptationReason::kQuality, reason)
             << "We can only assert adaptation result for quality resources";
         EXPECT_EQ(
             ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency,
@@ -222,29 +221,24 @@
   }
 
   void TriggerCpuOveruse() {
-    PostTaskAndWait(/*down=*/true,
-                    AdaptationObserverInterface::AdaptReason::kCpu);
+    PostTaskAndWait(/*down=*/true, VideoAdaptationReason::kCpu);
   }
 
   void TriggerCpuNormalUsage() {
-    PostTaskAndWait(/*down=*/false,
-                    AdaptationObserverInterface::AdaptReason::kCpu);
+    PostTaskAndWait(/*down=*/false, VideoAdaptationReason::kCpu);
   }
 
   void TriggerQualityLow() {
-    PostTaskAndWait(/*down=*/true,
-                    AdaptationObserverInterface::AdaptReason::kQuality);
+    PostTaskAndWait(/*down=*/true, VideoAdaptationReason::kQuality);
   }
 
   void TriggerQualityLowExpectFalse() {
-    PostTaskAndWait(/*down=*/true,
-                    AdaptationObserverInterface::AdaptReason::kQuality,
+    PostTaskAndWait(/*down=*/true, VideoAdaptationReason::kQuality,
                     /*expected_results=*/false);
   }
 
   void TriggerQualityHigh() {
-    PostTaskAndWait(/*down=*/false,
-                    AdaptationObserverInterface::AdaptReason::kQuality);
+    PostTaskAndWait(/*down=*/false, VideoAdaptationReason::kQuality);
   }
 
   CpuOveruseDetectorProxy* overuse_detector_proxy_;