diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn
index 50e3d02..24b1298 100644
--- a/api/video_codecs/BUILD.gn
+++ b/api/video_codecs/BUILD.gn
@@ -31,6 +31,7 @@
     "vp8_frame_buffer_controller.h",
     "vp8_frame_config.cc",
     "vp8_frame_config.h",
+    "vp8_temporal_layers.cc",
     "vp8_temporal_layers.h",
   ]
 
@@ -95,20 +96,19 @@
   ]
 }
 
-rtc_static_library("create_vp8_temporal_layers") {
+rtc_static_library("vp8_temporal_layers_factory") {
   visibility = [ "*" ]
   allow_poison = [ "software_video_codecs" ]
   sources = [
-    "create_vp8_temporal_layers.cc",
-    "create_vp8_temporal_layers.h",
+    "vp8_temporal_layers_factory.cc",
+    "vp8_temporal_layers_factory.h",
   ]
 
   deps = [
     ":video_codecs_api",
-    "../..:webrtc_common",
-    "../../modules/video_coding:video_codec_interface",
+    "../../modules/video_coding:video_coding_utility",
     "../../modules/video_coding:webrtc_vp8_temporal_layers",
-    "../../system_wrappers:system_wrappers",
+    "../../rtc_base:checks",
     "//third_party/abseil-cpp/absl/memory",
   ]
 }
diff --git a/api/video_codecs/create_vp8_temporal_layers.cc b/api/video_codecs/create_vp8_temporal_layers.cc
deleted file mode 100644
index 26f734a..0000000
--- a/api/video_codecs/create_vp8_temporal_layers.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "api/video_codecs/create_vp8_temporal_layers.h"
-#include "absl/memory/memory.h"
-#include "api/video_codecs/vp8_temporal_layers.h"
-#include "modules/video_coding/codecs/vp8/default_temporal_layers.h"
-#include "modules/video_coding/codecs/vp8/screenshare_layers.h"
-
-namespace webrtc {
-
-std::unique_ptr<Vp8TemporalLayers> CreateVp8TemporalLayers(
-    Vp8TemporalLayersType type,
-    int num_temporal_layers) {
-  switch (type) {
-    case Vp8TemporalLayersType::kFixedPattern:
-      return absl::make_unique<DefaultTemporalLayers>(num_temporal_layers);
-    case Vp8TemporalLayersType::kBitrateDynamic:
-      // Conference mode temporal layering for screen content in base stream.
-      return absl::make_unique<ScreenshareLayers>(num_temporal_layers);
-  }
-}
-
-}  // namespace webrtc
diff --git a/api/video_codecs/create_vp8_temporal_layers.h b/api/video_codecs/create_vp8_temporal_layers.h
deleted file mode 100644
index 52f14c8..0000000
--- a/api/video_codecs/create_vp8_temporal_layers.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- *  Copyright (c) 2018 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_CODECS_CREATE_VP8_TEMPORAL_LAYERS_H_
-#define API_VIDEO_CODECS_CREATE_VP8_TEMPORAL_LAYERS_H_
-
-#include <memory>
-
-#include "api/video_codecs/vp8_temporal_layers.h"
-
-namespace webrtc {
-
-std::unique_ptr<Vp8TemporalLayers> CreateVp8TemporalLayers(
-    Vp8TemporalLayersType type,
-    int num_temporal_layers);
-
-}  // namespace webrtc
-
-#endif  // API_VIDEO_CODECS_CREATE_VP8_TEMPORAL_LAYERS_H_
diff --git a/api/video_codecs/video_encoder.cc b/api/video_codecs/video_encoder.cc
index a8b6f42..233ca24 100644
--- a/api/video_codecs/video_encoder.cc
+++ b/api/video_codecs/video_encoder.cc
@@ -125,6 +125,10 @@
   return SetRates(allocation.get_sum_kbps(), framerate);
 }
 
+void VideoEncoder::OnPacketLossRateUpdate(float packet_loss_rate) {}
+
+void VideoEncoder::OnRttUpdate(int64_t rtt_ms) {}
+
 // TODO(webrtc:9722): Remove and make pure virtual.
 VideoEncoder::EncoderInfo VideoEncoder::GetEncoderInfo() const {
   return EncoderInfo();
diff --git a/api/video_codecs/video_encoder.h b/api/video_codecs/video_encoder.h
index dc68928..9ff8faa 100644
--- a/api/video_codecs/video_encoder.h
+++ b/api/video_codecs/video_encoder.h
@@ -263,6 +263,16 @@
   virtual int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
                                     uint32_t framerate);
 
+  // Inform the encoder when the packet loss rate changes.
+  //
+  // Input:   - packet_loss_rate  : The packet loss rate (0.0 to 1.0).
+  virtual void OnPacketLossRateUpdate(float packet_loss_rate);
+
+  // Inform the encoder when the round trip time changes.
+  //
+  // Input:   - rtt_ms            : The new RTT, in milliseconds.
+  virtual void OnRttUpdate(int64_t rtt_ms);
+
   // Returns meta-data about the encoder, such as implementation name.
   // The output of this method may change during runtime. For instance if a
   // hardware encoder fails, it may fall back to doing software encoding using
diff --git a/api/video_codecs/vp8_frame_buffer_controller.h b/api/video_codecs/vp8_frame_buffer_controller.h
index 93ed6da..7f4c282 100644
--- a/api/video_codecs/vp8_frame_buffer_controller.h
+++ b/api/video_codecs/vp8_frame_buffer_controller.h
@@ -11,8 +11,10 @@
 #ifndef API_VIDEO_CODECS_VP8_FRAME_BUFFER_CONTROLLER_H_
 #define API_VIDEO_CODECS_VP8_FRAME_BUFFER_CONTROLLER_H_
 
+#include <memory>
 #include <vector>
 
+#include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/vp8_frame_config.h"
 
 namespace webrtc {
@@ -66,10 +68,15 @@
 };
 
 // This interface defines a way of delegating the logic of buffer management.
