diff --git a/video/adaptation/BUILD.gn b/video/adaptation/BUILD.gn
index 755e2f6..c5afb02 100644
--- a/video/adaptation/BUILD.gn
+++ b/video/adaptation/BUILD.gn
@@ -18,6 +18,8 @@
     "encode_usage_resource.h",
     "overuse_frame_detector.cc",
     "overuse_frame_detector.h",
+    "pixel_limit_resource.cc",
+    "pixel_limit_resource.h",
     "quality_rampup_experiment_helper.cc",
     "quality_rampup_experiment_helper.h",
     "quality_scaler_resource.cc",
@@ -34,6 +36,7 @@
     "../../api/adaptation:resource_adaptation_api",
     "../../api/task_queue:task_queue",
     "../../api/units:data_rate",
+    "../../api/units:time_delta",
     "../../api/video:video_adaptation",
     "../../api/video:video_frame",
     "../../api/video:video_stream_encoder",
@@ -73,12 +76,15 @@
     defines = []
     sources = [
       "overuse_frame_detector_unittest.cc",
+      "pixel_limit_resource_unittest.cc",
       "quality_scaler_resource_unittest.cc",
     ]
     deps = [
       ":video_adaptation",
       "../../api:scoped_refptr",
       "../../api/task_queue:task_queue",
+      "../../api/units:time_delta",
+      "../../api/units:timestamp",
       "../../api/video:encoded_image",
       "../../api/video:video_adaptation",
       "../../api/video:video_frame",
@@ -94,10 +100,11 @@
       "../../rtc_base:rtc_numerics",
       "../../rtc_base:rtc_task_queue",
       "../../rtc_base:task_queue_for_test",
+      "../../rtc_base/task_utils:to_queued_task",
       "../../test:field_trial",
-      "//test:rtc_expect_death",
-      "//test:test_support",
-      "//testing/gtest",
+      "../../test:rtc_expect_death",
+      "../../test:test_support",
+      "../../test/time_controller:time_controller",
     ]
     absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
   }
