diff --git a/api/BUILD.gn b/api/BUILD.gn
index 5bf7396..9445e3c 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -454,7 +454,6 @@
     "../rtc_base:checks",
     "../rtc_base:stringutils",
     "../rtc_base/system:rtc_export",
-    "video:resolution",
     "video_codecs:scalability_mode",
   ]
   absl_deps = [
diff --git a/api/rtp_parameters.h b/api/rtp_parameters.h
index 0d3c9df..e311577 100644
--- a/api/rtp_parameters.h
+++ b/api/rtp_parameters.h
@@ -23,7 +23,6 @@
 #include "api/media_types.h"
 #include "api/priority.h"
 #include "api/rtp_transceiver_direction.h"
-#include "api/video/resolution.h"
 #include "api/video_codecs/scalability_mode.h"
 #include "rtc_base/system/rtc_export.h"
 
@@ -503,24 +502,6 @@
   // https://w3c.github.io/webrtc-svc/#rtcrtpencodingparameters
   absl::optional<std::string> scalability_mode;
 
-  // Requested encode resolution.
-  //
-  // This field provides an alternative to `scale_resolution_down_by`
-  // that is not dependent on the video source.
-  //
-  // When setting requested_resolution it is not necessary to adapt the
-  // video source using OnOutputFormatRequest, since the VideoStreamEncoder
-  // will apply downscaling if necessary. requested_resolution will also be
-  // propagated to the video source, this allows downscaling earlier in the
-  // pipeline which can be beneficial if the source is consumed by multiple
-  // encoders, but is not strictly necessary.
-  //
-  // The `requested_resolution` is subject to resource adaptation.
-  //
-  // It is an error to set both `requested_resolution` and
-  // `scale_resolution_down_by`.
-  absl::optional<Resolution> requested_resolution;
-
   // For an RtpSender, set to true to cause this encoding to be encoded and
   // sent, and false for it not to be encoded and sent. This allows control
   // across multiple encodings of a sender for turning simulcast layers on and
@@ -546,8 +527,7 @@
            num_temporal_layers == o.num_temporal_layers &&
            scale_resolution_down_by == o.scale_resolution_down_by &&
            active == o.active && rid == o.rid &&
-           adaptive_ptime == o.adaptive_ptime &&
-           requested_resolution == o.requested_resolution;
+           adaptive_ptime == o.adaptive_ptime;
   }
   bool operator!=(const RtpEncodingParameters& o) const {
     return !(*this == o);
diff --git a/api/video/BUILD.gn b/api/video/BUILD.gn
index ee62abd..060b9e4 100644
--- a/api/video/BUILD.gn
+++ b/api/video/BUILD.gn
@@ -131,11 +131,6 @@
   public = [ "render_resolution.h" ]
 }
 