+// Multiple streams may be controlled by a single controller, demuxing between
+// them using stream_index.
 class Vp8FrameBufferController {
  public:
   virtual ~Vp8FrameBufferController() = default;
 
+  // Number of streamed controlled by |this|.
+  virtual size_t StreamCount() const = 0;
+
   // If this method returns true, the encoder is free to drop frames for
   // instance in an effort to uphold encoding bitrate.
   // If this return false, the encoder must not drop any frames unless:
@@ -79,10 +86,11 @@
   //     re-encode the image at a low bitrate. In this case the encoder should
   //     call OnEncodeDone() once with size = 0 to indicate drop, and then call
   //     OnEncodeDone() again when the frame has actually been encoded.
-  virtual bool SupportsEncoderFrameDropping() const = 0;
+  virtual bool SupportsEncoderFrameDropping(size_t stream_index) const = 0;
 
   // New target bitrate, per temporal layer.
-  virtual void OnRatesUpdated(const std::vector<uint32_t>& bitrates_bps,
+  virtual void OnRatesUpdated(size_t stream_index,
+                              const std::vector<uint32_t>& bitrates_bps,
                               int framerate_fps) = 0;
 
   // Called by the encoder before encoding a frame. |cfg| contains the current
@@ -90,7 +98,8 @@
   // to be changed before the encode step, |cfg| should be changed and then
   // return true. If false is returned, the encoder will proceed without
   // updating the configuration.
-  virtual bool UpdateConfiguration(Vp8EncoderConfig* cfg) = 0;
+  virtual bool UpdateConfiguration(size_t stream_index,
+                                   Vp8EncoderConfig* cfg) = 0;
 
   // Returns the recommended VP8 encode flags needed, and moves the temporal
   // pattern to the next frame.
@@ -99,7 +108,8 @@
   // The timestamp uses a 90kHz RTP clock.
   // After calling this method, first call the actual encoder with the provided
   // frame configuration, and then OnEncodeDone() below.
-  virtual Vp8FrameConfig UpdateLayerConfig(uint32_t rtp_timestamp) = 0;
+  virtual Vp8FrameConfig UpdateLayerConfig(size_t stream_index,
+                                           uint32_t rtp_timestamp) = 0;
 
   // Called after the encode step is done. |rtp_timestamp| must match the
   // parameter use in the UpdateLayerConfig() call.
@@ -114,11 +124,28 @@
   // If |size_bytes| > 0, |qp| should indicate the frame-level QP this frame was
   // encoded at. If the encoder does not support extracting this, |qp| should be
   // set to 0.
-  virtual void OnEncodeDone(uint32_t rtp_timestamp,
+  virtual void OnEncodeDone(size_t stream_index,
+                            uint32_t rtp_timestamp,
                             size_t size_bytes,
                             bool is_keyframe,
                             int qp,
                             CodecSpecificInfo* info) = 0;
+
+  // Called by the encoder when the packet loss rate changes.
+  // |packet_loss_rate| runs between 0.0 (no loss) and 1.0 (everything lost).
+  virtual void OnPacketLossRateUpdate(float packet_loss_rate) = 0;
+
+  // Called by the encoder when the round trip time changes.
+  virtual void OnRttUpdate(int64_t rtt_ms) = 0;
+};
+
+// Interface for a factory of Vp8FrameBufferController instances.
+class Vp8FrameBufferControllerFactory {
+ public:
+  virtual ~Vp8FrameBufferControllerFactory() = default;
+
+  virtual std::unique_ptr<Vp8FrameBufferController> Create(
+      const VideoCodec& codec) = 0;
 };
 
 }  // namespace webrtc
diff --git a/api/video_codecs/vp8_temporal_layers.cc b/api/video_codecs/vp8_temporal_layers.cc
new file mode 100644
index 0000000..a3c0db1
--- /dev/null
+++ b/api/video_codecs/vp8_temporal_layers.cc
@@ -0,0 +1,84 @@
+/*
+ *  Copyright (c) 2019 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 "api/video_codecs/vp8_temporal_layers.h"
+
+#include <utility>
+
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+
+Vp8TemporalLayers::Vp8TemporalLayers(
+    std::vector<std::unique_ptr<Vp8FrameBufferController>>&& controllers)
+    : controllers_(std::move(controllers)) {
+  RTC_DCHECK(!controllers_.empty());
+  RTC_DCHECK(std::none_of(
+      controllers_.begin(), controllers_.end(),
+      [](const std::unique_ptr<Vp8FrameBufferController>& controller) {
+        return controller.get() == nullptr;
+      }));
+}
+
+size_t Vp8TemporalLayers::StreamCount() const {
+  return controllers_.size();
+}
+
+bool Vp8TemporalLayers::SupportsEncoderFrameDropping(
+    size_t stream_index) const {
+  RTC_DCHECK_LT(stream_index, controllers_.size());
+  return controllers_[stream_index]->SupportsEncoderFrameDropping(0);
+}
+
+void Vp8TemporalLayers::OnRatesUpdated(
+    size_t stream_index,
+    const std::vector<uint32_t>& bitrates_bps,
+    int framerate_fps) {
+  RTC_DCHECK_LT(stream_index, controllers_.size());
+  return controllers_[stream_index]->OnRatesUpdated(0, bitrates_bps,
+                                                    framerate_fps);
+}
+
+bool Vp8TemporalLayers::UpdateConfiguration(size_t stream_index,
+                                            Vp8EncoderConfig* cfg) {
+  RTC_DCHECK_LT(stream_index, controllers_.size());
+  return controllers_[stream_index]->UpdateConfiguration(0, cfg);
+}
+
+Vp8FrameConfig Vp8TemporalLayers::UpdateLayerConfig(size_t stream_index,
+                                                    uint32_t rtp_timestamp) {
+  RTC_DCHECK_LT(stream_index, controllers_.size());
+  return controllers_[stream_index]->UpdateLayerConfig(0, rtp_timestamp);
+}
+
+void Vp8TemporalLayers::OnEncodeDone(size_t stream_index,
+                                     uint32_t rtp_timestamp,
+                                     size_t size_bytes,
+                                     bool is_keyframe,
+                                     int qp,
+                                     CodecSpecificInfo* info) {
+  RTC_DCHECK_LT(stream_index, controllers_.size());
+  return controllers_[stream_index]->OnEncodeDone(0, rtp_timestamp, size_bytes,
+                                                  is_keyframe, qp, info);
+}
+
+void Vp8TemporalLayers::OnPacketLossRateUpdate(float packet_loss_rate) {
+  for (auto& controller : controllers_) {
+    controller->OnPacketLossRateUpdate(packet_loss_rate);
+  }
+}
+
+void Vp8TemporalLayers::OnRttUpdate(int64_t rtt_ms) {
+  for (auto& controller : controllers_) {
+    controller->OnRttUpdate(rtt_ms);
+  }
+}
+
+}  // namespace webrtc
diff --git a/api/video_codecs/vp8_temporal_layers.h b/api/video_codecs/vp8_temporal_layers.h
index 61a9def..d5d29cd 100644
--- a/api/video_codecs/vp8_temporal_layers.h
+++ b/api/video_codecs/vp8_temporal_layers.h
@@ -11,8 +11,10 @@
 #ifndef API_VIDEO_CODECS_VP8_TEMPORAL_LAYERS_H_
 #define API_VIDEO_CODECS_VP8_TEMPORAL_LAYERS_H_
 
+#include <memory>
 #include <vector>
 
+#include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/vp8_frame_buffer_controller.h"
 #include "api/video_codecs/vp8_frame_config.h"
 
@@ -22,28 +24,43 @@
 // kFixedPattern uses a fixed repeating pattern of 1-4 layers.
 // kBitrateDynamic can allocate frames dynamically to 1 or 2 layers, based on
 // the bitrate produced.
+// TODO(eladalon): Remove this enum.
 enum class Vp8TemporalLayersType { kFixedPattern, kBitrateDynamic };
 
 // This interface defines a way of getting the encoder settings needed to
 // realize a temporal layer structure.
-class Vp8TemporalLayers : public Vp8FrameBufferController {
+class Vp8TemporalLayers final : public Vp8FrameBufferController {
  public:
+  explicit Vp8TemporalLayers(
+      std::vector<std::unique_ptr<Vp8FrameBufferController>>&& controllers);
   ~Vp8TemporalLayers() override = default;
 
-  bool SupportsEncoderFrameDropping() const override = 0;
+  size_t StreamCount() const override;
 
-  void OnRatesUpdated(const std::vector<uint32_t>& bitrates_bps,
-                      int framerate_fps) override = 0;
+  bool SupportsEncoderFrameDropping(size_t stream_index) const override;
 
-  bool UpdateConfiguration(Vp8EncoderConfig* cfg) override = 0;
+  void OnRatesUpdated(size_t stream_index,
+                      const std::vector<uint32_t>& bitrates_bps,
+                      int framerate_fps) override;
 
-  Vp8FrameConfig UpdateLayerConfig(uint32_t rtp_timestamp) override = 0;
+  bool UpdateConfiguration(size_t stream_index, Vp8EncoderConfig* cfg) override;
 
-  void OnEncodeDone(uint32_t rtp_timestamp,
+  Vp8FrameConfig UpdateLayerConfig(size_t stream_index,
+                                   uint32_t rtp_timestamp) override;
+
+  void OnEncodeDone(size_t stream_index,
+                    uint32_t rtp_timestamp,
                     size_t size_bytes,
                     bool is_keyframe,
                     int qp,
-                    CodecSpecificInfo* info) override = 0;
+                    CodecSpecificInfo* info) override;
+
+  void OnPacketLossRateUpdate(float packet_loss_rate) override;
+
+  void OnRttUpdate(int64_t rtt_ms) override;
+
+ private:
+  std::vector<std::unique_ptr<Vp8FrameBufferController>> controllers_;
 };
 
 }  // namespace webrtc
diff --git a/api/video_codecs/vp8_temporal_layers_factory.cc b/api/video_codecs/vp8_temporal_layers_factory.cc
new file mode 100644
index 0000000..2eb7bb9
--- /dev/null
+++ b/api/video_codecs/vp8_temporal_layers_factory.cc
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (c) 2019 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 "api/video_codecs/vp8_temporal_layers_factory.h"
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "modules/video_coding/codecs/vp8/default_temporal_layers.h"
+#include "modules/video_coding/codecs/vp8/screenshare_layers.h"
+#include "modules/video_coding/utility/simulcast_utility.h"
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+
+std::unique_ptr<Vp8FrameBufferController> Vp8TemporalLayersFactory::Create(
+    const VideoCodec& codec) {
+  std::vector<std::unique_ptr<Vp8FrameBufferController>> controllers;
+  const int num_streams = SimulcastUtility::NumberOfSimulcastStreams(codec);
+  RTC_DCHECK_GE(num_streams, 1);
+  controllers.reserve(num_streams);
+
+  for (int i = 0; i < num_streams; ++i) {
+    int num_temporal_layers =
+        SimulcastUtility::NumberOfTemporalLayers(codec, i);
+    if (SimulcastUtility::IsConferenceModeScreenshare(codec) && i == 0) {
+      // Legacy screenshare layers supports max 2 layers.
+      num_temporal_layers = std::max(2, num_temporal_layers);
+      controllers.push_back(
+          absl::make_unique<ScreenshareLayers>(num_temporal_layers));
+    } else {
+      controllers.push_back(
+          absl::make_unique<DefaultTemporalLayers>(num_temporal_layers));
+    }
+  }
+
+  return absl::make_unique<Vp8TemporalLayers>(std::move(controllers));
+}
+
+}  // namespace webrtc
diff --git a/api/video_codecs/vp8_temporal_layers_factory.h b/api/video_codecs/vp8_temporal_layers_factory.h
new file mode 100644
index 0000000..9c65d4c
--- /dev/null
+++ b/api/video_codecs/vp8_temporal_layers_factory.h
@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2019 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_CODECS_VP8_TEMPORAL_LAYERS_FACTORY_H_
+#define API_VIDEO_CODECS_VP8_TEMPORAL_LAYERS_FACTORY_H_
+
+#include <memory>
+
+#include "api/video_codecs/vp8_temporal_layers.h"
+
+namespace webrtc {
+
+class Vp8TemporalLayersFactory : public Vp8FrameBufferControllerFactory {
+ public:
+  ~Vp8TemporalLayersFactory() override = default;
+
+  std::unique_ptr<Vp8FrameBufferController> Create(
+      const VideoCodec& codec) override;
+};
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_CODECS_VP8_TEMPORAL_LAYERS_FACTORY_H_
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index b6314bd..afd6837 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -373,8 +373,8 @@
     "../../api/video:encoded_image",
     "../../api/video:video_frame",
     "../../api/video:video_frame_i420",
-    "../../api/video_codecs:create_vp8_temporal_layers",
     "../../api/video_codecs:video_codecs_api",
+    "../../api/video_codecs:vp8_temporal_layers_factory",
     "../../common_video",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
@@ -838,8 +838,8 @@
       "../../api/video:video_bitrate_allocator_factory",
       "../../api/video:video_frame",
       "../../api/video:video_frame_i420",
-      "../../api/video_codecs:create_vp8_temporal_layers",
       "../../api/video_codecs:video_codecs_api",
+      "../../api/video_codecs:vp8_temporal_layers_factory",
       "../../common_video:common_video",
       "../../media:rtc_media_base",
       "../../rtc_base:checks",
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.cc b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
index 61dca09..70e78a7 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
@@ -7,6 +7,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "modules/video_coding/codecs/vp8/default_temporal_layers.h"
+
 #include <stdlib.h>
 #include <string.h>
 
@@ -18,7 +20,6 @@
 #include <vector>
 
 #include "modules/include/module_common_types.h"
-#include "modules/video_coding/codecs/vp8/default_temporal_layers.h"
 #include "modules/video_coding/include/video_codec_interface.h"
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
@@ -260,14 +261,22 @@
 
 DefaultTemporalLayers::~DefaultTemporalLayers() = default;
 
-bool DefaultTemporalLayers::SupportsEncoderFrameDropping() const {
+size_t DefaultTemporalLayers::StreamCount() const {
+  return 1;
+}
+
+bool DefaultTemporalLayers::SupportsEncoderFrameDropping(
+    size_t stream_index) const {
+  RTC_DCHECK_LT(stream_index, StreamCount());
   // This class allows the encoder drop frames as it sees fit.
   return true;
 }
 
 void DefaultTemporalLayers::OnRatesUpdated(
+    size_t stream_index,
     const std::vector<uint32_t>& bitrates_bps,
     int framerate_fps) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
   RTC_DCHECK_GT(bitrates_bps.size(), 0);
   RTC_DCHECK_LE(bitrates_bps.size(), num_layers_);
   // |bitrates_bps| uses individual rate per layer, but Vp8EncoderConfig wants
@@ -279,7 +288,10 @@
   }
 }
 
-bool DefaultTemporalLayers::UpdateConfiguration(Vp8EncoderConfig* cfg) {
+bool DefaultTemporalLayers::UpdateConfiguration(size_t stream_index,
+                                                Vp8EncoderConfig* cfg) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
+
   if (!new_bitrates_bps_) {
     return false;
   }
@@ -328,9 +340,11 @@
   return true;
 }
 
-Vp8FrameConfig DefaultTemporalLayers::UpdateLayerConfig(uint32_t timestamp) {
+Vp8FrameConfig DefaultTemporalLayers::UpdateLayerConfig(size_t stream_index,
+                                                        uint32_t timestamp) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
   RTC_DCHECK_GT(num_layers_, 0);
-  RTC_DCHECK_LT(0, temporal_pattern_.size());
+  RTC_DCHECK_GT(temporal_pattern_.size(), 0);
 
   pattern_idx_ = (pattern_idx_ + 1) % temporal_pattern_.size();
   Vp8FrameConfig tl_config = temporal_pattern_[pattern_idx_];
@@ -440,11 +454,13 @@
   }
 }
 
-void DefaultTemporalLayers::OnEncodeDone(uint32_t rtp_timestamp,
+void DefaultTemporalLayers::OnEncodeDone(size_t stream_index,
+                                         uint32_t rtp_timestamp,
                                          size_t size_bytes,
                                          bool is_keyframe,
                                          int qp,
                                          CodecSpecificInfo* info) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
   RTC_DCHECK_GT(num_layers_, 0);
 
   auto pending_frame = pending_frames_.find(rtp_timestamp);
@@ -525,6 +541,10 @@
   }
 }
 
+void DefaultTemporalLayers::OnPacketLossRateUpdate(float packet_loss_rate) {}
+
+void DefaultTemporalLayers::OnRttUpdate(int64_t rtt_ms) {}
+
 TemplateStructure DefaultTemporalLayers::GetTemplateStructure(
     int num_layers) const {
   RTC_CHECK_LT(num_layers, 5);
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.h b/modules/video_coding/codecs/vp8/default_temporal_layers.h
index f94d908..ee2333e 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.h
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.h
@@ -28,29 +28,38 @@
 
 namespace webrtc {
 
-class DefaultTemporalLayers : public Vp8TemporalLayers {
+class DefaultTemporalLayers final : public Vp8FrameBufferController {
  public:
   explicit DefaultTemporalLayers(int number_of_temporal_layers);
   ~DefaultTemporalLayers() override;
 
-  bool SupportsEncoderFrameDropping() const override;
+  size_t StreamCount() const override;
+
+  bool SupportsEncoderFrameDropping(size_t stream_index) const override;
 
   // Returns the recommended VP8 encode flags needed. May refresh the decoder
   // and/or update the reference buffers.
-  Vp8FrameConfig UpdateLayerConfig(uint32_t timestamp) override;
+  Vp8FrameConfig UpdateLayerConfig(size_t stream_index,
+                                   uint32_t timestamp) override;
 
   // New target bitrate, per temporal layer.
-  void OnRatesUpdated(const std::vector<uint32_t>& bitrates_bps,
+  void OnRatesUpdated(size_t stream_index,
+                      const std::vector<uint32_t>& bitrates_bps,
                       int framerate_fps) override;
 
-  bool UpdateConfiguration(Vp8EncoderConfig* cfg) override;
+  bool UpdateConfiguration(size_t stream_index, Vp8EncoderConfig* cfg) override;
 
-  void OnEncodeDone(uint32_t rtp_timestamp,
+  void OnEncodeDone(size_t stream_index,
+                    uint32_t rtp_timestamp,
                     size_t size_bytes,
                     bool is_keyframe,
                     int qp,
                     CodecSpecificInfo* info) override;
 
+  void OnPacketLossRateUpdate(float packet_loss_rate) override;
+
+  void OnRttUpdate(int64_t rtt_ms) override;
+
  private:
   static std::vector<Vp8FrameConfig> GetTemporalPattern(size_t num_layers);
   bool IsSyncFrame(const Vp8FrameConfig& config) const;
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
index 37e6620..b8625ad 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
@@ -121,10 +121,11 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   constexpr size_t kPatternSize = 4;
   constexpr size_t kRepetitions = 4;
@@ -142,10 +143,10 @@
   for (size_t i = 0; i < kPatternSize * kRepetitions; ++i) {
     const size_t ind = i % kPatternSize;
     CodecSpecificInfo info;
-    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
+    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
     EXPECT_EQ(expected_flags[ind], LibvpxVp8Encoder::EncodeFlags(tl_config))
         << i;
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
                     &info);
     EXPECT_TRUE(checker.CheckTemporalConfig(i == 0, tl_config));
     EXPECT_EQ(expected_temporal_idx[ind], info.codecSpecific.VP8.temporalIdx);
@@ -163,10 +164,11 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   int expected_flags[16] = {
       kTemporalUpdateLastRefAltRef,
@@ -196,9 +198,9 @@
   unsigned int timestamp = 0;
   for (int i = 0; i < 16; ++i) {
     CodecSpecificInfo info;
-    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
+    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
     EXPECT_EQ(expected_flags[i], LibvpxVp8Encoder::EncodeFlags(tl_config)) << i;
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
                     &info);
     EXPECT_TRUE(checker.CheckTemporalConfig(i == 0, tl_config));
     EXPECT_EQ(expected_temporal_idx[i], info.codecSpecific.VP8.temporalIdx);
@@ -217,10 +219,11 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   int expected_flags[8] = {kTemporalUpdateLast,
                            kTemporalUpdateAltrefWithoutDependency,
@@ -238,9 +241,9 @@
   unsigned int timestamp = 0;
   for (int i = 0; i < 8; ++i) {
     CodecSpecificInfo info;
-    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
+    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
     EXPECT_EQ(expected_flags[i], LibvpxVp8Encoder::EncodeFlags(tl_config)) << i;
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
                     &info);
     EXPECT_TRUE(checker.CheckTemporalConfig(i == 0, tl_config));
     EXPECT_EQ(expected_temporal_idx[i], info.codecSpecific.VP8.temporalIdx);
@@ -259,38 +262,39 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   // Use a repeating pattern of tl 0, 2, 1, 2.
   // Tl 0, 1, 2 update last, golden, altref respectively.
 
   // Start with a key-frame. tl_config flags can be ignored.
   uint32_t timestamp = 0;
-  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
+  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame. First one only references TL0. Updates altref.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_EQ(tl_config.first_reference, Vp8BufferReference::kLast);
   EXPECT_EQ(tl_config.second_reference, Vp8BufferReference::kNone);
 
   // TL1 frame. Can only reference TL0. Updated golden.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_EQ(tl_config.first_reference, Vp8BufferReference::kLast);
   EXPECT_EQ(tl_config.second_reference, Vp8BufferReference::kNone);
 
   // TL2 frame. Can reference all three buffers. Golden was the last to be
   // updated, the next to last was altref.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_EQ(tl_config.first_reference, Vp8BufferReference::kGolden);
   EXPECT_EQ(tl_config.second_reference, Vp8BufferReference::kAltref);
@@ -302,35 +306,36 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   // Use a repeating pattern of tl 0, 2, 1, 2.
   // Tl 0, 1, 2 update last, golden, altref respectively.
 
   // Start with a key-frame. tl_config flags can be ignored.
   uint32_t timestamp = 0;
-  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
+  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame. First one only references TL0. Updates altref.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_EQ(tl_config.first_reference, Vp8BufferReference::kLast);
   EXPECT_EQ(tl_config.second_reference, Vp8BufferReference::kNone);
 
   // Dropped TL1 frame. Can only reference TL0. Should have updated golden.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, 0, false, 0, nullptr);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, 0, false, 0, nullptr);
 
   // TL2 frame. Can normally reference all three buffers, but golden has not
   // been populated this cycle. Altref was last to be updated, before that last.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_EQ(tl_config.first_reference, Vp8BufferReference::kAltref);
   EXPECT_EQ(tl_config.second_reference, Vp8BufferReference::kLast);
@@ -341,10 +346,11 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
   int expected_flags[16] = {
       kTemporalUpdateLast,
       kTemporalUpdateNoneNoRefGoldenAltRef,
@@ -373,9 +379,9 @@
   uint32_t timestamp = 0;
   for (int i = 0; i < 16; ++i) {
     CodecSpecificInfo info;
-    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
+    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
     EXPECT_EQ(expected_flags[i], LibvpxVp8Encoder::EncodeFlags(tl_config)) << i;
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, i == 0, kDefaultQp,
                     &info);
     EXPECT_TRUE(checker.CheckTemporalConfig(i == 0, tl_config));
     EXPECT_EQ(expected_temporal_idx[i], info.codecSpecific.VP8.temporalIdx);
@@ -396,29 +402,30 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   // Start with a keyframe.
   uint32_t timestamp = 0;
-  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
+  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // Dropped TL2 frame.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, 0, false, 0, nullptr);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, 0, false, 0, nullptr);
 
   // Dropped TL1 frame.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, 0, false, 0, nullptr);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, 0, false, 0, nullptr);
 
   // TL2 frame. Can reference all three buffers, valid since golden and altref
   // both contain the last keyframe.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_TRUE(tl_config.last_buffer_flags & BufferFlags::kReference);
   EXPECT_TRUE(tl_config.golden_buffer_flags & BufferFlags::kReference);
@@ -427,24 +434,24 @@
   // Restart of cycle!
 
   // TL0 base layer frame, updating and referencing last.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame, updating altref.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL1 frame, updating golden.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame. Can still reference all buffer since they have been update this
   // cycle.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_TRUE(tl_config.last_buffer_flags & BufferFlags::kReference);
   EXPECT_TRUE(tl_config.golden_buffer_flags & BufferFlags::kReference);
@@ -453,22 +460,22 @@
   // Restart of cycle!
 
   // TL0 base layer frame, updating and referencing last.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // Dropped TL2 frame.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, 0, false, 0, nullptr);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, 0, false, 0, nullptr);
 
   // Dropped TL1 frame.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, 0, false, 0, nullptr);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, 0, false, 0, nullptr);
 
   // TL2 frame. This time golden and altref contain data from the previous cycle
   // and cannot be referenced.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   EXPECT_TRUE(tl_config.last_buffer_flags & BufferFlags::kReference);
   EXPECT_FALSE(tl_config.golden_buffer_flags & BufferFlags::kReference);
@@ -482,62 +489,63 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   // Start with a keyframe.
   uint32_t timestamp = 0;
-  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
+  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // Do a full cycle of the pattern.
   for (int i = 0; i < 7; ++i) {
-    tl_config = tl.UpdateLayerConfig(++timestamp);
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+    tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                     IgnoredCodecSpecificInfo());
   }
 
   // TL0 base layer frame, starting the cycle over.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // Encoder has a hiccup and builds a queue, so frame encoding is delayed.
   // TL1 frame, updating golden.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
 
   // TL2 frame, that should be referencing golden, but we can't be certain it's
   // not going to be dropped, so that is not allowed.
-  tl_config = tl.UpdateLayerConfig(timestamp + 1);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 1);
   EXPECT_TRUE(tl_config.last_buffer_flags & BufferFlags::kReference);
   EXPECT_FALSE(tl_config.golden_buffer_flags & BufferFlags::kReference);
   EXPECT_TRUE(tl_config.arf_buffer_flags & BufferFlags::kReference);
 
   // TL0 base layer frame.
-  tl_config = tl.UpdateLayerConfig(timestamp + 2);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 2);
 
   // The previous four enqueued frames finally get encoded, and the updated
   // buffers are now OK to reference.
   // Enqueued TL1 frame ready.
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   // Enqueued TL2 frame.
-  tl.OnEncodeDone(++timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl.OnEncodeDone(0, ++timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   // Enqueued TL0 frame.
-  tl.OnEncodeDone(++timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl.OnEncodeDone(0, ++timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame, all buffers are now in a known good state, OK to reference.
-  tl_config = tl.UpdateLayerConfig(++timestamp + 1);
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp + 1);
   EXPECT_TRUE(tl_config.last_buffer_flags & BufferFlags::kReference);
   EXPECT_TRUE(tl_config.golden_buffer_flags & BufferFlags::kReference);
   EXPECT_TRUE(tl_config.arf_buffer_flags & BufferFlags::kReference);
@@ -551,56 +559,57 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   // Start with a keyframe.
   uint32_t timestamp = 0;
-  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
+  Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // Do a full cycle of the pattern.
   for (int i = 0; i < 3; ++i) {
-    tl_config = tl.UpdateLayerConfig(++timestamp);
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+    tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                     IgnoredCodecSpecificInfo());
   }
 
   // TL0 base layer frame, starting the cycle over.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame.
-  tl_config = tl.UpdateLayerConfig(++timestamp);
-  tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl_config = tl.UpdateLayerConfig(0, ++timestamp);
+  tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // Encoder has a hiccup and builds a queue, so frame encoding is delayed.
   // Encoded, but delayed frames in TL 1, 2.
-  tl_config = tl.UpdateLayerConfig(timestamp + 1);
-  tl_config = tl.UpdateLayerConfig(timestamp + 2);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 1);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 2);
 
   // Restart of the pattern!
 
   // Encoded, but delayed frames in TL 2, 1.
-  tl_config = tl.UpdateLayerConfig(timestamp + 3);
-  tl_config = tl.UpdateLayerConfig(timestamp + 4);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 3);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 4);
 
   // TL1 frame from last cycle is ready.
-  tl.OnEncodeDone(timestamp + 1, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl.OnEncodeDone(0, timestamp + 1, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
   // TL2 frame from last cycle is ready.
-  tl.OnEncodeDone(timestamp + 2, kDefaultBytesPerFrame, false, kDefaultQp,
+  tl.OnEncodeDone(0, timestamp + 2, kDefaultBytesPerFrame, false, kDefaultQp,
                   IgnoredCodecSpecificInfo());
 
   // TL2 frame, that should be referencing all buffers, but altref and golden
   // haven not been updated this cycle. (Don't be fooled by the late frames from
   // the last cycle!)
-  tl_config = tl.UpdateLayerConfig(timestamp + 5);
+  tl_config = tl.UpdateLayerConfig(0, timestamp + 5);
   EXPECT_TRUE(tl_config.last_buffer_flags & BufferFlags::kReference);
   EXPECT_FALSE(tl_config.golden_buffer_flags & BufferFlags::kReference);
   EXPECT_FALSE(tl_config.arf_buffer_flags & BufferFlags::kReference);
@@ -611,10 +620,11 @@
   DefaultTemporalLayers tl(kNumLayers);
   DefaultTemporalLayersChecker checker(kNumLayers);
   Vp8EncoderConfig cfg;
-  tl.OnRatesUpdated(GetTemporalLayerRates(kDefaultBytesPerFrame,
+  tl.OnRatesUpdated(0,
+                    GetTemporalLayerRates(kDefaultBytesPerFrame,
                                           kDefaultFramerate, kNumLayers),
                     kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   int expected_flags[8] = {
       kTemporalUpdateLastRefAltRef,
@@ -637,10 +647,10 @@
     for (int j = 1; j <= i; ++j) {
       // Since last frame was always a keyframe and thus index 0 in the pattern,
       // this loop starts at index 1.
-      Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
+      Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
       EXPECT_EQ(expected_flags[j], LibvpxVp8Encoder::EncodeFlags(tl_config))
           << j;
-      tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
+      tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, false, kDefaultQp,
                       IgnoredCodecSpecificInfo());
       EXPECT_TRUE(checker.CheckTemporalConfig(false, tl_config));
       EXPECT_EQ(expected_temporal_idx[j], tl_config.packetizer_temporal_idx);
@@ -650,8 +660,9 @@
     }
 
     CodecSpecificInfo info;
-    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp);
-    tl.OnEncodeDone(timestamp, kDefaultBytesPerFrame, true, kDefaultQp, &info);
+    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp);
+    tl.OnEncodeDone(0, timestamp, kDefaultBytesPerFrame, true, kDefaultQp,
+                    &info);
     EXPECT_TRUE(info.codecSpecific.VP8.layerSync)
         << "Key frame should be marked layer sync.";
     EXPECT_EQ(0, info.codecSpecific.VP8.temporalIdx)
@@ -727,9 +738,9 @@
   DefaultTemporalLayers tl(num_layers);
   Vp8EncoderConfig cfg;
   tl.OnRatesUpdated(
-      GetTemporalLayerRates(kDefaultBytesPerFrame, kDefaultFramerate, 1),
+      0, GetTemporalLayerRates(kDefaultBytesPerFrame, kDefaultFramerate, 1),
       kDefaultFramerate);
-  tl.UpdateConfiguration(&cfg);
+  tl.UpdateConfiguration(0, &cfg);
 
   // Run through the pattern and store the frame dependencies, plus keep track
   // of the buffer state; which buffers references which temporal layers (if
@@ -738,8 +749,8 @@
   // updates |last|.
   std::vector<Vp8FrameConfig> tl_configs(kMaxPatternLength);
   for (int i = 0; i < kMaxPatternLength; ++i) {
-    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(timestamp_);
-    tl.OnEncodeDone(timestamp_, kDefaultBytesPerFrame, i == 0, kDefaultQp,
+    Vp8FrameConfig tl_config = tl.UpdateLayerConfig(0, timestamp_);
+    tl.OnEncodeDone(0, timestamp_, kDefaultBytesPerFrame, i == 0, kDefaultQp,
                     IgnoredCodecSpecificInfo());
     ++timestamp_;
     EXPECT_FALSE(tl_config.drop_frame);
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index 98d5e3c..580f706 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -25,8 +25,8 @@
 #include "api/video/video_content_type.h"
 #include "api/video/video_frame_buffer.h"
 #include "api/video/video_timing.h"
-#include "api/video_codecs/create_vp8_temporal_layers.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
+#include "api/video_codecs/vp8_temporal_layers_factory.h"
 #include "common_video/libyuv/include/webrtc_libyuv.h"
 #include "modules/video_coding/codecs/interface/common_constants.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
@@ -122,10 +122,12 @@
   vpx_config->rc_max_quantizer = config.rc_max_quantizer;
 }
 
-bool UpdateVpxConfiguration(Vp8FrameBufferController* frame_buffer_controller,
+bool UpdateVpxConfiguration(size_t stream_index,
+                            Vp8FrameBufferController* frame_buffer_controller,
                             vpx_codec_enc_cfg_t* cfg) {
   Vp8EncoderConfig config = GetEncoderConfig(cfg);
-  const bool res = frame_buffer_controller->UpdateConfiguration(&config);
+  const bool res =
+      frame_buffer_controller->UpdateConfiguration(stream_index, &config);
   if (res)
     FillInEncoderConfig(cfg, config);
   return res;
@@ -185,7 +187,6 @@
           "WebRTC-VP8VariableFramerateScreenshare")),
       framerate_controller_(variable_framerate_experiment_.framerate_limit),
       num_steady_state_frames_(0) {
-  frame_buffer_controllers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
   encoded_images_.reserve(kMaxSimulcastStreams);
   send_stream_.reserve(kMaxSimulcastStreams);
@@ -220,7 +221,7 @@
     libvpx_->img_free(&raw_images_.back());
     raw_images_.pop_back();
   }
-  frame_buffer_controllers_.clear();
+  frame_buffer_controller_.reset();
   inited_ = false;
   return ret_val;
 }
@@ -279,11 +280,12 @@
 
     configurations_[i].rc_target_bitrate = target_bitrate_kbps;
     if (send_stream) {
-      frame_buffer_controllers_[stream_idx]->OnRatesUpdated(
-          bitrate.GetTemporalLayerAllocation(stream_idx), new_framerate);
+      frame_buffer_controller_->OnRatesUpdated(
+          stream_idx, bitrate.GetTemporalLayerAllocation(stream_idx),
+          new_framerate);
     }
 
-    UpdateVpxConfiguration(frame_buffer_controllers_[stream_idx].get(),
+    UpdateVpxConfiguration(stream_idx, frame_buffer_controller_.get(),
                            &configurations_[i]);
 
     if (libvpx_->codec_enc_config_set(&encoders_[i], &configurations_[i])) {
@@ -293,6 +295,20 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
+void LibvpxVp8Encoder::OnPacketLossRateUpdate(float packet_loss_rate) {
+  // TODO(bugs.webrtc.org/10431): Replace condition by DCHECK.
+  if (frame_buffer_controller_) {
+    frame_buffer_controller_->OnPacketLossRateUpdate(packet_loss_rate);
+  }
+}
+
+void LibvpxVp8Encoder::OnRttUpdate(int64_t rtt_ms) {
+  // TODO(bugs.webrtc.org/10431): Replace condition by DCHECK.
+  if (frame_buffer_controller_) {
+    frame_buffer_controller_->OnRttUpdate(rtt_ms);
+  }
+}
+
 void LibvpxVp8Encoder::SetStreamState(bool send_stream, int stream_idx) {
   if (send_stream && !send_stream_[stream_idx]) {
     // Need a key frame if we have not sent this stream before.
@@ -301,26 +317,6 @@
   send_stream_[stream_idx] = send_stream;
 }
 
-void LibvpxVp8Encoder::SetupTemporalLayers(const VideoCodec& codec) {
-  RTC_DCHECK(frame_buffer_controllers_.empty());
-  const int num_streams = SimulcastUtility::NumberOfSimulcastStreams(codec);
-  for (int i = 0; i < num_streams; ++i) {
-    Vp8TemporalLayersType type;
-    int num_frame_buffer_controllers =
-        SimulcastUtility::NumberOfTemporalLayers(codec, i);
-    if (SimulcastUtility::IsConferenceModeScreenshare(codec) && i == 0) {
-      type = Vp8TemporalLayersType::kBitrateDynamic;
-      // Legacy screenshare layers supports max 2 layers.
-      num_frame_buffer_controllers =
-          std::max<int>(2, num_frame_buffer_controllers);
-    } else {
-      type = Vp8TemporalLayersType::kFixedPattern;
-    }
-    frame_buffer_controllers_.emplace_back(
-        CreateVp8TemporalLayers(type, num_frame_buffer_controllers));
-  }
-}
-
 int LibvpxVp8Encoder::InitEncode(const VideoCodec* inst,
                                  int number_of_cores,
                                  size_t /*maxPayloadSize */) {
@@ -354,7 +350,10 @@
     return WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED;
   }
 