diff --git a/video/adaptation/pixel_limit_resource.cc b/video/adaptation/pixel_limit_resource.cc
new file mode 100644
index 0000000..96c8cac
--- /dev/null
+++ b/video/adaptation/pixel_limit_resource.cc
@@ -0,0 +1,102 @@
+/*
+ *  Copyright 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.
+ */
+
+#include "video/adaptation/pixel_limit_resource.h"
+
+#include "api/units/time_delta.h"
+#include "call/adaptation/video_stream_adapter.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/ref_counted_object.h"
+#include "rtc_base/synchronization/sequence_checker.h"
+
+namespace webrtc {
+
+namespace {
+
+constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
+
+}  // namespace
+
+// static
+rtc::scoped_refptr<PixelLimitResource> PixelLimitResource::Create(
+    TaskQueueBase* task_queue,
+    VideoStreamInputStateProvider* input_state_provider) {
+  return new rtc::RefCountedObject<PixelLimitResource>(task_queue,
+                                                       input_state_provider);
+}
+
+PixelLimitResource::PixelLimitResource(
+    TaskQueueBase* task_queue,
+    VideoStreamInputStateProvider* input_state_provider)
+    : task_queue_(task_queue),
+      input_state_provider_(input_state_provider),
+      max_pixels_(absl::nullopt) {
+  RTC_DCHECK(task_queue_);
+  RTC_DCHECK(input_state_provider_);
+}
+
+PixelLimitResource::~PixelLimitResource() {
+  RTC_DCHECK(!listener_);
+  RTC_DCHECK(!repeating_task_.Running());
+}
+
+void PixelLimitResource::SetMaxPixels(int max_pixels) {
+  RTC_DCHECK_RUN_ON(task_queue_);
+  max_pixels_ = max_pixels;
+}
+
+void PixelLimitResource::SetResourceListener(ResourceListener* listener) {
+  RTC_DCHECK_RUN_ON(task_queue_);
+  listener_ = listener;
+  if (listener_) {
+    repeating_task_.Stop();
+    repeating_task_ = RepeatingTaskHandle::Start(task_queue_, [&] {
+      RTC_DCHECK_RUN_ON(task_queue_);
+      if (!listener_) {
+        // We don't have a listener so resource adaptation must not be running,
+        // try again later.
+        return kResourceUsageCheckIntervalMs;
+      }
+      if (!max_pixels_.has_value()) {
+        // No pixel limit configured yet, try again later.
+        return kResourceUsageCheckIntervalMs;
+      }
+      absl::optional<int> frame_size_pixels =
+          input_state_provider_->InputState().frame_size_pixels();
+      if (!frame_size_pixels.has_value()) {
+        // We haven't observed a frame yet so we don't know if it's going to be
+        // too big or too small, try again later.
+        return kResourceUsageCheckIntervalMs;
+      }
+      int current_pixels = frame_size_pixels.value();
+      int target_pixel_upper_bounds = max_pixels_.value();
+      // To avoid toggling, we allow any resolutions between
+      // |target_pixel_upper_bounds| and video_stream_adapter.h's
+      // GetLowerResolutionThan(). This is the pixels we end up if we adapt down
+      // from |target_pixel_upper_bounds|.
+      int target_pixels_lower_bounds =
+          GetLowerResolutionThan(target_pixel_upper_bounds);
+      if (current_pixels > target_pixel_upper_bounds) {
+        listener_->OnResourceUsageStateMeasured(this,
+                                                ResourceUsageState::kOveruse);
+      } else if (current_pixels < target_pixels_lower_bounds) {
+        listener_->OnResourceUsageStateMeasured(this,
+                                                ResourceUsageState::kUnderuse);
+      }
+      return kResourceUsageCheckIntervalMs;
+    });
+  } else {
+    repeating_task_.Stop();
+  }
+  // The task must be running if we have a listener.
+  RTC_DCHECK(repeating_task_.Running() || !listener_);
+}
+
+}  // namespace webrtc
diff --git a/video/adaptation/pixel_limit_resource.h b/video/adaptation/pixel_limit_resource.h
new file mode 100644
index 0000000..b42f924
--- /dev/null
+++ b/video/adaptation/pixel_limit_resource.h
@@ -0,0 +1,60 @@
+/*
+ *  Copyright 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 VIDEO_ADAPTATION_PIXEL_LIMIT_RESOURCE_H_
+#define VIDEO_ADAPTATION_PIXEL_LIMIT_RESOURCE_H_
+
+#include <string>
+
+#include "absl/types/optional.h"
+#include "api/adaptation/resource.h"
+#include "api/scoped_refptr.h"
+#include "call/adaptation/video_stream_input_state_provider.h"
+#include "rtc_base/task_utils/repeating_task.h"
+#include "rtc_base/thread_annotations.h"
+
+namespace webrtc {
+
+// An adaptation resource designed to be used in the TestBed. Used to simulate
+// being CPU limited.
+//
+// Periodically reports "overuse" or "underuse" (every 5 seconds) until the
+// stream is within the bounds specified in terms of a maximum resolution and
+// one resolution step lower than that (this avoids toggling when this is the
+// only resource in play). When multiple resources come in to play some amount
+// of toggling is still possible in edge cases but that is OK for testing
+// purposes.
+class PixelLimitResource : public Resource {
+ public:
+  static rtc::scoped_refptr<PixelLimitResource> Create(
+      TaskQueueBase* task_queue,
+      VideoStreamInputStateProvider* input_state_provider);
+
+  PixelLimitResource(TaskQueueBase* task_queue,
+                     VideoStreamInputStateProvider* input_state_provider);
+  ~PixelLimitResource() override;
+
+  void SetMaxPixels(int max_pixels);
+
+  // Resource implementation.
+  std::string Name() const override { return "PixelLimitResource"; }
+  void SetResourceListener(ResourceListener* listener) override;
+
+ private:
+  TaskQueueBase* const task_queue_;
+  VideoStreamInputStateProvider* const input_state_provider_;
+  absl::optional<int> max_pixels_ RTC_GUARDED_BY(task_queue_);
+  webrtc::ResourceListener* listener_ RTC_GUARDED_BY(task_queue_);
+  RepeatingTaskHandle repeating_task_ RTC_GUARDED_BY(task_queue_);
+};
+
+}  // namespace webrtc
+
+#endif  // VIDEO_ADAPTATION_PIXEL_LIMIT_RESOURCE_H_
diff --git a/video/adaptation/pixel_limit_resource_unittest.cc b/video/adaptation/pixel_limit_resource_unittest.cc
new file mode 100644
index 0000000..7b633b3
--- /dev/null
+++ b/video/adaptation/pixel_limit_resource_unittest.cc
@@ -0,0 +1,147 @@
+/*
+ *  Copyright 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.
+ */
+
+#include "video/adaptation/pixel_limit_resource.h"
+
+#include <memory>
+#include <utility>
+
+#include "api/units/timestamp.h"
+#include "call/adaptation/test/fake_video_stream_input_state_provider.h"
+#include "call/adaptation/test/mock_resource_listener.h"
+#include "call/adaptation/video_stream_adapter.h"
+#include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/task_utils/to_queued_task.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+#include "test/time_controller/simulated_time_controller.h"
+
+using testing::_;
+
+namespace webrtc {
+
+namespace {
+
+constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
+
+}  // namespace
+
+class PixelLimitResourceTest : public ::testing::Test {
+ public:
+  PixelLimitResourceTest()
+      : time_controller_(Timestamp::Micros(1234)),
+        task_queue_(time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
+            "TestQueue",
+            TaskQueueFactory::Priority::NORMAL)),
+        input_state_provider_() {}
+
+  void SetCurrentPixels(int current_pixels) {
+    input_state_provider_.SetInputState(current_pixels, 30, current_pixels);
+  }
+
+  void RunTaskOnTaskQueue(std::unique_ptr<QueuedTask> task) {
+    task_queue_->PostTask(std::move(task));
+    time_controller_.AdvanceTime(TimeDelta::Millis(0));
+  }
+
+ protected:
+  // Posted tasks, including repeated tasks, are executed when simulated time is
+  // advanced by time_controller_.AdvanceTime().
+  GlobalSimulatedTimeController time_controller_;
+  std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue_;
+  FakeVideoStreamInputStateProvider input_state_provider_;
+};
+
+TEST_F(PixelLimitResourceTest, ResourceIsSilentByDefault) {
+  // Because our mock is strick, the test would fail if
+  // OnResourceUsageStateMeasured() is invoked.
+  testing::StrictMock<MockResourceListener> resource_listener;
+  RunTaskOnTaskQueue(ToQueuedTask([&]() {
+    rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource =
+        PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+    pixel_limit_resource->SetResourceListener(&resource_listener);
+    // Set a current pixel count.
+    SetCurrentPixels(1280 * 720);
+    // Advance a significant amount of time.
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 10);
+    pixel_limit_resource->SetResourceListener(nullptr);
+  }));
+}
+
+TEST_F(PixelLimitResourceTest,
+       OveruseIsReportedWhileCurrentPixelsIsGreaterThanMaxPixels) {
+  constexpr int kMaxPixels = 640 * 480;
+  testing::StrictMock<MockResourceListener> resource_listener;
+  RunTaskOnTaskQueue(ToQueuedTask([&]() {
+    rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource =
+        PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+    pixel_limit_resource->SetResourceListener(&resource_listener);
+    time_controller_.AdvanceTime(TimeDelta::Millis(0));
+
+    pixel_limit_resource->SetMaxPixels(kMaxPixels);
+    SetCurrentPixels(kMaxPixels + 1);
+    EXPECT_CALL(resource_listener,
+                OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
+        .Times(1);
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs);
+
+    // As long as the current pixels has not updated, the overuse signal is
+    // repeated at a fixed interval.
+    EXPECT_CALL(resource_listener,
+                OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
+        .Times(3);
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+
+    // When the overuse signal has resulted in a lower resolution, the overuse
+    // signals stops.
+    SetCurrentPixels(kMaxPixels);
+    EXPECT_CALL(resource_listener, OnResourceUsageStateMeasured(_, _)).Times(0);
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+
+    pixel_limit_resource->SetResourceListener(nullptr);
+  }));
+}
+
+TEST_F(PixelLimitResourceTest,
+       UnderuseIsReportedWhileCurrentPixelsIsLessThanMinPixels) {
+  constexpr int kMaxPixels = 640 * 480;
+  const int kMinPixels = GetLowerResolutionThan(kMaxPixels);
+  testing::StrictMock<MockResourceListener> resource_listener;
+  RunTaskOnTaskQueue(ToQueuedTask([&]() {
+    rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource =
+        PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+    pixel_limit_resource->SetResourceListener(&resource_listener);
+    time_controller_.AdvanceTime(TimeDelta::Millis(0));
+
+    pixel_limit_resource->SetMaxPixels(kMaxPixels);
+    SetCurrentPixels(kMinPixels - 1);
+    EXPECT_CALL(resource_listener,
+                OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
+        .Times(1);
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs);
+
+    // As long as the current pixels has not updated, the underuse signal is
+    // repeated at a fixed interval.
+    EXPECT_CALL(resource_listener,
+                OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
+        .Times(3);
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+
+    // When the underuse signal has resulted in a higher resolution, the
+    // underuse signals stops.
+    SetCurrentPixels(kMinPixels);
+    EXPECT_CALL(resource_listener, OnResourceUsageStateMeasured(_, _)).Times(0);
+    time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+
+    pixel_limit_resource->SetResourceListener(nullptr);
+  }));
+}
+
+}  // namespace webrtc
diff --git a/video/adaptation/video_stream_encoder_resource_manager.cc b/video/adaptation/video_stream_encoder_resource_manager.cc
index 340b2e8..8d532f3 100644
--- a/video/adaptation/video_stream_encoder_resource_manager.cc
+++ b/video/adaptation/video_stream_encoder_resource_manager.cc
@@ -10,6 +10,7 @@
 
 #include "video/adaptation/video_stream_encoder_resource_manager.h"
 
+#include <stdio.h>
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ -30,6 +31,7 @@
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/time_utils.h"
+#include "system_wrappers/include/field_trial.h"
 #include "video/adaptation/quality_scaler_resource.h"
 
 namespace webrtc {
@@ -39,6 +41,9 @@
 
 namespace {
 
+constexpr const char* kPixelLimitResourceFieldTrialName =
+    "WebRTC-PixelLimitResource";
+
 bool IsResolutionScalingEnabled(DegradationPreference degradation_preference) {
   return degradation_preference == DegradationPreference::MAINTAIN_FRAMERATE ||
          degradation_preference == DegradationPreference::BALANCED;
@@ -234,6 +239,7 @@
       encode_usage_resource_(
           EncodeUsageResource::Create(std::move(overuse_detector))),
       quality_scaler_resource_(QualityScalerResource::Create()),
+      pixel_limit_resource_(nullptr),
       encoder_queue_(nullptr),
       input_state_provider_(input_state_provider),
       adaptation_processor_(nullptr),
@@ -298,6 +304,34 @@
   encode_usage_resource_->StartCheckForOveruse(GetCpuOveruseOptions());
 }
 
+void VideoStreamEncoderResourceManager::MaybeInitializePixelLimitResource() {
+  RTC_DCHECK_RUN_ON(encoder_queue_);
+  RTC_DCHECK(adaptation_processor_);
+  RTC_DCHECK(!pixel_limit_resource_);
+  if (!field_trial::IsEnabled(kPixelLimitResourceFieldTrialName)) {
+    // The field trial is not running.
+    return;
+  }
+  int max_pixels = 0;
+  std::string pixel_limit_field_trial =
+      field_trial::FindFullName(kPixelLimitResourceFieldTrialName);
+  if (sscanf(pixel_limit_field_trial.c_str(), "Enabled-%d", &max_pixels) != 1) {
+    RTC_LOG(LS_ERROR) << "Couldn't parse " << kPixelLimitResourceFieldTrialName
+                      << " trial config: " << pixel_limit_field_trial;
+    return;
+  }
+  RTC_LOG(LS_INFO) << "Running field trial "
+                   << kPixelLimitResourceFieldTrialName << " configured to "
+                   << max_pixels << " max pixels";
+  // Configure the specified max pixels from the field trial. The pixel limit
+  // resource is active for the lifetme of the stream (until
+  // StopManagedResources() is called).
+  pixel_limit_resource_ =
+      PixelLimitResource::Create(encoder_queue_->Get(), input_state_provider_);
+  pixel_limit_resource_->SetMaxPixels(max_pixels);
+  AddResource(pixel_limit_resource_, VideoAdaptationReason::kCpu);
+}
+
 void VideoStreamEncoderResourceManager::StopManagedResources() {
   RTC_DCHECK_RUN_ON(encoder_queue_);
   RTC_DCHECK(adaptation_processor_);
@@ -309,6 +343,10 @@
     quality_scaler_resource_->StopCheckForOveruse();
     RemoveResource(quality_scaler_resource_);
   }
+  if (pixel_limit_resource_) {
+    RemoveResource(pixel_limit_resource_);
+    pixel_limit_resource_ = nullptr;
+  }
 }
 
 void VideoStreamEncoderResourceManager::AddResource(
diff --git a/video/adaptation/video_stream_encoder_resource_manager.h b/video/adaptation/video_stream_encoder_resource_manager.h
index 623d17a..30bab53 100644
--- a/video/adaptation/video_stream_encoder_resource_manager.h
+++ b/video/adaptation/video_stream_encoder_resource_manager.h
@@ -46,6 +46,7 @@
 #include "video/adaptation/bitrate_constraint.h"
 #include "video/adaptation/encode_usage_resource.h"
 #include "video/adaptation/overuse_frame_detector.h"
+#include "video/adaptation/pixel_limit_resource.h"
 #include "video/adaptation/quality_rampup_experiment_helper.h"
 #include "video/adaptation/quality_scaler_resource.h"
 #include "video/adaptation/video_stream_encoder_resource.h"
@@ -92,7 +93,11 @@
   DegradationPreference degradation_preference() const;
 
   void EnsureEncodeUsageResourceStarted();
+  // Initializes the pixel limit resource if the "WebRTC-PixelLimitResource"
+  // field trial is enabled. This can be used for testing.
+  void MaybeInitializePixelLimitResource();
   // Stops the encode usage and quality scaler resources if not already stopped.
+  // If the pixel limit resource was created it is also stopped and nulled.
   void StopManagedResources();
 
   // Settings that affect the VideoStreamEncoder-specific resources.
@@ -171,6 +176,7 @@
       RTC_GUARDED_BY(encoder_queue_);
   const rtc::scoped_refptr<EncodeUsageResource> encode_usage_resource_;
   const rtc::scoped_refptr<QualityScalerResource> quality_scaler_resource_;
+  rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource_;
 
   rtc::TaskQueue* encoder_queue_;
   VideoStreamInputStateProvider* const input_state_provider_