-rtc_source_set("resolution") {
-  visibility = [ "*" ]
-  public = [ "resolution.h" ]
-}
-
 rtc_library("encoded_image") {
   visibility = [ "*" ]
   sources = [
diff --git a/api/video/recordable_encoded_frame.h b/api/video/recordable_encoded_frame.h
index 47ea23f..702f4d7 100644
--- a/api/video/recordable_encoded_frame.h
+++ b/api/video/recordable_encoded_frame.h
@@ -24,7 +24,6 @@
 class RecordableEncodedFrame {
  public:
   // Encoded resolution in pixels
-  // TODO(bugs.webrtc.org/12114) : remove in favor of Resolution.
   struct EncodedResolution {
     bool empty() const { return width == 0 && height == 0; }
 
diff --git a/api/video/render_resolution.h b/api/video/render_resolution.h
index fcf4f12..edcf8f8 100644
--- a/api/video/render_resolution.h
+++ b/api/video/render_resolution.h
@@ -13,7 +13,6 @@
 
 namespace webrtc {
 
-// TODO(bugs.webrtc.org/12114) : remove in favor of Resolution.
 class RenderResolution {
  public:
   constexpr RenderResolution() = default;
diff --git a/api/video/resolution.h b/api/video/resolution.h
deleted file mode 100644
index 99cb622..0000000
--- a/api/video/resolution.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- *  Copyright (c) 2022 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_RESOLUTION_H_
-#define API_VIDEO_RESOLUTION_H_
-
-namespace webrtc {
-
-// A struct representing a video resolution in pixels.
-struct Resolution {
-  int width = 0;
-  int height = 0;
-};
-
-inline bool operator==(const Resolution& lhs, const Resolution& rhs) {
-  return lhs.width == rhs.width && lhs.height == rhs.height;
-}
-
-inline bool operator!=(const Resolution& lhs, const Resolution& rhs) {
-  return !(lhs == rhs);
-}
-
-}  // namespace webrtc
-
-#endif  // API_VIDEO_RESOLUTION_H_
diff --git a/api/video/video_source_interface.h b/api/video/video_source_interface.h
index 72937c7..5eb4ebf 100644
--- a/api/video/video_source_interface.h
+++ b/api/video/video_source_interface.h
@@ -80,24 +80,6 @@
   // Note that the `resolutions` can change while frames are in flight and
   // should only be used as a hint when constructing the webrtc::VideoFrame.
   std::vector<FrameSize> resolutions;
-
-  // This is the resolution requested by the user using RtpEncodingParameters.
-  absl::optional<FrameSize> requested_resolution;
-
-  // `active` : is (any) of the layers/sink(s) active.
-  bool is_active = false;
-
-  // This sub-struct contains information computed by VideoBroadcaster
-  // that aggregates several VideoSinkWants (and sends them to
-  // AdaptedVideoTrackSource).
-  struct Aggregates {
-    // `active_without_requested_resolution` is set by VideoBroadcaster
-    // when aggregating sink wants if there exists any sink (encoder) that is
-    // active but has not set the `requested_resolution`, i.e is relying on
-    // OnOutputFormatRequest to handle encode resolution.
-    bool any_active_without_requested_resolution = false;
-  };
-  absl::optional<Aggregates> aggregates;
 };
 
 inline bool operator==(const VideoSinkWants::FrameSize& a,
@@ -105,11 +87,6 @@
   return a.width == b.width && a.height == b.height;
 }
 
-inline bool operator!=(const VideoSinkWants::FrameSize& a,
-                       const VideoSinkWants::FrameSize& b) {
-  return !(a == b);
-}
-
 template <typename VideoFrameT>
 class VideoSourceInterface {
  public:
diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn
index d6b7392..3f933b9 100644
--- a/api/video_codecs/BUILD.gn
+++ b/api/video_codecs/BUILD.gn
@@ -84,7 +84,6 @@
     "../units:data_rate",
     "../video:encoded_image",
     "../video:render_resolution",
-    "../video:resolution",
     "../video:video_bitrate_allocation",
     "../video:video_codec_constants",
     "../video:video_frame",
diff --git a/api/video_codecs/video_encoder_config.h b/api/video_codecs/video_encoder_config.h
index 3d1b176..86d89d5 100644
--- a/api/video_codecs/video_encoder_config.h
+++ b/api/video_codecs/video_encoder_config.h
@@ -18,7 +18,6 @@
 
 #include "absl/types/optional.h"
 #include "api/scoped_refptr.h"
-#include "api/video/resolution.h"
 #include "api/video_codecs/scalability_mode.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_codec.h"
@@ -33,11 +32,10 @@
   VideoStream(const VideoStream& other);
   std::string ToString() const;
 
-  // Width/Height in pixels.
-  // This is the actual width and height used to configure encoder,
-  // which might be less than `requested_resolution` due to adaptation
-  // or due to the source providing smaller frames than requested.
+  // Width in pixels.
   size_t width;
+
+  // Height in pixels.
   size_t height;
 
   // Frame rate in fps.
@@ -71,17 +69,6 @@
 
   // If this stream is enabled by the user, or not.
   bool active;
-
-  // An optional user supplied max_frame_resolution
-  // than can be set independently of (adapted) VideoSource.
-  // This value is set from RtpEncodingParameters::requested_resolution
-  // (i.e. used for signaling app-level settings).
-  //
-  // The actual encode resolution is in `width` and `height`,
-  // which can be lower than requested_resolution,
-  // e.g. if source only provides lower resolution or
-  // if resource adaptation is active.
-  absl::optional<Resolution> requested_resolution;
 };
 
 class VideoEncoderConfig {
diff --git a/media/base/media_engine.cc b/media/base/media_engine.cc
index 694e690..813657e 100644
--- a/media/base/media_engine.cc
+++ b/media/base/media_engine.cc
@@ -106,13 +106,6 @@
                              "num_temporal_layers to an invalid number.");
       }
     }
-
-    if (rtp_parameters.encodings[i].requested_resolution &&
-        rtp_parameters.encodings[i].scale_resolution_down_by) {
-      LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
-                           "Attempted to set scale_resolution_down_by and "
-                           "requested_resolution simultaniously.");
-    }
   }
 
   return webrtc::RTCError::OK();
diff --git a/media/base/video_broadcaster.cc b/media/base/video_broadcaster.cc
index 60c0e1c..1167d7f 100644
--- a/media/base/video_broadcaster.cc
+++ b/media/base/video_broadcaster.cc
@@ -10,7 +10,6 @@
 
 #include "media/base/video_broadcaster.h"
 
-#include <algorithm>
 #include <vector>
 
 #include "absl/types/optional.h"
@@ -124,7 +123,6 @@
   VideoSinkWants wants;
   wants.rotation_applied = false;
   wants.resolution_alignment = 1;
-  wants.aggregates.emplace(VideoSinkWants::Aggregates());
   for (auto& sink : sink_pairs()) {
     // wants.rotation_applied == ANY(sink.wants.rotation_applied)
     if (sink.wants.rotation_applied) {
@@ -149,25 +147,6 @@
     }
     wants.resolution_alignment = cricket::LeastCommonMultiple(
         wants.resolution_alignment, sink.wants.resolution_alignment);
-
-    // Pick MAX(requested_resolution) since the actual can be downscaled
-    // in encoder instead.
-    if (sink.wants.requested_resolution) {
-      if (!wants.requested_resolution) {
-        wants.requested_resolution = sink.wants.requested_resolution;
-      } else {
-        wants.requested_resolution->width =
-            std::max(wants.requested_resolution->width,
-                     sink.wants.requested_resolution->width);
-        wants.requested_resolution->height =
-            std::max(wants.requested_resolution->height,
-                     sink.wants.requested_resolution->height);
-      }
-    } else if (sink.wants.is_active) {
-      wants.aggregates->any_active_without_requested_resolution = true;
-    }
-
-    wants.is_active |= sink.wants.is_active;
   }
 
   if (wants.target_pixel_count &&
diff --git a/media/base/video_broadcaster_unittest.cc b/media/base/video_broadcaster_unittest.cc
index 52f015c..fe1a1cb 100644
--- a/media/base/video_broadcaster_unittest.cc
+++ b/media/base/video_broadcaster_unittest.cc
@@ -24,7 +24,6 @@
 using cricket::FakeVideoRenderer;
 using rtc::VideoBroadcaster;
 using rtc::VideoSinkWants;
-using FrameSize = rtc::VideoSinkWants::FrameSize;
 
 using ::testing::AllOf;
 using ::testing::Eq;
@@ -331,70 +330,3 @@
           Field(&webrtc::VideoTrackSourceConstraints::max_fps, Optional(3)))));
   broadcaster.ProcessConstraints(webrtc::VideoTrackSourceConstraints{2, 3});
 }
