diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.cc b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
index bcead35d05..eea693370e 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
@@ -286,13 +286,11 @@ std::vector<TemporalLayers::FrameConfig> GetTemporalPattern(size_t num_layers) {
 }
 }  // namespace
 
-DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers,
-                                             uint8_t initial_tl0_pic_idx)
+DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers)
     : num_layers_(std::max(1, number_of_temporal_layers)),
       temporal_ids_(GetTemporalIds(num_layers_)),
       temporal_layer_sync_(GetTemporalLayerSync(num_layers_)),
       temporal_pattern_(GetTemporalPattern(num_layers_)),
-      tl0_pic_idx_(initial_tl0_pic_idx),
       pattern_idx_(255),
       last_base_layer_sync_(false) {
   RTC_DCHECK_EQ(temporal_pattern_.size(), temporal_layer_sync_.size());
@@ -305,10 +303,6 @@ DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers,
   RTC_DCHECK_LE(temporal_ids_.size(), temporal_pattern_.size());
 }
 
-uint8_t DefaultTemporalLayers::Tl0PicIdx() const {
-  return tl0_pic_idx_;
-}
-
 void DefaultTemporalLayers::OnRatesUpdated(
     const std::vector<uint32_t>& bitrates_bps,
     int framerate_fps) {
@@ -367,7 +361,6 @@ void DefaultTemporalLayers::PopulateCodecSpecific(
   if (num_layers_ == 1) {
     vp8_info->temporalIdx = kNoTemporalIdx;
     vp8_info->layerSync = false;
-    vp8_info->tl0PicIdx = kNoTl0PicIdx;
   } else {
     vp8_info->temporalIdx = tl_config.packetizer_temporal_idx;
     vp8_info->layerSync = tl_config.layer_sync;
@@ -380,10 +373,7 @@ void DefaultTemporalLayers::PopulateCodecSpecific(
       // be a layer sync.
       vp8_info->layerSync = true;
     }
-    if (vp8_info->temporalIdx == 0)
-      tl0_pic_idx_++;
     last_base_layer_sync_ = frame_is_keyframe;
-    vp8_info->tl0PicIdx = tl0_pic_idx_;
   }
 }
 
@@ -414,9 +404,8 @@ std::vector<std::set<uint8_t>> GetTemporalDependencies(
 }
 
 DefaultTemporalLayersChecker::DefaultTemporalLayersChecker(
-    int num_temporal_layers,
-    uint8_t initial_tl0_pic_idx)
-    : TemporalLayersChecker(num_temporal_layers, initial_tl0_pic_idx),
+    int num_temporal_layers)
+    : TemporalLayersChecker(num_temporal_layers),
       num_layers_(std::max(1, num_temporal_layers)),
       temporal_ids_(GetTemporalIds(num_layers_)),
       temporal_dependencies_(GetTemporalDependencies(num_layers_)),
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.h b/modules/video_coding/codecs/vp8/default_temporal_layers.h
index 2abc41588d..f8bb09b09c 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.h
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.h
@@ -23,8 +23,7 @@ namespace webrtc {
 
 class DefaultTemporalLayers : public TemporalLayers {
  public:
-  DefaultTemporalLayers(int number_of_temporal_layers,
-                        uint8_t initial_tl0_pic_idx);
+  explicit DefaultTemporalLayers(int number_of_temporal_layers);
   virtual ~DefaultTemporalLayers() {}
 
   // Returns the recommended VP8 encode flags needed. May refresh the decoder
@@ -44,15 +43,12 @@ class DefaultTemporalLayers : public TemporalLayers {
 
   void FrameEncoded(unsigned int size, int qp) override {}
 
-  uint8_t Tl0PicIdx() const override;
-
  private:
   const size_t num_layers_;
   const std::vector<unsigned int> temporal_ids_;
   const std::vector<bool> temporal_layer_sync_;
   const std::vector<TemporalLayers::FrameConfig> temporal_pattern_;
 
-  uint8_t tl0_pic_idx_;
   uint8_t pattern_idx_;
   bool last_base_layer_sync_;
   // Updated cumulative bitrates, per temporal layer.
@@ -61,8 +57,7 @@ class DefaultTemporalLayers : public TemporalLayers {
 
 class DefaultTemporalLayersChecker : public TemporalLayersChecker {
  public:
-  DefaultTemporalLayersChecker(int number_of_temporal_layers,
-                               uint8_t initial_tl0_pic_idx);
+  explicit DefaultTemporalLayersChecker(int number_of_temporal_layers);
   bool CheckTemporalConfig(
       bool frame_is_keyframe,
       const TemporalLayers::FrameConfig& frame_config) override;
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 c11a7c933f..f61c302f17 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
@@ -71,8 +71,8 @@ std::vector<uint32_t> GetTemporalLayerRates(int target_bitrate_kbps,
 }  // namespace
 
 TEST(TemporalLayersTest, 2Layers) {
-  DefaultTemporalLayers tl(2, 0);
-  DefaultTemporalLayersChecker checker(2, 0);
+  DefaultTemporalLayers tl(2);
+  DefaultTemporalLayersChecker checker(2);
   Vp8EncoderConfig cfg;
   CodecSpecificInfoVP8 vp8_info;
   tl.OnRatesUpdated(GetTemporalLayerRates(500, 30, 1), 30);
@@ -119,8 +119,8 @@ TEST(TemporalLayersTest, 2Layers) {
 }
 
 TEST(TemporalLayersTest, 3Layers) {
-  DefaultTemporalLayers tl(3, 0);
-  DefaultTemporalLayersChecker checker(3, 0);
+  DefaultTemporalLayers tl(3);
+  DefaultTemporalLayersChecker checker(3);
   Vp8EncoderConfig cfg;
   CodecSpecificInfoVP8 vp8_info;
   tl.OnRatesUpdated(GetTemporalLayerRates(500, 30, 1), 30);
@@ -168,8 +168,8 @@ TEST(TemporalLayersTest, 3Layers) {
 
 TEST(TemporalLayersTest, Alternative3Layers) {
   ScopedFieldTrials field_trial("WebRTC-UseShortVP8TL3Pattern/Enabled/");
-  DefaultTemporalLayers tl(3, 0);
-  DefaultTemporalLayersChecker checker(3, 0);
+  DefaultTemporalLayers tl(3);
+  DefaultTemporalLayersChecker checker(3);
   Vp8EncoderConfig cfg;
   CodecSpecificInfoVP8 vp8_info;
   tl.OnRatesUpdated(GetTemporalLayerRates(500, 30, 1), 30);
@@ -204,8 +204,8 @@ TEST(TemporalLayersTest, Alternative3Layers) {
 }
 
 TEST(TemporalLayersTest, 4Layers) {
-  DefaultTemporalLayers tl(4, 0);
-  DefaultTemporalLayersChecker checker(4, 0);
+  DefaultTemporalLayers tl(4);
+  DefaultTemporalLayersChecker checker(4);
   Vp8EncoderConfig cfg;
   CodecSpecificInfoVP8 vp8_info;
   tl.OnRatesUpdated(GetTemporalLayerRates(500, 30, 1), 30);
@@ -251,8 +251,8 @@ TEST(TemporalLayersTest, 4Layers) {
 }
 
 TEST(TemporalLayersTest, KeyFrame) {
-  DefaultTemporalLayers tl(3, 0);
-  DefaultTemporalLayersChecker checker(3, 0);
+  DefaultTemporalLayers tl(3);
+  DefaultTemporalLayersChecker checker(3);
   Vp8EncoderConfig cfg;
   CodecSpecificInfoVP8 vp8_info;
   tl.OnRatesUpdated(GetTemporalLayerRates(500, 30, 1), 30);
@@ -366,7 +366,7 @@ INSTANTIATE_TEST_CASE_P(DefaultTemporalLayersTest,
 
 TEST_P(TemporalLayersReferenceTest, ValidFrameConfigs) {
   const int num_layers = GetParam();
-  DefaultTemporalLayers tl(num_layers, 0);
+  DefaultTemporalLayers tl(num_layers);
   Vp8EncoderConfig cfg;
   tl.OnRatesUpdated(GetTemporalLayerRates(500, 30, 1), 30);
   tl.UpdateConfiguration(&cfg);
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index 1f442a8017..9eeb4b80b4 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -18,7 +18,6 @@
 #include "modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/ptr_util.h"
-#include "rtc_base/random.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/field_trial.h"
@@ -208,12 +207,6 @@ LibvpxVp8Encoder::LibvpxVp8Encoder()
       number_of_cores_(0),
       rc_max_intra_target_(0),
       key_frame_request_(kMaxSimulcastStreams, false) {
-  Random random(rtc::TimeMicros());
-  picture_id_.reserve(kMaxSimulcastStreams);
-  for (int i = 0; i < kMaxSimulcastStreams; ++i) {
-    picture_id_.push_back(random.Rand<uint16_t>() & 0x7FFF);
-    tl0_pic_idx_.push_back(random.Rand<uint8_t>());
-  }
   temporal_layers_.reserve(kMaxSimulcastStreams);
   temporal_layers_checkers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
@@ -253,9 +246,6 @@ int LibvpxVp8Encoder::Release() {
     vpx_img_free(&raw_images_.back());
     raw_images_.pop_back();
   }
-  for (size_t i = 0; i < temporal_layers_.size(); ++i) {
-    tl0_pic_idx_[i] = temporal_layers_[i]->Tl0PicIdx();
-  }
   temporal_layers_.clear();
   temporal_layers_checkers_.clear();
   inited_ = false;
@@ -347,9 +337,9 @@ void LibvpxVp8Encoder::SetupTemporalLayers(int num_streams,
   RTC_DCHECK(temporal_layers_.empty());
   for (int i = 0; i < num_streams; ++i) {
     temporal_layers_.emplace_back(
-        TemporalLayers::CreateTemporalLayers(codec, i, tl0_pic_idx_[i]));
+        TemporalLayers::CreateTemporalLayers(codec, i));
     temporal_layers_checkers_.emplace_back(
-        TemporalLayers::CreateTemporalLayersChecker(codec, i, tl0_pic_idx_[i]));
+        TemporalLayers::CreateTemporalLayersChecker(codec, i));
   }
 }
 
@@ -871,15 +861,12 @@ void LibvpxVp8Encoder::PopulateCodecSpecific(
   codec_specific->codecType = kVideoCodecVP8;
   codec_specific->codec_name = ImplementationName();
   CodecSpecificInfoVP8* vp8Info = &(codec_specific->codecSpecific.VP8);
-  vp8Info->pictureId = picture_id_[stream_idx];
   vp8Info->simulcastIdx = stream_idx;
   vp8Info->keyIdx = kNoKeyIdx;  // TODO(hlundin) populate this
   vp8Info->nonReference = (pkt.data.frame.flags & VPX_FRAME_IS_DROPPABLE) != 0;
   temporal_layers_[stream_idx]->PopulateCodecSpecific(
       (pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, tl_config, vp8Info,
       timestamp);
-  // Prepare next.
-  picture_id_[stream_idx] = (picture_id_[stream_idx] + 1) & 0x7FFF;
 }
 
 int LibvpxVp8Encoder::GetEncodedPartitions(
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
index d6c02dd446..f3e8c7a91a 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
@@ -96,8 +96,6 @@ class LibvpxVp8Encoder : public VP8Encoder {
   uint32_t rc_max_intra_target_;
   std::vector<std::unique_ptr<TemporalLayers>> temporal_layers_;
   std::vector<std::unique_ptr<TemporalLayersChecker>> temporal_layers_checkers_;
-  std::vector<uint16_t> picture_id_;
-  std::vector<uint8_t> tl0_pic_idx_;
   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 f3d8359da0..733ca0aee6 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.cc
@@ -38,13 +38,11 @@ constexpr int ScreenshareLayers::kMaxNumTemporalLayers;
 const int ScreenshareLayers::kMaxFrameIntervalMs = 2750;
 
 ScreenshareLayers::ScreenshareLayers(int num_temporal_layers,
-                                     uint8_t initial_tl0_pic_idx,
                                      Clock* clock)
     : clock_(clock),
       number_of_temporal_layers_(
           std::min(kMaxNumTemporalLayers, num_temporal_layers)),
       last_base_layer_sync_(false),
-      tl0_pic_idx_(initial_tl0_pic_idx),
       active_layer_(-1),
       last_timestamp_(-1),
       last_sync_timestamp_(-1),
@@ -63,10 +61,6 @@ ScreenshareLayers::~ScreenshareLayers() {
   UpdateHistograms();
 }
 
-uint8_t ScreenshareLayers::Tl0PicIdx() const {
-  return tl0_pic_idx_;
-}
-
 TemporalLayers::FrameConfig ScreenshareLayers::UpdateLayerConfig(
     uint32_t timestamp) {
   if (number_of_temporal_layers_ <= 1) {
@@ -286,7 +280,6 @@ void ScreenshareLayers::PopulateCodecSpecific(
   if (number_of_temporal_layers_ == 1) {
     vp8_info->temporalIdx = kNoTemporalIdx;
     vp8_info->layerSync = false;
-    vp8_info->tl0PicIdx = kNoTl0PicIdx;
   } else {
     int64_t unwrapped_timestamp = time_wrap_handler_.Unwrap(timestamp);
     vp8_info->temporalIdx = tl_config.packetizer_temporal_idx;
@@ -301,11 +294,7 @@ void ScreenshareLayers::PopulateCodecSpecific(
       last_sync_timestamp_ = unwrapped_timestamp;
       vp8_info->layerSync = true;
     }
-    if (vp8_info->temporalIdx == 0) {
-      tl0_pic_idx_++;
-    }
     last_base_layer_sync_ = frame_is_keyframe;
-    vp8_info->tl0PicIdx = tl0_pic_idx_;
   }
 }
 
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers.h b/modules/video_coding/codecs/vp8/screenshare_layers.h
index 63c97e04fb..c479917fc2 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.h
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.h
@@ -29,7 +29,6 @@ class ScreenshareLayers : public TemporalLayers {
   static const int kMaxFrameIntervalMs;
 
   ScreenshareLayers(int num_temporal_layers,
-                    uint8_t initial_tl0_pic_idx,
                     Clock* clock);
   virtual ~ScreenshareLayers();
 
@@ -52,8 +51,6 @@ class ScreenshareLayers : public TemporalLayers {
 
   void FrameEncoded(unsigned int size, int qp) override;
 
-  uint8_t Tl0PicIdx() const override;
-
  private:
   enum class TemporalLayerState : int { kDrop, kTl0, kTl1, kTl1Sync };
 
@@ -64,7 +61,6 @@ class ScreenshareLayers : public TemporalLayers {
 
   int number_of_temporal_layers_;
   bool last_base_layer_sync_;
-  uint8_t tl0_pic_idx_;
   int active_layer_;
   int64_t last_timestamp_;
   int64_t last_sync_timestamp_;
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
index 2b9fb0dbb7..04762a3606 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
@@ -61,7 +61,7 @@ class ScreenshareLayerTest : public ::testing::Test {
   virtual ~ScreenshareLayerTest() {}
 
   void SetUp() override {
-    layers_.reset(new ScreenshareLayers(2, 0, &clock_));
+    layers_.reset(new ScreenshareLayers(2, &clock_));
     cfg_ = ConfigureBitrates();
   }
 
@@ -175,7 +175,7 @@ class ScreenshareLayerTest : public ::testing::Test {
 };
 
 TEST_F(ScreenshareLayerTest, 1Layer) {
-  layers_.reset(new ScreenshareLayers(1, 0, &clock_));
+  layers_.reset(new ScreenshareLayers(1, &clock_));
   ConfigureBitrates();
   // One layer screenshare should not use the frame dropper as all frames will
   // belong to the base layer.
@@ -184,13 +184,11 @@ TEST_F(ScreenshareLayerTest, 1Layer) {
   timestamp_ += kTimestampDelta5Fps;
   EXPECT_EQ(static_cast<uint8_t>(kNoTemporalIdx), vp8_info_.temporalIdx);
   EXPECT_FALSE(vp8_info_.layerSync);
-  EXPECT_EQ(kNoTl0PicIdx, vp8_info_.tl0PicIdx);
 
   flags = EncodeFrame(false);
   EXPECT_EQ(kSingleLayerFlags, flags);
   EXPECT_EQ(static_cast<uint8_t>(kNoTemporalIdx), vp8_info_.temporalIdx);
   EXPECT_FALSE(vp8_info_.layerSync);
-  EXPECT_EQ(kNoTl0PicIdx, vp8_info_.tl0PicIdx);
 }
 
 TEST_F(ScreenshareLayerTest, 2LayersPeriodicSync) {
@@ -540,7 +538,7 @@ TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
 }
 
 TEST_F(ScreenshareLayerTest, AllowsUpdateConfigBeforeSetRates) {
-  layers_.reset(new ScreenshareLayers(2, 0, &clock_));
+  layers_.reset(new ScreenshareLayers(2, &clock_));
   // New layer instance, OnRatesUpdated() never called.
   // UpdateConfiguration() call should not cause crash.
   layers_->UpdateConfiguration(&cfg_);
diff --git a/modules/video_coding/codecs/vp8/simulcast_test_utility.h b/modules/video_coding/codecs/vp8/simulcast_test_utility.h
index ba2bdcb1c3..01d4aebcfb 100644
--- a/modules/video_coding/codecs/vp8/simulcast_test_utility.h
+++ b/modules/video_coding/codecs/vp8/simulcast_test_utility.h
@@ -96,7 +96,6 @@ class Vp8TestEncodedImageCallback : public EncodedImageCallback {
                encoded_image._length);
       }
     }
-    picture_id_ = codec_specific_info->codecSpecific.VP8.pictureId;
     layer_sync_[codec_specific_info->codecSpecific.VP8.simulcastIdx] =
         codec_specific_info->codecSpecific.VP8.layerSync;
     temporal_layer_[codec_specific_info->codecSpecific.VP8.simulcastIdx] =
diff --git a/modules/video_coding/codecs/vp8/temporal_layers.cc b/modules/video_coding/codecs/vp8/temporal_layers.cc
index 6339516952..3ecd0fe17f 100644
--- a/modules/video_coding/codecs/vp8/temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/temporal_layers.cc
@@ -49,34 +49,30 @@ bool IsConferenceModeScreenshare(const VideoCodec& codec) {
 
 std::unique_ptr<TemporalLayers> TemporalLayers::CreateTemporalLayers(
     const VideoCodec& codec,
-    size_t spatial_id,
-    uint8_t initial_tl0_pic_idx) {
+    size_t spatial_id) {
   if (IsConferenceModeScreenshare(codec) && spatial_id == 0) {
     // Conference mode temporal layering for screen content in base stream.
-    return rtc::MakeUnique<ScreenshareLayers>(2, initial_tl0_pic_idx,
-                                              Clock::GetRealTimeClock());
+    return rtc::MakeUnique<ScreenshareLayers>(2, Clock::GetRealTimeClock());
   }
 
   return rtc::MakeUnique<DefaultTemporalLayers>(
-      NumTemporalLayers(codec, spatial_id), initial_tl0_pic_idx);
+      NumTemporalLayers(codec, spatial_id));
 }
 
 std::unique_ptr<TemporalLayersChecker>
 TemporalLayers::CreateTemporalLayersChecker(const VideoCodec& codec,
-                                            size_t spatial_id,
-                                            uint8_t initial_tl0_pic_idx) {
+                                            size_t spatial_id) {
   if (IsConferenceModeScreenshare(codec) && spatial_id == 0) {
     // Conference mode temporal layering for screen content in base stream,
     // use generic checker.
-    return rtc::MakeUnique<TemporalLayersChecker>(2, initial_tl0_pic_idx);
+    return rtc::MakeUnique<TemporalLayersChecker>(2);
   }
 
   return rtc::MakeUnique<DefaultTemporalLayersChecker>(
-      NumTemporalLayers(codec, spatial_id), initial_tl0_pic_idx);
+      NumTemporalLayers(codec, spatial_id));
 }
 
-TemporalLayersChecker::TemporalLayersChecker(int num_temporal_layers,
-                                             uint8_t /*initial_tl0_pic_idx*/)
+TemporalLayersChecker::TemporalLayersChecker(int num_temporal_layers)
     : num_temporal_layers_(num_temporal_layers),
       sequence_number_(0),
       last_sync_sequence_number_(0),
diff --git a/modules/video_coding/codecs/vp8/temporal_layers.h b/modules/video_coding/codecs/vp8/temporal_layers.h
index 3d0912c082..e36f2571ee 100644
--- a/modules/video_coding/codecs/vp8/temporal_layers.h
+++ b/modules/video_coding/codecs/vp8/temporal_layers.h
@@ -99,12 +99,10 @@ class TemporalLayers {
 
   static std::unique_ptr<TemporalLayers> CreateTemporalLayers(
       const VideoCodec& codec,
-      size_t spatial_id,
-      uint8_t initial_tl0_pic_idx);
+      size_t spatial_id);
   static std::unique_ptr<TemporalLayersChecker> CreateTemporalLayersChecker(
       const VideoCodec& codec,
-      size_t spatial_id,
-      uint8_t initial_tl0_pic_idx);
+      size_t spatial_id);
 
   // Factory for TemporalLayer strategy. Default behavior is a fixed pattern
   // of temporal layers. See default_temporal_layers.cc
@@ -129,10 +127,6 @@ class TemporalLayers {
       uint32_t timestamp) = 0;
 
   virtual void FrameEncoded(unsigned int size, int qp) = 0;
-
-  // Returns the current tl0_pic_idx, so it can be reused in future
-  // instantiations.
-  virtual uint8_t Tl0PicIdx() const = 0;
 };
 
 // TODO(webrtc:9012): Remove TemporalLayersFactory type and field once all
@@ -149,7 +143,7 @@ class TemporalLayersFactory {
 // each UpdateLayersConfig() of a corresponding TemporalLayers class.
 class TemporalLayersChecker {
  public:
-  TemporalLayersChecker(int num_temporal_layers, uint8_t initial_tl0_pic_idx);
+  explicit TemporalLayersChecker(int num_temporal_layers);
   virtual ~TemporalLayersChecker() {}
 
   virtual bool CheckTemporalConfig(
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index 504cc3b986..fc853754b8 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -100,16 +100,10 @@ class TestVp8Impl : public VideoCodecUnitTest {
     EXPECT_EQ(0u, codec_specific_info->codecSpecific.VP8.simulcastIdx);
   }
 
-  void EncodeAndExpectFrameWith(int16_t picture_id,
-                                int tl0_pic_idx,
-                                uint8_t temporal_idx) {
+  void EncodeAndExpectFrameWith(uint8_t temporal_idx) {
     EncodedImage encoded_frame;
     CodecSpecificInfo codec_specific_info;
     EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
-    EXPECT_EQ(picture_id % (1 << 15),
-              codec_specific_info.codecSpecific.VP8.pictureId);
-    EXPECT_EQ(tl0_pic_idx % (1 << 8),
-              codec_specific_info.codecSpecific.VP8.tl0PicIdx);
     EXPECT_EQ(temporal_idx, codec_specific_info.codecSpecific.VP8.temporalIdx);
   }
 
@@ -319,7 +313,7 @@ TEST_F(TestVp8Impl, MAYBE_DecodeWithACompleteKeyFrame) {
   EXPECT_GT(I420PSNR(input_frame_.get(), decoded_frame.get()), 36);
 }
 
-TEST_F(TestVp8Impl, EncoderWith2TemporalLayersRetainsRtpStateAfterRelease) {
+TEST_F(TestVp8Impl, EncoderWith2TemporalLayers) {
   codec_settings_.VP8()->numberOfTemporalLayers = 2;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
@@ -330,78 +324,16 @@ TEST_F(TestVp8Impl, EncoderWith2TemporalLayersRetainsRtpStateAfterRelease) {
   EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
 
   EXPECT_EQ(0, codec_specific_info.codecSpecific.VP8.temporalIdx);
-  const int16_t picture_id = codec_specific_info.codecSpecific.VP8.pictureId;
-  const int tl0_pic_idx = codec_specific_info.codecSpecific.VP8.tl0PicIdx;
   // Temporal layer 1.
   input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
 
-  EncodeAndExpectFrameWith(picture_id + 1, tl0_pic_idx + 0, 1);
+  EncodeAndExpectFrameWith(1);
   // Temporal layer 0.
   input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 2, tl0_pic_idx + 1, 0);
+  EncodeAndExpectFrameWith(0);
   // Temporal layer 1.
   input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 3, tl0_pic_idx + 1, 1);
-
-  // Reinit.
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
-
-  // Temporal layer 0.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 4, tl0_pic_idx + 2, 0);
-  // Temporal layer 1.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 5, tl0_pic_idx + 2, 1);
-  // Temporal layer 0.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 6, tl0_pic_idx + 3, 0);
-  // Temporal layer 1.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 7, tl0_pic_idx + 3, 1);
-}
-
-TEST_F(TestVp8Impl, EncoderWith3TemporalLayersRetainsRtpStateAfterRelease) {
-  codec_settings_.VP8()->numberOfTemporalLayers = 3;
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
-
-  EncodedImage encoded_frame;
-  CodecSpecificInfo codec_specific_info;
-  EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
-
-  // Temporal layer 0.
-  EXPECT_EQ(0, codec_specific_info.codecSpecific.VP8.temporalIdx);
-  const int16_t picture_id = codec_specific_info.codecSpecific.VP8.pictureId;
-  const int tl0_pic_idx = codec_specific_info.codecSpecific.VP8.tl0PicIdx;
-  // Temporal layer 2.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 1, tl0_pic_idx + 0, 2);
-  // Temporal layer 1.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 2, tl0_pic_idx + 0, 1);
-  // Temporal layer 2.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 3, tl0_pic_idx + 0, 2);
-
-  // Reinit.
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
-
-  // Temporal layer 0.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 4, tl0_pic_idx + 1, 0);
-  // Temporal layer 2.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 5, tl0_pic_idx + 1, 2);
-  // Temporal layer 1.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 6, tl0_pic_idx + 1, 1);
-  // Temporal layer 2.
-  input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
-  EncodeAndExpectFrameWith(picture_id + 7, tl0_pic_idx + 1, 2);
+  EncodeAndExpectFrameWith(1);
 }
 
 TEST_F(TestVp8Impl, ScalingDisabledIfAutomaticResizeOff) {
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 442e02886f..3b28c57581 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -36,14 +36,10 @@ class TestVp9Impl : public VideoCodecUnitTest {
     return codec_settings;
   }
 
-  void ExpectFrameWith(int16_t picture_id,
-                       int tl0_pic_idx,
-                       uint8_t temporal_idx) {
+  void ExpectFrameWith(uint8_t temporal_idx) {
     EncodedImage encoded_frame;
     CodecSpecificInfo codec_specific_info;
     ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info));
-    EXPECT_EQ(picture_id, codec_specific_info.codecSpecific.VP9.picture_id);
-    EXPECT_EQ(tl0_pic_idx, codec_specific_info.codecSpecific.VP9.tl0_pic_idx);
     EXPECT_EQ(temporal_idx, codec_specific_info.codecSpecific.VP9.temporal_idx);
   }
 };
@@ -121,7 +117,7 @@ TEST_F(TestVp9Impl, ParserQpEqualsEncodedQp) {
   EXPECT_EQ(encoded_frame.qp_, qp);
 }
 
-TEST_F(TestVp9Impl, EncoderRetainsRtpStateAfterRelease) {
+TEST_F(TestVp9Impl, EncoderWith2TemporalLayers) {
   // Override default settings.
   codec_settings_.VP9()->numberOfTemporalLayers = 2;
   // Tl0PidIdx is only used in non-flexible mode.
@@ -136,8 +132,6 @@ TEST_F(TestVp9Impl, EncoderRetainsRtpStateAfterRelease) {
   EncodedImage encoded_frame;
   CodecSpecificInfo codec_specific_info;
   ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info));
-  int16_t picture_id = codec_specific_info.codecSpecific.VP9.picture_id;
-  int tl0_pic_idx = codec_specific_info.codecSpecific.VP9.tl0_pic_idx;
   EXPECT_EQ(0, codec_specific_info.codecSpecific.VP9.temporal_idx);
 
   // Temporal layer 1.
@@ -145,61 +139,21 @@ TEST_F(TestVp9Impl, EncoderRetainsRtpStateAfterRelease) {
                               kTimestampIncrementPerFrame);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 1) % (1 << 15), tl0_pic_idx, 1);
+  ExpectFrameWith(1);
 
   // Temporal layer 0.
   input_frame_->set_timestamp(input_frame_->timestamp() +
                               kTimestampIncrementPerFrame);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 2) % (1 << 15), (tl0_pic_idx + 1) % (1 << 8),
-                  0);
+  ExpectFrameWith(0);
 
   // Temporal layer 1.
   input_frame_->set_timestamp(input_frame_->timestamp() +
                               kTimestampIncrementPerFrame);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 3) % (1 << 15), (tl0_pic_idx + 1) % (1 << 8),
-                  1);
-
-  // Reinit.
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
-                                 0 /* max payload size (unused) */));
-
-  // Temporal layer 0.
-  input_frame_->set_timestamp(input_frame_->timestamp() +
-                              kTimestampIncrementPerFrame);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 4) % (1 << 15), (tl0_pic_idx + 2) % (1 << 8),
-                  0);
-
-  // Temporal layer 1.
-  input_frame_->set_timestamp(input_frame_->timestamp() +
-                              kTimestampIncrementPerFrame);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 5) % (1 << 15), (tl0_pic_idx + 2) % (1 << 8),
-                  1);
-
-  // Temporal layer 0.
-  input_frame_->set_timestamp(input_frame_->timestamp() +
-                              kTimestampIncrementPerFrame);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 6) % (1 << 15), (tl0_pic_idx + 3) % (1 << 8),
-                  0);
-
-  // Temporal layer 1.
-  input_frame_->set_timestamp(input_frame_->timestamp() +
-                              kTimestampIncrementPerFrame);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->Encode(*input_frame_, nullptr, nullptr));
-  ExpectFrameWith((picture_id + 7) % (1 << 15), (tl0_pic_idx + 3) % (1 << 8),
-                  1);
+  ExpectFrameWith(1);
 }
 
 TEST_F(TestVp9Impl, EncoderExplicitLayering) {
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc
index 06f485ba8c..4c4981d844 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -28,7 +28,6 @@
 #include "rtc_base/keep_ref_until_done.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/ptr_util.h"
-#include "rtc_base/random.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 
@@ -83,10 +82,6 @@ VP9EncoderImpl::VP9EncoderImpl()
       spatial_layer_(new ScreenshareLayersVP9(2)) {
   memset(&codec_, 0, sizeof(codec_));
   memset(&svc_params_, 0, sizeof(vpx_svc_extra_cfg_t));
-
-  Random random(rtc::TimeMicros());
-  picture_id_ = random.Rand<uint16_t>() & 0x7FFF;
-  tl0_pic_idx_ = random.Rand<uint8_t>();
 }
 
 VP9EncoderImpl::~VP9EncoderImpl() {
@@ -637,7 +632,6 @@ void VP9EncoderImpl::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
   }
 
   if (is_first_frame) {
-    picture_id_ = (picture_id_ + 1) & 0x7FFF;
     // TODO(asapersson): this info has to be obtained from the encoder.
     vp9_info->inter_layer_predicted = false;
     ++frames_since_kf_;
@@ -652,15 +646,6 @@ void VP9EncoderImpl::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
     frames_since_kf_ = 0;
   }
 
-  vp9_info->picture_id = picture_id_;
-
-  if (!vp9_info->flexible_mode) {
-    if (layer_id.temporal_layer_id == 0 && layer_id.spatial_layer_id == 0) {
-      tl0_pic_idx_++;
-    }
-    vp9_info->tl0_pic_idx = tl0_pic_idx_;
-  }
-
   // Always populate this, so that the packetizer can properly set the marker
   // bit.
   vp9_info->num_spatial_layers = num_spatial_layers_;
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.h b/modules/video_coding/codecs/vp9/vp9_impl.h
index d2f7822713..8ed443190e 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.h
+++ b/modules/video_coding/codecs/vp9/vp9_impl.h
@@ -127,10 +127,6 @@ class VP9EncoderImpl : public VP9Encoder {
   uint8_t num_ref_pics_[kMaxVp9NumberOfSpatialLayers];
   uint8_t p_diff_[kMaxVp9NumberOfSpatialLayers][kMaxVp9RefPics];
   std::unique_ptr<ScreenshareLayersVP9> spatial_layer_;
-
-  // RTP state.
-  uint16_t picture_id_;
-  uint8_t tl0_pic_idx_;  // Only used in non-flexible mode.
 };
 
 class VP9DecoderImpl : public VP9Decoder {
diff --git a/modules/video_coding/include/video_codec_interface.h b/modules/video_coding/include/video_codec_interface.h
index 7524631f99..b534f642e6 100644
--- a/modules/video_coding/include/video_codec_interface.h
+++ b/modules/video_coding/include/video_codec_interface.h
@@ -28,19 +28,19 @@ class RTPFragmentationHeader;  // forward declaration
 // Note: if any pointers are added to this struct, it must be fitted
 // with a copy-constructor. See below.
 struct CodecSpecificInfoVP8 {
-  // TODO(nisse): Delete, set by PayloadRouter.
+  // TODO(nisse): Used on receive side only. Move elsewhere?
   int16_t pictureId;  // Negative value to skip pictureId.
   bool nonReference;
   uint8_t simulcastIdx;
   uint8_t temporalIdx;
   bool layerSync;
-  // TODO(nisse): Delete, set by PayloadRouter.
+  // TODO(nisse): Used on receive side only. Move elsewhere?
   int tl0PicIdx;  // Negative value to skip tl0PicIdx.
   int8_t keyIdx;  // Negative value to skip keyIdx.
 };
 
 struct CodecSpecificInfoVP9 {
-  // TODO(nisse): Delete, set by PayloadRouter.
+  // TODO(nisse): Used on receive side only. Move elsewhere?
   int16_t picture_id;  // Negative value to skip pictureId.
 
   bool first_frame_in_picture;  // First frame, increment picture_id.
@@ -49,7 +49,7 @@ struct CodecSpecificInfoVP9 {
   bool flexible_mode;
   bool ss_data_available;
 
-  // TODO(nisse): Delete, set by PayloadRouter.
+  // TODO(nisse): Used on receive side only. Move elsewhere?
   int tl0_pic_idx;  // Negative value to skip tl0PicIdx.
   uint8_t temporal_idx;
   uint8_t spatial_idx;
diff --git a/modules/video_coding/video_codec_initializer_unittest.cc b/modules/video_coding/video_codec_initializer_unittest.cc
index 6dd82c1f05..3a69d999a5 100644
--- a/modules/video_coding/video_codec_initializer_unittest.cc
+++ b/modules/video_coding/video_codec_initializer_unittest.cc
@@ -82,7 +82,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
     if (codec_out_.codecType == VideoCodecType::kVideoCodecVP8) {
       for (int i = 0; i < codec_out_.numberOfSimulcastStreams; ++i) {
         temporal_layers_.emplace_back(
-            TemporalLayers::CreateTemporalLayers(codec_out_, i, 0));
+            TemporalLayers::CreateTemporalLayers(codec_out_, i));
       }
     }
     return true;
diff --git a/video/payload_router_unittest.cc b/video/payload_router_unittest.cc
index 9e09dabd7e..42cafc11ef 100644
--- a/video/payload_router_unittest.cc
+++ b/video/payload_router_unittest.cc
@@ -325,7 +325,6 @@ TEST(PayloadRouterTest, InfoMappedToRtpVideoHeader_Vp8) {
   memset(&codec_info, 0, sizeof(CodecSpecificInfo));
   codec_info.codecType = kVideoCodecVP8;
   codec_info.codecSpecific.VP8.simulcastIdx = 1;
-  codec_info.codecSpecific.VP8.pictureId = -1;
   codec_info.codecSpecific.VP8.temporalIdx = kTemporalIdx;
   codec_info.codecSpecific.VP8.keyIdx = kNoKeyIdx;
   codec_info.codecSpecific.VP8.layerSync = true;
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 2d99350215..1bba52e2e8 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -563,7 +563,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
         int num_streams = std::max<int>(1, config->numberOfSimulcastStreams);
         for (int i = 0; i < num_streams; ++i) {
           allocated_temporal_layers_.emplace_back(
-              TemporalLayers::CreateTemporalLayers(*config, i, 42));
+              TemporalLayers::CreateTemporalLayers(*config, i));
         }
       }
       if (force_init_encode_failed_)