-  SetupTemporalLayers(*inst);
+  RTC_DCHECK(!frame_buffer_controller_);
+  // TODO(bugs.webrtc.org/10382): Inject the factory.
+  Vp8TemporalLayersFactory factory;
+  frame_buffer_controller_ = factory.Create(*inst);
 
   number_of_cores_ = number_of_cores;
   timestamp_ = 0;
@@ -492,10 +491,11 @@
 
   configurations_[0].rc_target_bitrate = stream_bitrates[stream_idx];
   if (stream_bitrates[stream_idx] > 0) {
-    frame_buffer_controllers_[stream_idx]->OnRatesUpdated(
-        allocation.GetTemporalLayerAllocation(stream_idx), inst->maxFramerate);
+    frame_buffer_controller_->OnRatesUpdated(
+        stream_idx, allocation.GetTemporalLayerAllocation(stream_idx),
+        inst->maxFramerate);
   }
-  UpdateVpxConfiguration(frame_buffer_controllers_[stream_idx].get(),
+  UpdateVpxConfiguration(stream_idx, frame_buffer_controller_.get(),
                          &configurations_[0]);
   configurations_[0].rc_dropframe_thresh = FrameDropThreshold(stream_idx);
 
@@ -522,11 +522,11 @@
     SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
     configurations_[i].rc_target_bitrate = stream_bitrates[stream_idx];
     if (stream_bitrates[stream_idx] > 0) {
-      frame_buffer_controllers_[stream_idx]->OnRatesUpdated(
-          allocation.GetTemporalLayerAllocation(stream_idx),
+      frame_buffer_controller_->OnRatesUpdated(
+          stream_idx, allocation.GetTemporalLayerAllocation(stream_idx),
           inst->maxFramerate);
     }
-    UpdateVpxConfiguration(frame_buffer_controllers_[stream_idx].get(),
+    UpdateVpxConfiguration(stream_idx, frame_buffer_controller_.get(),
                            &configurations_[i]);
   }
 
@@ -695,9 +695,10 @@
   // setting, as eg. ScreenshareLayers does not work as intended with frame
   // dropping on and DefaultTemporalLayers will have performance issues with
   // frame dropping off.
-  RTC_CHECK_LT(spatial_idx, frame_buffer_controllers_.size());
+  RTC_DCHECK(frame_buffer_controller_);
+  RTC_DCHECK_LT(spatial_idx, frame_buffer_controller_->StreamCount());
   enable_frame_dropping =
-      frame_buffer_controllers_[spatial_idx]->SupportsEncoderFrameDropping();
+      frame_buffer_controller_->SupportsEncoderFrameDropping(spatial_idx);
   return enable_frame_dropping ? 30 : 0;
 }
 
@@ -811,7 +812,7 @@
   Vp8FrameConfig tl_configs[kMaxSimulcastStreams];
   for (size_t i = 0; i < encoders_.size(); ++i) {
     tl_configs[i] =
-        frame_buffer_controllers_[i]->UpdateLayerConfig(frame.timestamp());
+        frame_buffer_controller_->UpdateLayerConfig(i, frame.timestamp());
     if (tl_configs[i].drop_frame) {
       if (send_key_frame) {
         continue;
@@ -840,10 +841,9 @@
   }
 
   // Set the encoder frame flags and temporal layer_id for each spatial stream.
-  // Note that |frame_buffer_controllers_| are defined starting from lowest
-  // resolution at position 0 to highest resolution at position
-  // |encoders_.size() - 1|, whereas |encoder_| is from highest to lowest
-  // resolution.
+  // Note that streams are defined starting from lowest resolution at
+  // position 0 to highest resolution at position |encoders_.size() - 1|,
+  // whereas |encoder_| is from highest to lowest resolution.
   size_t stream_idx = encoders_.size() - 1;
   for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
     // Allow the layers adapter to temporarily modify the configuration. This
@@ -851,7 +851,7 @@
     // the next update.
     vpx_codec_enc_cfg_t temp_config;
     memcpy(&temp_config, &configurations_[i], sizeof(vpx_codec_enc_cfg_t));
-    if (UpdateVpxConfiguration(frame_buffer_controllers_[stream_idx].get(),
+    if (UpdateVpxConfiguration(stream_idx, frame_buffer_controller_.get(),
                                &temp_config)) {
       if (libvpx_->codec_enc_config_set(&encoders_[i], &temp_config))
         return WEBRTC_VIDEO_CODEC_ERROR;
@@ -913,8 +913,8 @@
 
   int qp = 0;
   vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER_64, &qp);
-  frame_buffer_controllers_[stream_idx]->OnEncodeDone(
-      timestamp, encoded_images_[encoder_idx].size(),
+  frame_buffer_controller_->OnEncodeDone(
+      stream_idx, timestamp, encoded_images_[encoder_idx].size(),
       (pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, qp, codec_specific);
 }
 
@@ -988,13 +988,13 @@
         } else {
           ++num_steady_state_frames_;
         }
-      } else if (!frame_buffer_controllers_[stream_idx]
-                      ->SupportsEncoderFrameDropping()) {
+      } else if (!frame_buffer_controller_->SupportsEncoderFrameDropping(
+                     stream_idx)) {
         result = WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT;
         if (encoded_images_[encoder_idx].size() == 0) {
           // Dropped frame that will be re-encoded.
-          frame_buffer_controllers_[stream_idx]->OnEncodeDone(
-              input_image.timestamp(), 0, false, 0, nullptr);
+          frame_buffer_controller_->OnEncodeDone(
+              stream_idx, input_image.timestamp(), 0, false, 0, nullptr);
         }
       }
     }
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
index b0e1afb..11a2e6a 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
@@ -53,13 +53,15 @@
   int SetRateAllocation(const VideoBitrateAllocation& bitrate,
                         uint32_t new_framerate) override;
 
+  void OnPacketLossRateUpdate(float packet_loss_rate) override;
+
+  void OnRttUpdate(int64_t rtt_ms) override;
+
   EncoderInfo GetEncoderInfo() const override;
 
   static vpx_enc_frame_flags_t EncodeFlags(const Vp8FrameConfig& references);
 
  private:
-  void SetupTemporalLayers(const VideoCodec& codec);
-
   // Get the cpu_speed setting for encoder based on resolution and/or platform.
   int GetCpuSpeed(int width, int height);
 
@@ -100,8 +102,7 @@
   int cpu_speed_default_;
   int number_of_cores_;
   uint32_t rc_max_intra_target_;
-  std::vector<std::unique_ptr<Vp8FrameBufferController>>
-      frame_buffer_controllers_;
+  std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_;
   std::vector<bool> key_frame_request_;
   std::vector<bool> send_stream_;
   std::vector<int> cpu_speed_;
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers.cc b/modules/video_coding/codecs/vp8/screenshare_layers.cc
index 17b1aed..594afad 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.cc
@@ -72,12 +72,21 @@
   UpdateHistograms();
 }
 
-bool ScreenshareLayers::SupportsEncoderFrameDropping() const {
+size_t ScreenshareLayers::StreamCount() const {
+  return 1;
+}
+
+bool ScreenshareLayers::SupportsEncoderFrameDropping(
+    size_t stream_index) const {
+  RTC_DCHECK_LT(stream_index, StreamCount());
   // Frame dropping is handled internally by this class.
   return false;
 }
 
-Vp8FrameConfig ScreenshareLayers::UpdateLayerConfig(uint32_t timestamp) {
+Vp8FrameConfig ScreenshareLayers::UpdateLayerConfig(size_t stream_index,
+                                                    uint32_t timestamp) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
+
   auto it = pending_frame_configs_.find(timestamp);
   if (it != pending_frame_configs_.end()) {
     // Drop and re-encode, reuse the previous config.
@@ -222,8 +231,10 @@
 }
 
 void ScreenshareLayers::OnRatesUpdated(
+    size_t stream_index,
     const std::vector<uint32_t>& bitrates_bps,
     int framerate_fps) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
   RTC_DCHECK_GT(framerate_fps, 0);
   RTC_DCHECK_GE(bitrates_bps.size(), 1);
   RTC_DCHECK_LE(bitrates_bps.size(), 2);
@@ -261,11 +272,14 @@
   layers_[1].target_rate_kbps_ = tl1_kbps;
 }
 
-void ScreenshareLayers::OnEncodeDone(uint32_t rtp_timestamp,
+void ScreenshareLayers::OnEncodeDone(size_t stream_index,
+                                     uint32_t rtp_timestamp,
                                      size_t size_bytes,
                                      bool is_keyframe,
                                      int qp,
                                      CodecSpecificInfo* info) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
+
   if (size_bytes == 0) {
     layers_[active_layer_].state = TemporalLayer::State::kDropped;
     ++stats_.num_overshoots_;
@@ -355,6 +369,10 @@
   }
 }
 
+void ScreenshareLayers::OnPacketLossRateUpdate(float packet_loss_rate) {}
+
+void ScreenshareLayers::OnRttUpdate(int64_t rtt_ms) {}
+
 TemplateStructure ScreenshareLayers::GetTemplateStructure(
     int num_layers) const {
   RTC_CHECK_LT(num_layers, 3);
@@ -428,7 +446,10 @@
   return std::max(layers_[0].target_rate_kbps_, target_bitrate_kbps);
 }
 
-bool ScreenshareLayers::UpdateConfiguration(Vp8EncoderConfig* cfg) {
+bool ScreenshareLayers::UpdateConfiguration(size_t stream_index,
+                                            Vp8EncoderConfig* cfg) {
+  RTC_DCHECK_LT(stream_index, StreamCount());
+
   if (min_qp_ == -1 || max_qp_ == -1) {
     // Store the valid qp range. This must not change during the lifetime of
     // this class.
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers.h b/modules/video_coding/codecs/vp8/screenshare_layers.h
index 1c96796..6b1bc7e 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.h
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.h
@@ -26,7 +26,7 @@
 struct CodecSpecificInfoVP8;
 class Clock;
 
-class ScreenshareLayers : public Vp8TemporalLayers {
+class ScreenshareLayers final : public Vp8FrameBufferController {
  public:
   static const double kMaxTL0FpsReduction;
   static const double kAcceptableTargetOvershoot;
@@ -35,26 +35,35 @@
   explicit ScreenshareLayers(int num_temporal_layers);
   ~ScreenshareLayers() override;
 
-  bool SupportsEncoderFrameDropping() const override;
+  size_t StreamCount() const override;
+
+  bool SupportsEncoderFrameDropping(size_t stream_index) const override;
 
   // Returns the recommended VP8 encode flags needed. May refresh the decoder
   // and/or update the reference buffers.
-  Vp8FrameConfig UpdateLayerConfig(uint32_t rtp_timestamp) override;
+  Vp8FrameConfig UpdateLayerConfig(size_t stream_index,
+                                   uint32_t rtp_timestamp) override;
 
   // New target bitrate, per temporal layer.
-  void OnRatesUpdated(const std::vector<uint32_t>& bitrates_bps,
+  void OnRatesUpdated(size_t stream_index,
+                      const std::vector<uint32_t>& bitrates_bps,
                       int framerate_fps) override;
 
   // Update the encoder configuration with target bitrates or other parameters.
   // Returns true iff the configuration was actually modified.
-  bool UpdateConfiguration(Vp8EncoderConfig* cfg) override;
+  bool UpdateConfiguration(size_t stream_index, Vp8EncoderConfig* cfg) override;
 
-  void OnEncodeDone(uint32_t rtp_timestamp,
+  void OnEncodeDone(size_t stream_index,
+                    uint32_t rtp_timestamp,
                     size_t size_bytes,
                     bool is_keyframe,
                     int qp,
                     CodecSpecificInfo* info) override;
 
+  void OnPacketLossRateUpdate(float packet_loss_rate) override;
+
+  void OnRttUpdate(int64_t rtt_ms) override;
+
  private:
   enum class TemporalLayerState : int { kDrop, kTl0, kTl1, kTl1Sync };
 
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
index 16e4d46..b8aa435 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
@@ -79,13 +79,13 @@
 
     int flags = ConfigureFrame(base_sync);
     if (flags != -1)
-      layers_->OnEncodeDone(timestamp_, frame_size_, base_sync, kDefaultQp,
+      layers_->OnEncodeDone(0, timestamp_, frame_size_, base_sync, kDefaultQp,
                             info);
     return flags;
   }
 
   int ConfigureFrame(bool key_frame) {
-    tl_config_ = UpdateLayerConfig(timestamp_);
+    tl_config_ = UpdateLayerConfig(0, timestamp_);
     EXPECT_EQ(0, tl_config_.encoder_layer_id)
         << "ScreenshareLayers always encodes using the bitrate allocator for "
            "layer 0, but may reference different buffers and packetize "
@@ -93,16 +93,16 @@
     if (tl_config_.drop_frame) {
       return -1;
     }
-    config_updated_ = layers_->UpdateConfiguration(&cfg_);
+    config_updated_ = layers_->UpdateConfiguration(0, &cfg_);
     int flags = LibvpxVp8Encoder::EncodeFlags(tl_config_);
     EXPECT_NE(-1, frame_size_);
     return flags;
   }
 
-  Vp8FrameConfig UpdateLayerConfig(uint32_t timestamp) {
+  Vp8FrameConfig UpdateLayerConfig(size_t stream_index, uint32_t timestamp) {
     int64_t timestamp_ms = timestamp / 90;
     clock_.AdvanceTime(TimeDelta::ms(timestamp_ms - rtc::TimeMillis()));
-    return layers_->UpdateLayerConfig(timestamp);
+    return layers_->UpdateLayerConfig(stream_index, timestamp);
   }
 
   int FrameSizeForBitrate(int bitrate_kbps) {
@@ -114,8 +114,8 @@
     memset(&vp8_cfg, 0, sizeof(Vp8EncoderConfig));
     vp8_cfg.rc_min_quantizer = min_qp_;
     vp8_cfg.rc_max_quantizer = max_qp_;
-    layers_->OnRatesUpdated(kDefault2TlBitratesBps, kFrameRate);
-    EXPECT_TRUE(layers_->UpdateConfiguration(&vp8_cfg));
+    layers_->OnRatesUpdated(0, kDefault2TlBitratesBps, kFrameRate);
+    EXPECT_TRUE(layers_->UpdateConfiguration(0, &vp8_cfg));
     frame_size_ = FrameSizeForBitrate(vp8_cfg.rc_target_bitrate);
     return vp8_cfg;
   }
@@ -162,7 +162,7 @@
       if (tl_config_.packetizer_temporal_idx != layer ||
           (sync && *sync != tl_config_.layer_sync)) {
         CodecSpecificInfo info;
-        layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp,
+        layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
                               &info);
         timestamp_ += kTimestampDelta5Fps;
       } else {
@@ -238,14 +238,15 @@
   for (int i = 0; i < kNumFrames; ++i) {
     CodecSpecificInfo info;
 
-    tl_config_ = UpdateLayerConfig(timestamp_);
-    config_updated_ = layers_->UpdateConfiguration(&cfg_);
+    tl_config_ = UpdateLayerConfig(0, timestamp_);
+    config_updated_ = layers_->UpdateConfiguration(0, &cfg_);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (tl_config_.packetizer_temporal_idx == 0) {
-      layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp, &info);
+      layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
+                            &info);
     } else {
-      layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp - 8,
+      layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp - 8,
                             &info);
     }
 
@@ -273,9 +274,10 @@
 
     // Simulate TL1 being at least 8 qp steps better.
     if (tl_config_.packetizer_temporal_idx == 0) {
-      layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp, &info);
+      layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
+                            &info);
     } else {
-      layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp - 8,
+      layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp - 8,
                             &info);
     }
 
@@ -293,7 +295,7 @@
     CodecSpecificInfo info;
 
     int flags = ConfigureFrame(false);
-    layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp - 8,
+    layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp - 8,
                           &info);
     if (info.codecSpecific.VP8.temporalIdx == 0) {
       // Bump TL0 to same quality as TL1.
@@ -384,8 +386,8 @@
   const int kTl1_kbps = 1000;
   const std::vector<uint32_t> layer_rates = {kTl0_kbps * 1000,
                                              (kTl1_kbps - kTl0_kbps) * 1000};
-  layers_->OnRatesUpdated(layer_rates, kFrameRate);
-  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg_));
+  layers_->OnRatesUpdated(0, layer_rates, kFrameRate);
+  EXPECT_TRUE(layers_->UpdateConfiguration(0, &cfg_));
 
   EXPECT_EQ(static_cast<unsigned int>(
                 ScreenshareLayers::kMaxTL0FpsReduction * kTl0_kbps + 0.5),
@@ -397,8 +399,8 @@
   const int kTl1_kbps = 450;
   const std::vector<uint32_t> layer_rates = {kTl0_kbps * 1000,
                                              (kTl1_kbps - kTl0_kbps) * 1000};
-  layers_->OnRatesUpdated(layer_rates, kFrameRate);
-  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg_));
+  layers_->OnRatesUpdated(0, layer_rates, kFrameRate);
+  EXPECT_TRUE(layers_->UpdateConfiguration(0, &cfg_));
 
   EXPECT_EQ(static_cast<unsigned int>(
                 kTl1_kbps / ScreenshareLayers::kAcceptableTargetOvershoot),
@@ -408,8 +410,8 @@
 TEST_F(ScreenshareLayerTest, TargetBitrateBelowTL0) {
   const int kTl0_kbps = 100;
   const std::vector<uint32_t> layer_rates = {kTl0_kbps * 1000};
-  layers_->OnRatesUpdated(layer_rates, kFrameRate);
-  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg_));
+  layers_->OnRatesUpdated(0, layer_rates, kFrameRate);
+  EXPECT_TRUE(layers_->UpdateConfiguration(0, &cfg_));
 
   EXPECT_EQ(static_cast<uint32_t>(kTl0_kbps), cfg_.rc_target_bitrate);
 }
@@ -419,7 +421,7 @@
   SkipUntilTl(0);
 
   // Size 0 indicates dropped frame.
-  layers_->OnEncodeDone(timestamp_, 0, false, 0, IgnoredCodecSpecificInfo());
+  layers_->OnEncodeDone(0, timestamp_, 0, false, 0, IgnoredCodecSpecificInfo());
 
   // Re-encode frame (so don't advance timestamp).
   int flags = EncodeFrame(false);
@@ -431,20 +433,20 @@
   SkipUntilTl(0);
   EXPECT_TRUE(config_updated_);
   EXPECT_LT(cfg_.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp,
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
                         IgnoredCodecSpecificInfo());
   timestamp_ += kTimestampDelta5Fps;
 
   // ...then back to standard setup.
   SkipUntilTl(0);
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp,
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
                         IgnoredCodecSpecificInfo());
   timestamp_ += kTimestampDelta5Fps;
   EXPECT_EQ(cfg_.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
 
   // Next drop in TL1.
   SkipUntilTl(1);
-  layers_->OnEncodeDone(timestamp_, 0, false, 0, IgnoredCodecSpecificInfo());
+  layers_->OnEncodeDone(0, timestamp_, 0, false, 0, IgnoredCodecSpecificInfo());
 
   // Re-encode frame (so don't advance timestamp).
   flags = EncodeFrame(false);
@@ -456,14 +458,14 @@
   SkipUntilTl(1);
   EXPECT_TRUE(config_updated_);
   EXPECT_LT(cfg_.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp,
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
                         IgnoredCodecSpecificInfo());
   timestamp_ += kTimestampDelta5Fps;
 
   // ...and back to normal.
   SkipUntilTl(1);
   EXPECT_EQ(cfg_.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp,
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
                         IgnoredCodecSpecificInfo());
   timestamp_ += kTimestampDelta5Fps;
 }
@@ -474,12 +476,12 @@
   const uint32_t kStartTimestamp = 1234;
 
   const std::vector<uint32_t> layer_rates = {kLowBitrateKbps * 1000};
-  layers_->OnRatesUpdated(layer_rates, kFrameRate);
-  layers_->UpdateConfiguration(&cfg_);
+  layers_->OnRatesUpdated(0, layer_rates, kFrameRate);
+  layers_->UpdateConfiguration(0, &cfg_);
 
-  EXPECT_EQ(kTl0Flags,
-            LibvpxVp8Encoder::EncodeFlags(UpdateLayerConfig(kStartTimestamp)));
-  layers_->OnEncodeDone(kStartTimestamp, kLargeFrameSizeBytes, false,
+  EXPECT_EQ(kTl0Flags, LibvpxVp8Encoder::EncodeFlags(
+                           UpdateLayerConfig(0, kStartTimestamp)));
+  layers_->OnEncodeDone(0, kStartTimestamp, kLargeFrameSizeBytes, false,
                         kDefaultQp, IgnoredCodecSpecificInfo());
 
   const uint32_t kTwoSecondsLater =
@@ -493,12 +495,12 @@
   // any later, the frame will be dropped anyway by the frame rate throttling
   // logic.
   EXPECT_TRUE(
-      UpdateLayerConfig(kTwoSecondsLater - kTimestampDelta5Fps).drop_frame);
+      UpdateLayerConfig(0, kTwoSecondsLater - kTimestampDelta5Fps).drop_frame);
 
   // More than two seconds has passed since last frame, one should be emitted
   // even if bitrate target is then exceeded.
   EXPECT_EQ(kTl0Flags, LibvpxVp8Encoder::EncodeFlags(
-                           UpdateLayerConfig(kTwoSecondsLater + 90)));
+                           UpdateLayerConfig(0, kTwoSecondsLater + 90)));
 }
 
 TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