-
-TEST(VideoBroadcasterTest, AppliesMaxOfSinkWantsRequestedResolution) {
-  VideoBroadcaster broadcaster;
-
-  FakeVideoRenderer sink1;
-  VideoSinkWants wants1;
-  wants1.requested_resolution = FrameSize(640, 360);
-
-  broadcaster.AddOrUpdateSink(&sink1, wants1);
-  EXPECT_EQ(FrameSize(640, 360), *broadcaster.wants().requested_resolution);
-
-  FakeVideoRenderer sink2;
-  VideoSinkWants wants2;
-  wants2.requested_resolution = FrameSize(650, 350);
-  broadcaster.AddOrUpdateSink(&sink2, wants2);
-  EXPECT_EQ(FrameSize(650, 360), *broadcaster.wants().requested_resolution);
-
-  broadcaster.RemoveSink(&sink2);
-  EXPECT_EQ(FrameSize(640, 360), *broadcaster.wants().requested_resolution);
-}
-
-TEST(VideoBroadcasterTest, AnyActive) {
-  VideoBroadcaster broadcaster;
-
-  FakeVideoRenderer sink1;
-  VideoSinkWants wants1;
-  wants1.is_active = false;
-
-  broadcaster.AddOrUpdateSink(&sink1, wants1);
-  EXPECT_EQ(false, broadcaster.wants().is_active);
-
-  FakeVideoRenderer sink2;
-  VideoSinkWants wants2;
-  wants2.is_active = true;
-  broadcaster.AddOrUpdateSink(&sink2, wants2);
-  EXPECT_EQ(true, broadcaster.wants().is_active);
-
-  broadcaster.RemoveSink(&sink2);
-  EXPECT_EQ(false, broadcaster.wants().is_active);
-}
-
-TEST(VideoBroadcasterTest, AnyActiveWithoutRequestedResolution) {
-  VideoBroadcaster broadcaster;
-
-  FakeVideoRenderer sink1;
-  VideoSinkWants wants1;
-  wants1.is_active = true;
-  wants1.requested_resolution = FrameSize(640, 360);
-
-  broadcaster.AddOrUpdateSink(&sink1, wants1);
-  EXPECT_EQ(
-      false,
-      broadcaster.wants().aggregates->any_active_without_requested_resolution);
-
-  FakeVideoRenderer sink2;
-  VideoSinkWants wants2;
-  wants2.is_active = true;
-  broadcaster.AddOrUpdateSink(&sink2, wants2);
-  EXPECT_EQ(
-      true,
-      broadcaster.wants().aggregates->any_active_without_requested_resolution);
-
-  broadcaster.RemoveSink(&sink2);
-  EXPECT_EQ(
-      false,
-      broadcaster.wants().aggregates->any_active_without_requested_resolution);
-}
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 2a9c0a8..5651f59 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -2350,9 +2350,7 @@
         (new_parameters.encodings[i].scale_resolution_down_by !=
          rtp_parameters_.encodings[i].scale_resolution_down_by) ||
         (new_parameters.encodings[i].num_temporal_layers !=
-         rtp_parameters_.encodings[i].num_temporal_layers) ||
-        (new_parameters.encodings[i].requested_resolution !=
-         rtp_parameters_.encodings[i].requested_resolution)) {
+         rtp_parameters_.encodings[i].num_temporal_layers)) {
       new_param = true;
       break;
     }