@@ -511,33 +513,33 @@
   for (int64_t timestamp = 0;
        timestamp < kTimestampDelta5Fps * 5 * metrics::kMinRunTimeInSeconds;
        timestamp += kTimestampDelta5Fps) {
-    tl_config_ = UpdateLayerConfig(timestamp);
+    tl_config_ = UpdateLayerConfig(0, timestamp);
     if (tl_config_.drop_frame) {
       dropped_frame = true;
       continue;
     }
     int flags = LibvpxVp8Encoder::EncodeFlags(tl_config_);
     if (flags != -1)
-      layers_->UpdateConfiguration(&cfg_);
+      layers_->UpdateConfiguration(0, &cfg_);
 
     if (timestamp >= kTimestampDelta5Fps * 5 && !overshoot && flags != -1) {
       // Simulate one overshoot.
-      layers_->OnEncodeDone(timestamp, 0, false, 0, nullptr);
+      layers_->OnEncodeDone(0, timestamp, 0, false, 0, nullptr);
       overshoot = true;
     }
 
     if (flags == kTl0Flags) {
       if (timestamp >= kTimestampDelta5Fps * 20 && !trigger_drop) {
         // Simulate a too large frame, to cause frame drop.
-        layers_->OnEncodeDone(timestamp, frame_size_ * 10, false, kTl0Qp,
+        layers_->OnEncodeDone(0, timestamp, frame_size_ * 10, false, kTl0Qp,
                               IgnoredCodecSpecificInfo());
         trigger_drop = true;
       } else {
-        layers_->OnEncodeDone(timestamp, frame_size_, false, kTl0Qp,
+        layers_->OnEncodeDone(0, timestamp, frame_size_, false, kTl0Qp,
                               IgnoredCodecSpecificInfo());
       }
     } else if (flags == kTl1Flags || flags == kTl1SyncFlags) {
-      layers_->OnEncodeDone(timestamp, frame_size_, false, kTl1Qp,
+      layers_->OnEncodeDone(0, timestamp, frame_size_, false, kTl1Qp,
                             IgnoredCodecSpecificInfo());
     } else if (flags == -1) {
       dropped_frame = true;
@@ -587,7 +589,7 @@
   layers_.reset(new ScreenshareLayers(2));
   // New layer instance, OnRatesUpdated() never called.
   // UpdateConfiguration() call should not cause crash.
-  layers_->UpdateConfiguration(&cfg_);
+  layers_->UpdateConfiguration(0, &cfg_);
 }
 
 TEST_F(ScreenshareLayerTest, RespectsConfiguredFramerate) {
@@ -600,11 +602,11 @@
 
   // Send at regular rate - no drops expected.
   for (int64_t i = 0; i < kTestSpanMs; i += kFrameIntervalsMs) {
-    if (UpdateLayerConfig(timestamp).drop_frame) {
+    if (UpdateLayerConfig(0, timestamp).drop_frame) {
       ++num_discarded_frames;
     } else {
       size_t frame_size_bytes = kDefaultTl0BitrateKbps * kFrameIntervalsMs / 8;
-      layers_->OnEncodeDone(timestamp, frame_size_bytes, false, kDefaultQp,
+      layers_->OnEncodeDone(0, timestamp, frame_size_bytes, false, kDefaultQp,
                             IgnoredCodecSpecificInfo());
     }
     timestamp += kFrameIntervalsMs * 90;
@@ -618,11 +620,11 @@
   num_input_frames = 0;
   num_discarded_frames = 0;
   for (int64_t i = 0; i < kTestSpanMs; i += kFrameIntervalsMs / 2) {
-    if (UpdateLayerConfig(timestamp).drop_frame) {
+    if (UpdateLayerConfig(0, timestamp).drop_frame) {
       ++num_discarded_frames;
     } else {
       size_t frame_size_bytes = kDefaultTl0BitrateKbps * kFrameIntervalsMs / 8;
-      layers_->OnEncodeDone(timestamp, frame_size_bytes, false, kDefaultQp,
+      layers_->OnEncodeDone(0, timestamp, frame_size_bytes, false, kDefaultQp,
                             IgnoredCodecSpecificInfo());
     }
     timestamp += kFrameIntervalsMs * 90 / 2;
@@ -643,13 +645,14 @@
   ASSERT_TRUE(tl_config_.layer_sync);
 
   // Simulate overshoot of this frame.
-  layers_->OnEncodeDone(timestamp_, 0, false, 0, nullptr);
+  layers_->OnEncodeDone(0, timestamp_, 0, false, 0, nullptr);
 
-  config_updated_ = layers_->UpdateConfiguration(&cfg_);
+  config_updated_ = layers_->UpdateConfiguration(0, &cfg_);
   EXPECT_EQ(kTl1SyncFlags, LibvpxVp8Encoder::EncodeFlags(tl_config_));
 
   CodecSpecificInfo new_info;
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp, &new_info);
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
+                        &new_info);
   EXPECT_TRUE(new_info.codecSpecific.VP8.layerSync);
 }
 
@@ -659,26 +662,26 @@
 
   // Add a large gap, so there's plenty of room in the rate tracker.
   timestamp_ += kTimestampDelta5Fps * 3;
-  EXPECT_FALSE(UpdateLayerConfig(timestamp_).drop_frame);
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, kDefaultQp,
+  EXPECT_FALSE(UpdateLayerConfig(0, timestamp_).drop_frame);
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, kDefaultQp,
                         IgnoredCodecSpecificInfo());
 
   // Frame interval below 90% if desired time is not allowed, try inserting
   // frame just before this limit.
   const int64_t kMinFrameInterval = (kTimestampDelta5Fps * 85) / 100;
   timestamp_ += kMinFrameInterval - 90;
-  EXPECT_TRUE(UpdateLayerConfig(timestamp_).drop_frame);
+  EXPECT_TRUE(UpdateLayerConfig(0, timestamp_).drop_frame);
 
   // Try again at the limit, now it should pass.
   timestamp_ += 90;
-  EXPECT_FALSE(UpdateLayerConfig(timestamp_).drop_frame);
+  EXPECT_FALSE(UpdateLayerConfig(0, timestamp_).drop_frame);
 }
 
 TEST_F(ScreenshareLayerTest, AdjustsBitrateWhenDroppingFrames) {
   const uint32_t kTimestampDelta10Fps = kTimestampDelta5Fps / 2;
   const int kNumFrames = 30;
   uint32_t default_bitrate = cfg_.rc_target_bitrate;
-  layers_->OnRatesUpdated(kDefault2TlBitratesBps, 10);
+  layers_->OnRatesUpdated(0, kDefault2TlBitratesBps, 10);
 
   int num_dropped_frames = 0;
   for (int i = 0; i < kNumFrames; ++i) {
@@ -686,7 +689,7 @@
       ++num_dropped_frames;
     timestamp_ += kTimestampDelta10Fps;
   }
-  layers_->UpdateConfiguration(&cfg_);
+  layers_->UpdateConfiguration(0, &cfg_);
 
   EXPECT_EQ(num_dropped_frames, kNumFrames / 2);
   EXPECT_EQ(cfg_.rc_target_bitrate, default_bitrate * 2);
@@ -694,21 +697,21 @@
 
 TEST_F(ScreenshareLayerTest, UpdatesConfigurationAfterRateChange) {
   // Set inital rate again, no need to update configuration.
-  layers_->OnRatesUpdated(kDefault2TlBitratesBps, kFrameRate);
-  EXPECT_FALSE(layers_->UpdateConfiguration(&cfg_));
+  layers_->OnRatesUpdated(0, kDefault2TlBitratesBps, kFrameRate);
+  EXPECT_FALSE(layers_->UpdateConfiguration(0, &cfg_));
 
   // Rate changed, now update config.
   std::vector<uint32_t> bitrates = kDefault2TlBitratesBps;
   bitrates[1] -= 100000;
-  layers_->OnRatesUpdated(bitrates, 5);
-  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg_));
+  layers_->OnRatesUpdated(0, bitrates, 5);
+  EXPECT_TRUE(layers_->UpdateConfiguration(0, &cfg_));
 
   // Changed rate, but then set changed rate again before trying to update
   // configuration, update should still apply.
   bitrates[1] -= 100000;
-  layers_->OnRatesUpdated(bitrates, 5);
-  layers_->OnRatesUpdated(bitrates, 5);
-  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg_));
+  layers_->OnRatesUpdated(0, bitrates, 5);
+  layers_->OnRatesUpdated(0, bitrates, 5);
+  EXPECT_TRUE(layers_->UpdateConfiguration(0, &cfg_));
 }
 
 // TODO(bugs.webrtc.org/10260): Fix.
@@ -721,42 +724,42 @@
   ASSERT_TRUE(tl_config_.layer_sync);
 
   // Simulate overshoot of this frame.
-  layers_->OnEncodeDone(timestamp_, 0, false, -1, nullptr);
+  layers_->OnEncodeDone(0, timestamp_, 0, false, -1, nullptr);
 
   // Simulate re-encoded frame.
-  layers_->OnEncodeDone(timestamp_, 1, false, max_qp_,
+  layers_->OnEncodeDone(0, timestamp_, 1, false, max_qp_,
                         IgnoredCodecSpecificInfo());
 
   // Next frame, expect boosted quality.
   // Slightly alter bitrate between each frame.
   std::vector<uint32_t> kDefault2TlBitratesBpsAlt = kDefault2TlBitratesBps;
   kDefault2TlBitratesBpsAlt[1] += 4000;
-  layers_->OnRatesUpdated(kDefault2TlBitratesBpsAlt, kFrameRate);
+  layers_->OnRatesUpdated(0, kDefault2TlBitratesBpsAlt, kFrameRate);
   EXPECT_EQ(kTl1Flags, SkipUntilTlAndSync(1, false));
   EXPECT_TRUE(config_updated_);
   EXPECT_LT(cfg_.rc_max_quantizer, max_qp_);
   uint32_t adjusted_qp = cfg_.rc_max_quantizer;
 
   // Simulate overshoot of this frame.
-  layers_->OnEncodeDone(timestamp_, 0, false, -1, nullptr);
+  layers_->OnEncodeDone(0, timestamp_, 0, false, -1, nullptr);
 
   // Simulate re-encoded frame.
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, max_qp_,
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, max_qp_,
                         IgnoredCodecSpecificInfo());
 
   // A third frame, expect boosted quality.
-  layers_->OnRatesUpdated(kDefault2TlBitratesBps, kFrameRate);
+  layers_->OnRatesUpdated(0, kDefault2TlBitratesBps, kFrameRate);
   EXPECT_EQ(kTl1Flags, SkipUntilTlAndSync(1, false));
   EXPECT_TRUE(config_updated_);
   EXPECT_LT(cfg_.rc_max_quantizer, max_qp_);
   EXPECT_EQ(adjusted_qp, cfg_.rc_max_quantizer);
 
   // Frame encoded.
-  layers_->OnEncodeDone(timestamp_, frame_size_, false, max_qp_,
+  layers_->OnEncodeDone(0, timestamp_, frame_size_, false, max_qp_,
                         IgnoredCodecSpecificInfo());
 
   // A fourth frame, max qp should be restored.
-  layers_->OnRatesUpdated(kDefault2TlBitratesBpsAlt, kFrameRate);
+  layers_->OnRatesUpdated(0, kDefault2TlBitratesBpsAlt, kFrameRate);
   EXPECT_EQ(kTl1Flags, SkipUntilTlAndSync(1, false));
   EXPECT_EQ(cfg_.rc_max_quantizer, max_qp_);
 }
diff --git a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
index 4744e38..6a6604b 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
@@ -35,14 +35,14 @@
 constexpr uint32_t kSimulcastScreenshareMinBitrateKbps = 600;
 constexpr uint32_t kSimulcastScreenshareMaxBitrateKbps = 1250;
 
-class MockTemporalLayers : public Vp8TemporalLayers {
+class MockTemporalLayers : public Vp8FrameBufferController {
  public:
-  MOCK_METHOD1(UpdateLayerConfig, Vp8FrameConfig(uint32_t));
-  MOCK_METHOD2(OnRatesUpdated, void(const std::vector<uint32_t>&, int));
-  MOCK_METHOD1(UpdateConfiguration, bool(Vp8EncoderConfig*));
-  MOCK_METHOD5(OnEncodeDone,
-               void(uint32_t, size_t, bool, int, CodecSpecificInfo*));
-  MOCK_METHOD3(FrameEncoded, void(uint32_t, size_t, int));
+  MOCK_METHOD2(UpdateLayerConfig, Vp8FrameConfig(size_t, uint32_t));
+  MOCK_METHOD3(OnRatesUpdated, void(size_t, const std::vector<uint32_t>&, int));
+  MOCK_METHOD2(UpdateConfiguration, bool(size_t, Vp8EncoderConfig*));
+  MOCK_METHOD6(OnEncodeDone,
+               void(size_t, uint32_t, size_t, bool, int, CodecSpecificInfo*));
+  MOCK_METHOD4(FrameEncoded, void(size_t, uint32_t, size_t, int));
   MOCK_CONST_METHOD0(Tl0PicIdx, uint8_t());
   MOCK_CONST_METHOD1(GetTemporalLayerId, int(const Vp8FrameConfig&));
 };
diff --git a/modules/video_coding/video_codec_initializer_unittest.cc b/modules/video_coding/video_codec_initializer_unittest.cc
index 0f2d9f1..0eca06d 100644
--- a/modules/video_coding/video_codec_initializer_unittest.cc
+++ b/modules/video_coding/video_codec_initializer_unittest.cc
@@ -20,9 +20,9 @@
 #include "api/video/video_bitrate_allocation.h"
 #include "api/video/video_bitrate_allocator.h"
 #include "api/video/video_bitrate_allocator_factory.h"
-#include "api/video_codecs/create_vp8_temporal_layers.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
+#include "api/video_codecs/vp8_temporal_layers_factory.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
 #include "rtc_base/checks.h"
@@ -86,7 +86,7 @@
 
   bool InitializeCodec() {
     codec_out_ = VideoCodec();
-    temporal_layers_.clear();
+    frame_buffer_controller_.reset();
     if (!VideoCodecInitializer::SetupCodec(config_, streams_, &codec_out_)) {
       return false;
     }
@@ -98,11 +98,8 @@
 
     // Make sure temporal layers instances have been created.
     if (codec_out_.codecType == VideoCodecType::kVideoCodecVP8) {
-      for (int i = 0; i < codec_out_.numberOfSimulcastStreams; ++i) {
-        temporal_layers_.emplace_back(
-            CreateVp8TemporalLayers(Vp8TemporalLayersType::kFixedPattern,
-                                    codec_out_.VP8()->numberOfTemporalLayers));
-      }
+      Vp8TemporalLayersFactory factory;
+      frame_buffer_controller_ = factory.Create(codec_out_);
     }
     return true;
   }
@@ -139,7 +136,7 @@
   // Output.
   VideoCodec codec_out_;
   std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_;
-  std::vector<std::unique_ptr<Vp8TemporalLayers>> temporal_layers_;
+  std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_;
 };
 
 TEST_F(VideoCodecInitializerTest, SingleStreamVp8Screenshare) {
diff --git a/test/BUILD.gn b/test/BUILD.gn
index b07a1f8..bce875f 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -648,8 +648,8 @@
     "../api/video:video_bitrate_allocation",
     "../api/video:video_frame",
     "../api/video:video_frame_i420",
-    "../api/video_codecs:create_vp8_temporal_layers",
     "../api/video_codecs:video_codecs_api",
+    "../api/video_codecs:vp8_temporal_layers_factory",
     "../common_video:common_video",
     "../modules:module_api",
     "../modules/video_coding:codec_globals_headers",
diff --git a/test/fake_vp8_encoder.cc b/test/fake_vp8_encoder.cc
index 6ad4094..c9adee4 100644
--- a/test/fake_vp8_encoder.cc
+++ b/test/fake_vp8_encoder.cc
@@ -13,8 +13,8 @@
 #include <algorithm>
 
 #include "absl/types/optional.h"
-#include "api/video_codecs/create_vp8_temporal_layers.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
+#include "api/video_codecs/vp8_temporal_layers_factory.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/video_coding/codecs/interface/common_constants.h"
 #include "modules/video_coding/include/video_codec_interface.h"
@@ -59,7 +59,8 @@
     return result;
   }
 
-  SetupTemporalLayers(*config);
+  Vp8TemporalLayersFactory factory;
+  frame_buffer_controller_ = factory.Create(*config);
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
@@ -70,26 +71,6 @@
   return result;
 }
 
-void FakeVP8Encoder::SetupTemporalLayers(const VideoCodec& codec) {
-  RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
-
-  int num_streams = SimulcastUtility::NumberOfSimulcastStreams(codec);
-  for (int i = 0; i < num_streams; ++i) {
-    Vp8TemporalLayersType type;
-    int num_temporal_layers =
-        SimulcastUtility::NumberOfTemporalLayers(codec, i);
-    if (SimulcastUtility::IsConferenceModeScreenshare(codec) && i == 0) {
-      type = Vp8TemporalLayersType::kBitrateDynamic;
-      // Legacy screenshare layers supports max 2 layers.
-      num_temporal_layers = std::max<int>(2, num_temporal_layers);
-    } else {
-      type = Vp8TemporalLayersType::kFixedPattern;
-    }
-    temporal_layers_.emplace_back(
-        CreateVp8TemporalLayers(type, num_temporal_layers));
-  }
-}
-
 void FakeVP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
                                            size_t size_bytes,
                                            VideoFrameType frame_type,
@@ -99,8 +80,9 @@
   codec_specific->codecType = kVideoCodecVP8;
   codec_specific->codecSpecific.VP8.keyIdx = kNoKeyIdx;
   codec_specific->codecSpecific.VP8.nonReference = false;
-  temporal_layers_[stream_idx]->OnEncodeDone(
-      timestamp, size_bytes, frame_type == kVideoFrameKey, -1, codec_specific);
+  frame_buffer_controller_->OnEncodeDone(stream_idx, timestamp, size_bytes,
+                                         frame_type == kVideoFrameKey, -1,
+                                         codec_specific);
 }
 
 std::unique_ptr<RTPFragmentationHeader> FakeVP8Encoder::EncodeHook(
@@ -108,7 +90,8 @@
     CodecSpecificInfo* codec_specific) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
   uint8_t stream_idx = encoded_image->SpatialIndex().value_or(0);
-  temporal_layers_[stream_idx]->UpdateLayerConfig(encoded_image->Timestamp());
+  frame_buffer_controller_->UpdateLayerConfig(stream_idx,
+                                              encoded_image->Timestamp());
   PopulateCodecSpecific(codec_specific, encoded_image->size(),
                         encoded_image->_frameType, stream_idx,
                         encoded_image->Timestamp());
diff --git a/test/fake_vp8_encoder.h b/test/fake_vp8_encoder.h
index 1906e74..23c6551 100644
--- a/test/fake_vp8_encoder.h
+++ b/test/fake_vp8_encoder.h
@@ -13,12 +13,13 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <memory>
-#include <vector>
 
 #include "api/video/encoded_image.h"
 #include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/video_encoder.h"
+#include "api/video_codecs/vp8_frame_buffer_controller.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/include/module_common_types.h"
@@ -45,7 +46,6 @@
   EncoderInfo GetEncoderInfo() const override;
 
  private:
-  void SetupTemporalLayers(const VideoCodec& codec);
   void PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
                              size_t size_bytes,
                              VideoFrameType frame_type,
@@ -58,7 +58,7 @@
 
   rtc::SequencedTaskChecker sequence_checker_;
 
-  std::vector<std::unique_ptr<Vp8TemporalLayers>> temporal_layers_
+  std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
       RTC_GUARDED_BY(sequence_checker_);
 };
 