@@ -2564,8 +2562,6 @@
       encoder_config.simulcast_layers[i].num_temporal_layers =
           *rtp_parameters_.encodings[i].num_temporal_layers;
     }
-    encoder_config.simulcast_layers[i].requested_resolution =
-        rtp_parameters_.encodings[i].requested_resolution;
   }
 
   encoder_config.legacy_conference_mode = parameters_.conference_mode;
@@ -3709,7 +3705,6 @@
   layer.width = width;
   layer.height = height;
   layer.max_framerate = max_framerate;
-  layer.active = encoder_config.simulcast_layers[0].active;
 
   if (encoder_config.simulcast_layers[0].scale_resolution_down_by > 1.) {
     layer.width = ScaleDownResolution(
diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index a05524f..79c680f 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -158,7 +158,7 @@
   TimeController* const time_controller_;
 };
 
-MATCHER_P2(MatchResolution, w, h, "") {
+MATCHER_P2(Resolution, w, h, "") {
   return arg.resolution().width == w && arg.resolution().height == h;
 }
 
@@ -740,9 +740,8 @@
       /*generate_key_frame=*/false);
 
   InSequence s;
-  EXPECT_CALL(callback,
-              Call(MatchResolution(test::FakeDecoder::kDefaultWidth,
-                                   test::FakeDecoder::kDefaultHeight)));
+  EXPECT_CALL(callback, Call(Resolution(test::FakeDecoder::kDefaultWidth,
+                                        test::FakeDecoder::kDefaultHeight)));
   EXPECT_CALL(callback, Call);
 
   video_receive_stream_->OnCompleteFrame(
@@ -764,7 +763,7 @@
       /*generate_key_frame=*/false);
 
   InSequence s;
-  EXPECT_CALL(callback, Call(MatchResolution(1080u, 720u)));
+  EXPECT_CALL(callback, Call(Resolution(1080u, 720u)));
   EXPECT_CALL(callback, Call);
 
   video_receive_stream_->OnCompleteFrame(
diff --git a/video/video_source_sink_controller.cc b/video/video_source_sink_controller.cc
index 2f7b375..cf3b649 100644
--- a/video/video_source_sink_controller.cc
+++ b/video/video_source_sink_controller.cc
@@ -20,6 +20,29 @@
 
 namespace webrtc {
 
+namespace {
+
+std::string WantsToString(const rtc::VideoSinkWants& wants) {
+  rtc::StringBuilder ss;
+
+  ss << "max_fps=" << wants.max_framerate_fps
+     << " max_pixel_count=" << wants.max_pixel_count << " target_pixel_count="
+     << (wants.target_pixel_count.has_value()
+             ? std::to_string(wants.target_pixel_count.value())
+             : "null")
+     << " resolutions={";
+  for (size_t i = 0; i < wants.resolutions.size(); ++i) {
+    if (i != 0)
+      ss << ",";
+    ss << wants.resolutions[i].width << "x" << wants.resolutions[i].height;
+  }
+  ss << "}";
+
+  return ss.Release();
+}
+
+}  // namespace
+
 VideoSourceSinkController::VideoSourceSinkController(
     rtc::VideoSinkInterface<VideoFrame>* sink,
     rtc::VideoSourceInterface<VideoFrame>* source)
@@ -63,6 +86,8 @@
   if (!source_)
     return;
   rtc::VideoSinkWants wants = CurrentSettingsToSinkWants();
+  RTC_LOG(LS_INFO) << "Pushing SourceSink restrictions: "
+                   << WantsToString(wants);
   source_->AddOrUpdateSink(sink_, wants);
 }
 
@@ -99,17 +124,6 @@
   return resolutions_;
 }
 
-bool VideoSourceSinkController::active() const {
-  RTC_DCHECK_RUN_ON(&sequence_checker_);
-  return active_;
-}
-
-absl::optional<rtc::VideoSinkWants::FrameSize>
-VideoSourceSinkController::requested_resolution() const {
-  RTC_DCHECK_RUN_ON(&sequence_checker_);
-  return requested_resolution_;
-}
-
 void VideoSourceSinkController::SetRestrictions(
     VideoSourceRestrictions restrictions) {
   RTC_DCHECK_RUN_ON(&sequence_checker_);
@@ -145,17 +159,6 @@
   resolutions_ = std::move(resolutions);
 }
 
-void VideoSourceSinkController::SetActive(bool active) {
-  RTC_DCHECK_RUN_ON(&sequence_checker_);
-  active_ = active;
-}
-
-void VideoSourceSinkController::SetRequestedResolution(
-    absl::optional<rtc::VideoSinkWants::FrameSize> requested_resolution) {
-  RTC_DCHECK_RUN_ON(&sequence_checker_);
-  requested_resolution_ = std::move(requested_resolution);
-}
-
 // RTC_EXCLUSIVE_LOCKS_REQUIRED(sequence_checker_)
 rtc::VideoSinkWants VideoSourceSinkController::CurrentSettingsToSinkWants()
     const {
@@ -185,8 +188,6 @@
                    ? static_cast<int>(frame_rate_upper_limit_.value())
                    : std::numeric_limits<int>::max());
   wants.resolutions = resolutions_;
-  wants.is_active = active_;
-  wants.requested_resolution = requested_resolution_;
   return wants;
 }
 
diff --git a/video/video_source_sink_controller.h b/video/video_source_sink_controller.h
index 1bb6ef6..e2a7eb7 100644
--- a/video/video_source_sink_controller.h
+++ b/video/video_source_sink_controller.h
@@ -51,8 +51,6 @@
   bool rotation_applied() const;
   int resolution_alignment() const;
   const std::vector<rtc::VideoSinkWants::FrameSize>& resolutions() const;
-  bool active() const;
-  absl::optional<rtc::VideoSinkWants::FrameSize> requested_resolution() const;
 
   // Updates the settings stored internally. In order for these settings to be
   // applied to the sink, PushSourceSinkSettings() must subsequently be called.
@@ -63,9 +61,6 @@
   void SetRotationApplied(bool rotation_applied);
   void SetResolutionAlignment(int resolution_alignment);
   void SetResolutions(std::vector<rtc::VideoSinkWants::FrameSize> resolutions);
-  void SetActive(bool active);
-  void SetRequestedResolution(
-      absl::optional<rtc::VideoSinkWants::FrameSize> requested_resolution);
 
  private:
   rtc::VideoSinkWants CurrentSettingsToSinkWants() const
@@ -92,9 +87,6 @@
   int resolution_alignment_ RTC_GUARDED_BY(&sequence_checker_) = 1;
   std::vector<rtc::VideoSinkWants::FrameSize> resolutions_
       RTC_GUARDED_BY(&sequence_checker_);