diff --git a/video/BUILD.gn b/video/BUILD.gn
index a9a3c04..7a6537c8 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -518,8 +518,8 @@
       "../api/video:video_bitrate_allocation",
       "../api/video:video_frame",
       "../api/video:video_frame_i420",
-      "../api/video_codecs:create_vp8_temporal_layers",
       "../api/video_codecs:video_codecs_api",
+      "../api/video_codecs:vp8_temporal_layers_factory",
       "../call:call_interfaces",
       "../call:fake_network",
       "../call:mock_bitrate_allocator",
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 449286f..d68af8d 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1455,6 +1455,11 @@
     has_seen_first_significant_bwe_change_ = true;
   }
 
+  if (encoder_) {
+    encoder_->OnPacketLossRateUpdate(static_cast<float>(fraction_lost) / 256.f);
+    encoder_->OnRttUpdate(round_trip_time_ms);
+  }
+
   uint32_t framerate_fps = GetInputFramerateFps();
   frame_dropper_.SetRates((target_bitrate.bps() + 500) / 1000, framerate_fps);
   SetEncoderRates(GetBitrateAllocationAndNotifyObserver(target_bitrate.bps(),
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index e2453a4..a9f1c4d 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -18,8 +18,8 @@
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/i420_buffer.h"
 #include "api/video/video_bitrate_allocation.h"
-#include "api/video_codecs/create_vp8_temporal_layers.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
+#include "api/video_codecs/vp8_temporal_layers_factory.h"
 #include "media/base/video_adapter.h"
 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
 #include "modules/video_coding/utility/default_video_bitrate_allocator.h"
@@ -678,12 +678,8 @@
       if (config->codecType == kVideoCodecVP8) {
         // Simulate setting up temporal layers, in order to validate the life
         // cycle of these objects.
-        int num_streams = std::max<int>(1, config->numberOfSimulcastStreams);
-        for (int i = 0; i < num_streams; ++i) {
-          allocated_temporal_layers_.emplace_back(
-              CreateVp8TemporalLayers(Vp8TemporalLayersType::kFixedPattern,
-                                      config->VP8().numberOfTemporalLayers));
-        }
+        Vp8TemporalLayersFactory factory;
+        frame_buffer_controller_ = factory.Create(*config);
       }
       if (force_init_encode_failed_) {
         initialized_ = EncoderState::kInitializationFailed;
@@ -736,7 +732,7 @@
     int last_input_height_ RTC_GUARDED_BY(local_crit_sect_) = 0;
     bool quality_scaling_ RTC_GUARDED_BY(local_crit_sect_) = true;
     bool is_hardware_accelerated_ RTC_GUARDED_BY(local_crit_sect_) = false;
-    std::vector<std::unique_ptr<Vp8TemporalLayers>> allocated_temporal_layers_
+    std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
         RTC_GUARDED_BY(local_crit_sect_);
     bool force_init_encode_failed_ RTC_GUARDED_BY(local_crit_sect_) = false;
     double rate_factor_ RTC_GUARDED_BY(local_crit_sect_) = 1.0;