-  bool active_ RTC_GUARDED_BY(&sequence_checker_) = true;
-  absl::optional<rtc::VideoSinkWants::FrameSize> requested_resolution_
-      RTC_GUARDED_BY(&sequence_checker_);
 };
 
 }  // namespace webrtc
diff --git a/video/video_source_sink_controller_unittest.cc b/video/video_source_sink_controller_unittest.cc
index 75cc52b..2db7b56 100644
--- a/video/video_source_sink_controller_unittest.cc
+++ b/video/video_source_sink_controller_unittest.cc
@@ -24,7 +24,6 @@
 
 namespace {
 
-using FrameSize = rtc::VideoSinkWants::FrameSize;
 constexpr int kIntUnconstrained = std::numeric_limits<int>::max();
 
 class MockVideoSinkWithVideoFrame : public rtc::VideoSinkInterface<VideoFrame> {
@@ -62,7 +61,6 @@
   EXPECT_FALSE(controller.pixels_per_frame_upper_limit().has_value());
   EXPECT_FALSE(controller.frame_rate_upper_limit().has_value());
   EXPECT_FALSE(controller.rotation_applied());
-  EXPECT_FALSE(controller.requested_resolution().has_value());
   EXPECT_EQ(controller.resolution_alignment(), 1);
 
   EXPECT_CALL(source, AddOrUpdateSink(_, _))
@@ -73,7 +71,6 @@
         EXPECT_EQ(wants.target_pixel_count, absl::nullopt);
         EXPECT_EQ(wants.max_framerate_fps, kIntUnconstrained);
         EXPECT_EQ(wants.resolution_alignment, 1);
-        EXPECT_FALSE(wants.requested_resolution.has_value());
       });
   controller.PushSourceSinkSettings();
 }
@@ -165,35 +162,4 @@
   VideoSourceSinkController controller(&sink, nullptr);
   controller.RequestRefreshFrame();
 }
-
-TEST(VideoSourceSinkControllerTest, RequestedResolutionPropagatesToWants) {
-  MockVideoSinkWithVideoFrame sink;
-  MockVideoSourceWithVideoFrame source;
-  VideoSourceSinkController controller(&sink, &source);
-  controller.SetRequestedResolution(FrameSize(640, 360));
-  EXPECT_TRUE(controller.requested_resolution().has_value());
-
-  EXPECT_CALL(source, AddOrUpdateSink(_, _))
-      .WillOnce([](rtc::VideoSinkInterface<VideoFrame>* sink,
-                   const rtc::VideoSinkWants& wants) {
-        EXPECT_EQ(*wants.requested_resolution, FrameSize(640, 360));
-      });
-  controller.PushSourceSinkSettings();
-}
-
-TEST(VideoSourceSinkControllerTest, ActivePropagatesToWants) {
-  MockVideoSinkWithVideoFrame sink;
-  MockVideoSourceWithVideoFrame source;
-  VideoSourceSinkController controller(&sink, &source);
-  controller.SetActive(true);
-  EXPECT_TRUE(controller.active());
-
-  EXPECT_CALL(source, AddOrUpdateSink(_, _))
-      .WillOnce([](rtc::VideoSinkInterface<VideoFrame>* sink,
-                   const rtc::VideoSinkWants& wants) {
-        EXPECT_TRUE(wants.is_active);
-      });
-  controller.PushSourceSinkSettings();
-}
-
 }  // namespace webrtc
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 1018df4..e320e43 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1130,30 +1130,10 @@
   RTC_DCHECK_LE(codec.startBitrate, 1000000);
   max_framerate_ = codec.maxFramerate;
 
-  // Inform source about max configured framerate,
-  // requested_resolution and which layers are active.
+  // Inform source about max configured framerate.
   int max_framerate = 0;
-  // Is any layer active.
-  bool active = false;
-  // The max requested_resolution.
-  absl::optional<rtc::VideoSinkWants::FrameSize> requested_resolution;
   for (const auto& stream : streams) {
     max_framerate = std::max(stream.max_framerate, max_framerate);
-    active |= stream.active;
-    // Note: we propagate the highest requested_resolution regardless
-    // if layer is active or not.
-    if (stream.requested_resolution) {
-      if (!requested_resolution) {
-        requested_resolution.emplace(stream.requested_resolution->width,
-                                     stream.requested_resolution->height);
-      } else {
-        requested_resolution.emplace(
-            std::max(stream.requested_resolution->width,
-                     requested_resolution->width),
-            std::max(stream.requested_resolution->height,
-                     requested_resolution->height));
-      }
-    }
   }
 
   // The resolutions that we're actually encoding with.
@@ -1166,28 +1146,20 @@
     encoder_resolutions.emplace_back(simulcastStream.width,
                                      simulcastStream.height);
   }
-
   worker_queue_->PostTask(SafeTask(
       task_safety_.flag(),
       [this, max_framerate, alignment,
-       encoder_resolutions = std::move(encoder_resolutions),
-       requested_resolution = std::move(requested_resolution), active]() {
+       encoder_resolutions = std::move(encoder_resolutions)]() {
         RTC_DCHECK_RUN_ON(worker_queue_);
         if (max_framerate !=
                 video_source_sink_controller_.frame_rate_upper_limit() ||
             alignment != video_source_sink_controller_.resolution_alignment() ||
             encoder_resolutions !=
-                video_source_sink_controller_.resolutions() ||
-            (video_source_sink_controller_.requested_resolution() !=
-             requested_resolution) ||
-            (video_source_sink_controller_.active() != active)) {
+                video_source_sink_controller_.resolutions()) {
           video_source_sink_controller_.SetFrameRateUpperLimit(max_framerate);
           video_source_sink_controller_.SetResolutionAlignment(alignment);
           video_source_sink_controller_.SetResolutions(
               std::move(encoder_resolutions));
-          video_source_sink_controller_.SetRequestedResolution(
-              requested_resolution);
-          video_source_sink_controller_.SetActive(active);
           video_source_sink_controller_.PushSourceSinkSettings();
         }
       }));