diff --git a/webrtc/video/BUILD.gn b/webrtc/video/BUILD.gn
index b5e8579..2204c74 100644
--- a/webrtc/video/BUILD.gn
+++ b/webrtc/video/BUILD.gn
@@ -241,6 +241,7 @@
       "end_to_end_tests.cc",
       "overuse_frame_detector_unittest.cc",
       "payload_router_unittest.cc",
+      "picture_id_tests.cc",
       "quality_threshold_unittest.cc",
       "receive_statistics_proxy_unittest.cc",
       "report_block_stats_unittest.cc",
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 68931ac..0d7662d 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -139,7 +139,6 @@
   void RespectsRtcpMode(RtcpMode rtcp_mode);
   void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
   void TestRtpStatePreservation(bool use_rtx, bool provoke_rtcpsr_before_rtp);
-  void TestPictureIdStatePreservation(VideoEncoder* encoder);
   void VerifyHistogramStats(bool use_rtx, bool use_red, bool screenshare);
   void VerifyNewVideoSendStreamsRespectNetworkState(
       MediaType network_to_bring_up,
@@ -3940,236 +3939,6 @@
   TestRtpStatePreservation(true, true);
 }
 
-void EndToEndTest::TestPictureIdStatePreservation(VideoEncoder* encoder) {
-  const size_t kFrameMaxWidth = 1280;
-  const size_t kFrameMaxHeight = 720;
-  const size_t kFrameRate = 30;
-
-  // Use a special stream factory in this test to ensure that all simulcast
-  // streams are being sent.
-  class VideoStreamFactory
-      : public VideoEncoderConfig::VideoStreamFactoryInterface {
-   public:
-    VideoStreamFactory() = default;
-
-   private:
-    std::vector<VideoStream> CreateEncoderStreams(
-        int width,
-        int height,
-        const VideoEncoderConfig& encoder_config) override {
-      std::vector<VideoStream> streams =
-          test::CreateVideoStreams(width, height, encoder_config);
-
-      const size_t kBitrate = 100000;
-
-      if (encoder_config.number_of_streams > 1) {
-        RTC_DCHECK_EQ(3, encoder_config.number_of_streams);
-
-        for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
-          streams[i].min_bitrate_bps = kBitrate;
-          streams[i].target_bitrate_bps = kBitrate;
-          streams[i].max_bitrate_bps = kBitrate;
-        }
-
-        // test::CreateVideoStreams does not return frame sizes for the lower
-        // streams that are accepted by VP8Impl::InitEncode.
-        // TODO(brandtr): Fix the problem in test::CreateVideoStreams, rather
-        // than overriding the values here.
-        streams[1].width = streams[2].width / 2;
-        streams[1].height = streams[2].height / 2;
-        streams[0].width = streams[1].width / 2;
-        streams[0].height = streams[1].height / 2;
-      } else {
-        // Use the same total bitrates when sending a single stream to avoid
-        // lowering the bitrate estimate and requiring a subsequent rampup.
-        streams[0].min_bitrate_bps = 3 * kBitrate;
-        streams[0].target_bitrate_bps = 3 * kBitrate;
-        streams[0].max_bitrate_bps = 3 * kBitrate;
-      }
-
-      return streams;
-    }
-  };
-
-  class PictureIdObserver : public test::RtpRtcpObserver {
-   public:
-    PictureIdObserver()
-        : test::RtpRtcpObserver(kDefaultTimeoutMs), num_ssrcs_to_observe_(1) {}
-
-    void ResetExpectations(size_t num_expected_ssrcs) {
-      rtc::CritScope lock(&crit_);
-      // Do not clear the timestamp and picture_id, to ensure that we check
-      // consistency between reinits and recreations.
-      num_packets_sent_.clear();
-      num_ssrcs_to_observe_ = num_expected_ssrcs;
-      ssrc_observed_.clear();
-    }
-
-   private:
-    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
-
-      // RTP header.
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
-      const uint32_t timestamp = header.timestamp;
-      const uint32_t ssrc = header.ssrc;
-
-      const bool known_ssrc =
-          (ssrc == kVideoSendSsrcs[0] || ssrc == kVideoSendSsrcs[1] ||
-           ssrc == kVideoSendSsrcs[2]);
-      EXPECT_TRUE(known_ssrc) << "Unknown SSRC sent.";
-
-      const bool is_padding =
-          (length == header.headerLength + header.paddingLength);
-      if (is_padding) {
-        return SEND_PACKET;
-      }
-
-      // VP8 header.
-      std::unique_ptr<RtpDepacketizer> depacketizer(
-          RtpDepacketizer::Create(kRtpVideoVp8));
-      RtpDepacketizer::ParsedPayload parsed_payload;
-      EXPECT_TRUE(depacketizer->Parse(
-          &parsed_payload, &packet[header.headerLength],
-          length - header.headerLength - header.paddingLength));
-      const uint16_t picture_id =
-          parsed_payload.type.Video.codecHeader.VP8.pictureId;
-
-      // If this is the first packet, we have nothing to compare to.
-      if (last_observed_timestamp_.find(ssrc) ==
-          last_observed_timestamp_.end()) {
-        last_observed_timestamp_[ssrc] = timestamp;
-        last_observed_picture_id_[ssrc] = picture_id;
-        ++num_packets_sent_[ssrc];
-
-        return SEND_PACKET;
-      }
-
-      // Verify continuity and monotonicity of picture_id sequence.
-      if (last_observed_timestamp_[ssrc] == timestamp) {
-        // Packet belongs to same frame as before.
-        EXPECT_EQ(last_observed_picture_id_[ssrc], picture_id);
-      } else {
-        // Packet is a new frame.
-        EXPECT_EQ((last_observed_picture_id_[ssrc] + 1) % (1 << 15),
-                  picture_id);
-      }
-      last_observed_timestamp_[ssrc] = timestamp;
-      last_observed_picture_id_[ssrc] = picture_id;
-
-      // Pass the test when enough media packets have been received
-      // on all streams.
-      if (++num_packets_sent_[ssrc] >= 10 && !ssrc_observed_[ssrc]) {
-        ssrc_observed_[ssrc] = true;
-        if (--num_ssrcs_to_observe_ == 0) {
-          observation_complete_.Set();
-        }
-      }
-
-      return SEND_PACKET;
-    }
-
-    rtc::CriticalSection crit_;
-    std::map<uint32_t, uint32_t> last_observed_timestamp_ GUARDED_BY(crit_);
-    std::map<uint32_t, uint16_t> last_observed_picture_id_ GUARDED_BY(crit_);
-    std::map<uint32_t, size_t> num_packets_sent_ GUARDED_BY(crit_);
-    size_t num_ssrcs_to_observe_ GUARDED_BY(crit_);
-    std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
-  } observer;
-
-  Call::Config config(event_log_.get());
-  CreateCalls(config, config);
-
-  test::PacketTransport send_transport(
-      sender_call_.get(), &observer, test::PacketTransport::kSender,
-      payload_type_map_, FakeNetworkPipe::Config());
-  test::PacketTransport receive_transport(
-      nullptr, &observer, test::PacketTransport::kReceiver, payload_type_map_,
-      FakeNetworkPipe::Config());
-  send_transport.SetReceiver(receiver_call_->Receiver());
-  receive_transport.SetReceiver(sender_call_->Receiver());
-
-  CreateSendConfig(kNumSsrcs, 0, 0, &send_transport);
-  video_send_config_.encoder_settings.encoder = encoder;
-  video_send_config_.encoder_settings.payload_name = "VP8";
-  video_encoder_config_.video_stream_factory =
-      new rtc::RefCountedObject<VideoStreamFactory>();
-  video_encoder_config_.number_of_streams = 1;
-  CreateMatchingReceiveConfigs(&receive_transport);
-
-  CreateVideoStreams();
-  CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
-
-  auto reinit_encoder_and_test = [this, &observer](int num_expected_ssrcs) {
-    video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy());
-    observer.ResetExpectations(num_expected_ssrcs);
-    EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
-  };
-
-  // TODO(brandtr): Add tests where we recreate the whole VideoSendStream. This
-  // requires synchronizing the frame generator output with the packetization
-  // output, to not have any timing-dependent gaps in the picture_id sequence.
-
-  // Initial test with a single stream.
-  Start();
-  EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
-
-  // Reinit the encoder and make sure the picture_id sequence is continuous.
-  reinit_encoder_and_test(1);
-
-  // Go up to three streams.
-  video_encoder_config_.number_of_streams = 3;
-  reinit_encoder_and_test(3);
-  reinit_encoder_and_test(3);
-
-  // Go back to one stream.
-  video_encoder_config_.number_of_streams = 1;
-  reinit_encoder_and_test(1);
-  reinit_encoder_and_test(1);
-
-  send_transport.StopSending();
-  receive_transport.StopSending();
-
-  Stop();
-  DestroyStreams();
-}
-
-TEST_F(EndToEndTest, PictureIdStateRetainedAfterReinitingVp8) {
-  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
-  TestPictureIdStatePreservation(encoder.get());
-}
-
-TEST_F(EndToEndTest,
-       PictureIdStateRetainedAfterReinitingSimulcastEncoderAdapter) {
-  class VideoEncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
-   public:
-    explicit VideoEncoderFactoryAdapter(
-        cricket::WebRtcVideoEncoderFactory* factory)
-        : factory_(factory) {}
-    virtual ~VideoEncoderFactoryAdapter() {}
-
-    // Implements webrtc::VideoEncoderFactory.
-    webrtc::VideoEncoder* Create() override {
-      return factory_->CreateVideoEncoder(
-          cricket::VideoCodec(cricket::kVp8CodecName));
-    }
-
-    void Destroy(webrtc::VideoEncoder* encoder) override {
-      return factory_->DestroyVideoEncoder(encoder);
-    }
-
-   private:
-    cricket::WebRtcVideoEncoderFactory* const factory_;
-  };
-
-  cricket::InternalEncoderFactory internal_encoder_factory;
-  SimulcastEncoderAdapter simulcast_encoder_adapter(
-      new VideoEncoderFactoryAdapter(&internal_encoder_factory));
-
-  TestPictureIdStatePreservation(&simulcast_encoder_adapter);
-}
-
 // This test is flaky on linux_memcheck. Disable on all linux bots until
 // flakyness has been fixed.
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=7737
diff --git a/webrtc/video/picture_id_tests.cc b/webrtc/video/picture_id_tests.cc
new file mode 100644
index 0000000..fe39a94
--- /dev/null
+++ b/webrtc/video/picture_id_tests.cc
@@ -0,0 +1,349 @@
+/*
+ *  Copyright (c) 2013 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 "webrtc/media/engine/internalencoderfactory.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_format.h"
+#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
+#include "webrtc/modules/video_coding/sequence_number_util.h"
+#include "webrtc/test/call_test.h"
+
+namespace webrtc {
+
+const int kFrameMaxWidth = 1280;
+const int kFrameMaxHeight = 720;
+const int kFrameRate = 30;
+const int kMaxSecondsLost = 5;
+const int kMaxFramesLost = kFrameRate * kMaxSecondsLost;
+const int kMinPacketsToObserve = 10;
+const int kEncoderBitrateBps = 100000;
+const uint32_t kPictureIdWraparound = (1 << 15);
+
+class PictureIdObserver : public test::RtpRtcpObserver {
+ public:
+  PictureIdObserver()
+      : test::RtpRtcpObserver(test::CallTest::kDefaultTimeoutMs),
+        max_expected_picture_id_gap_(0),
+        num_ssrcs_to_observe_(1) {}
+
+  void SetExpectedSsrcs(size_t num_expected_ssrcs) {
+    rtc::CritScope lock(&crit_);
+    num_ssrcs_to_observe_ = num_expected_ssrcs;
+  }
+
+  void ResetObservedSsrcs() {
+    rtc::CritScope lock(&crit_);
+    // Do not clear the timestamp and picture_id, to ensure that we check
+    // consistency between reinits and recreations.
+    num_packets_sent_.clear();
+    observed_ssrcs_.clear();
+  }
+
+  void SetMaxExpectedPictureIdGap(int max_expected_picture_id_gap) {
+    rtc::CritScope lock(&crit_);
+    max_expected_picture_id_gap_ = max_expected_picture_id_gap;
+  }
+
+ private:
+  Action OnSendRtp(const uint8_t* packet, size_t length) override {
+    rtc::CritScope lock(&crit_);
+
+    // RTP header.
+    RTPHeader header;
+    EXPECT_TRUE(parser_->Parse(packet, length, &header));
+    const uint32_t timestamp = header.timestamp;
+    const uint32_t ssrc = header.ssrc;
+
+    const bool known_ssrc = (ssrc == test::CallTest::kVideoSendSsrcs[0] ||
+                             ssrc == test::CallTest::kVideoSendSsrcs[1] ||
+                             ssrc == test::CallTest::kVideoSendSsrcs[2]);
+    EXPECT_TRUE(known_ssrc) << "Unknown SSRC sent.";
+
+    const bool is_padding =
+        (length == header.headerLength + header.paddingLength);
+    if (is_padding) {
+      return SEND_PACKET;
+    }
+
+    // VP8 header.
+    std::unique_ptr<RtpDepacketizer> depacketizer(
+        RtpDepacketizer::Create(kRtpVideoVp8));
+    RtpDepacketizer::ParsedPayload parsed_payload;
+    EXPECT_TRUE(depacketizer->Parse(
+        &parsed_payload, &packet[header.headerLength],
+        length - header.headerLength - header.paddingLength));
+    const uint16_t picture_id =
+        parsed_payload.type.Video.codecHeader.VP8.pictureId;
+
+    // If this is the first packet, we have nothing to compare to.
+    if (last_observed_timestamp_.find(ssrc) == last_observed_timestamp_.end()) {
+      last_observed_timestamp_[ssrc] = timestamp;
+      last_observed_picture_id_[ssrc] = picture_id;
+      ++num_packets_sent_[ssrc];
+
+      return SEND_PACKET;
+    }
+
+    // Verify continuity and monotonicity of picture_id sequence.
+    if (last_observed_timestamp_[ssrc] == timestamp) {
+      // Packet belongs to same frame as before.
+      EXPECT_EQ(last_observed_picture_id_[ssrc], picture_id);
+    } else {
+      // Packet is a new frame.
+
+      // Picture id should be increasing.
+      const bool picture_id_is_increasing =
+          AheadOf<uint16_t, kPictureIdWraparound>(
+              picture_id, last_observed_picture_id_[ssrc]);
+      EXPECT_TRUE(picture_id_is_increasing);
+
+      // Picture id should not increase more than expected.
+      const int picture_id_diff = ForwardDiff<uint16_t, kPictureIdWraparound>(
+          last_observed_picture_id_[ssrc], picture_id);
+      EXPECT_LE(picture_id_diff - 1, max_expected_picture_id_gap_);
+    }
+    last_observed_timestamp_[ssrc] = timestamp;
+    last_observed_picture_id_[ssrc] = picture_id;
+
+    // Pass the test when enough media packets have been received
+    // on all streams.
+    if (++num_packets_sent_[ssrc] >= kMinPacketsToObserve &&
+        observed_ssrcs_.find(ssrc) == observed_ssrcs_.end()) {
+      observed_ssrcs_.insert(ssrc);
+      if (observed_ssrcs_.size() == num_ssrcs_to_observe_) {
+        observation_complete_.Set();
+      }
+    }
+
+    return SEND_PACKET;
+  }
+
+  rtc::CriticalSection crit_;
+  std::map<uint32_t, uint32_t> last_observed_timestamp_ GUARDED_BY(crit_);
+  std::map<uint32_t, uint16_t> last_observed_picture_id_ GUARDED_BY(crit_);
+  std::map<uint32_t, size_t> num_packets_sent_ GUARDED_BY(crit_);
+  int max_expected_picture_id_gap_ GUARDED_BY(crit_);
+  size_t num_ssrcs_to_observe_ GUARDED_BY(crit_);
+  std::set<uint32_t> observed_ssrcs_ GUARDED_BY(crit_);
+};
+
+class PictureIdTest : public test::CallTest {
+ public:
+  PictureIdTest() {}
+
+  virtual ~PictureIdTest() {
+    EXPECT_EQ(nullptr, video_send_stream_);
+    EXPECT_TRUE(video_receive_streams_.empty());
+  }
+
+  void SetupEncoder(VideoEncoder* encoder);
+  void TestPictureIdContinuousAfterReconfigure(
+      const std::vector<int>& ssrc_counts);
+  void TestPictureIdIncreaseAfterRecreateStreams(
+      const std::vector<int>& ssrc_counts);
+
+ private:
+  PictureIdObserver observer;
+};
+
+// Use a special stream factory to ensure that all simulcast streams are being
+// sent.
+class VideoStreamFactory
+    : public VideoEncoderConfig::VideoStreamFactoryInterface {
+ public:
+  VideoStreamFactory() = default;
+
+ private:
+  std::vector<VideoStream> CreateEncoderStreams(
+      int width,
+      int height,
+      const VideoEncoderConfig& encoder_config) override {
+    std::vector<VideoStream> streams =
+        test::CreateVideoStreams(width, height, encoder_config);
+
+    if (encoder_config.number_of_streams > 1) {
+      RTC_DCHECK_EQ(3, encoder_config.number_of_streams);
+
+      for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
+        streams[i].min_bitrate_bps = kEncoderBitrateBps;
+        streams[i].target_bitrate_bps = kEncoderBitrateBps;
+        streams[i].max_bitrate_bps = kEncoderBitrateBps;
+      }
+
+      // test::CreateVideoStreams does not return frame sizes for the lower
+      // streams that are accepted by VP8Impl::InitEncode.
+      // TODO(brandtr): Fix the problem in test::CreateVideoStreams, rather
+      // than overriding the values here.
+      streams[1].width = streams[2].width / 2;
+      streams[1].height = streams[2].height / 2;
+      streams[0].width = streams[1].width / 2;
+      streams[0].height = streams[1].height / 2;
+    } else {
+      // Use the same total bitrates when sending a single stream to avoid
+      // lowering the bitrate estimate and requiring a subsequent rampup.
+      streams[0].min_bitrate_bps = 3 * kEncoderBitrateBps;
+      streams[0].target_bitrate_bps = 3 * kEncoderBitrateBps;
+      streams[0].max_bitrate_bps = 3 * kEncoderBitrateBps;
+    }
+
+    return streams;
+  }
+};
+
+void PictureIdTest::SetupEncoder(VideoEncoder* encoder) {
+  Call::Config config(event_log_.get());
+  CreateCalls(config, config);
+
+  send_transport_.reset(new test::PacketTransport(
+      sender_call_.get(), &observer, test::PacketTransport::kSender,
+      payload_type_map_, FakeNetworkPipe::Config()));
+
+  CreateSendConfig(kNumSsrcs, 0, 0, send_transport_.get());
+  video_send_config_.encoder_settings.encoder = encoder;
+  video_send_config_.encoder_settings.payload_name = "VP8";
+  video_encoder_config_.video_stream_factory =
+      new rtc::RefCountedObject<VideoStreamFactory>();
+  video_encoder_config_.number_of_streams = 1;
+}
+
+void PictureIdTest::TestPictureIdContinuousAfterReconfigure(
+    const std::vector<int>& ssrc_counts) {
+  CreateVideoStreams();
+  CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
+
+  // Initial test with a single stream.
+  Start();
+  EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
+
+  // Reconfigure VideoEncoder and test picture id increase.
+  // Expect continously increasing picture id, equivalent to no gaps.
+  observer.SetMaxExpectedPictureIdGap(0);
+  for (int ssrc_count : ssrc_counts) {
+    video_encoder_config_.number_of_streams = ssrc_count;
+    observer.SetExpectedSsrcs(ssrc_count);
+    observer.ResetObservedSsrcs();
+    // Make sure the picture_id sequence is continuous on reinit and recreate.
+    video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy());
+    EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
+  }
+
+  Stop();
+  DestroyStreams();
+}
+
+void PictureIdTest::TestPictureIdIncreaseAfterRecreateStreams(
+    const std::vector<int>& ssrc_counts) {
+  CreateVideoStreams();
+  CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
+
+  // Initial test with a single stream.
+  Start();
+  EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
+
+  // Recreate VideoSendStream and test picture id increase.
+  // When the VideoSendStream is destroyed, any frames still in queue is lost
+  // with it, therefore it is expected that some frames might be lost.
+  observer.SetMaxExpectedPictureIdGap(kMaxFramesLost);
+  for (int ssrc_count : ssrc_counts) {
+    video_encoder_config_.number_of_streams = ssrc_count;
+
+    frame_generator_capturer_->Stop();
+    sender_call_->DestroyVideoSendStream(video_send_stream_);
+
+    observer.SetExpectedSsrcs(ssrc_count);
+    observer.ResetObservedSsrcs();
+
+    video_send_stream_ = sender_call_->CreateVideoSendStream(
+        video_send_config_.Copy(), video_encoder_config_.Copy());
+    video_send_stream_->Start();
+    CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
+    frame_generator_capturer_->Start();
+    EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
+  }
+
+  Stop();
+  DestroyStreams();
+}
+
+TEST_F(PictureIdTest, PictureIdContinuousAfterReconfigureVp8) {
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  SetupEncoder(encoder.get());
+  TestPictureIdContinuousAfterReconfigure({1, 3, 3, 1, 1});
+}
+
+TEST_F(PictureIdTest, PictureIdIncreasingAfterRecreateStreamVp8) {
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  SetupEncoder(encoder.get());
+  TestPictureIdIncreaseAfterRecreateStreams({1, 3, 3, 1, 1});
+}
+
+TEST_F(PictureIdTest, PictureIdIncreasingAfterStreamCountChangeVp8) {
+  std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
+  // Make sure that that the picture id is not reset if the stream count goes
+  // down and then up.
+  std::vector<int> ssrc_counts = {3, 1, 3};
+  SetupEncoder(encoder.get());
+  TestPictureIdContinuousAfterReconfigure(ssrc_counts);
+}
+
+class VideoEncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
+ public:
+  explicit VideoEncoderFactoryAdapter(
+      cricket::WebRtcVideoEncoderFactory* factory)
+      : factory_(factory) {}
+  virtual ~VideoEncoderFactoryAdapter() {}
+
+  // Implements webrtc::VideoEncoderFactory.
+  webrtc::VideoEncoder* Create() override {
+    return factory_->CreateVideoEncoder(
+        cricket::VideoCodec(cricket::kVp8CodecName));
+  }
+
+  void Destroy(webrtc::VideoEncoder* encoder) override {
+    return factory_->DestroyVideoEncoder(encoder);
+  }
+
+ private:
+  cricket::WebRtcVideoEncoderFactory* const factory_;
+};
+
+TEST_F(PictureIdTest,
+       PictureIdContinuousAfterReconfigureSimulcastEncoderAdapter) {
+  cricket::InternalEncoderFactory internal_encoder_factory;
+  SimulcastEncoderAdapter simulcast_encoder_adapter(
+      new VideoEncoderFactoryAdapter(&internal_encoder_factory));
+  SetupEncoder(&simulcast_encoder_adapter);
+  TestPictureIdContinuousAfterReconfigure({1, 3, 3, 1, 1});
+}
+
+TEST_F(PictureIdTest,
+       PictureIdIncreasingAfterRecreateStreamSimulcastEncoderAdapter) {
+  cricket::InternalEncoderFactory internal_encoder_factory;
+  SimulcastEncoderAdapter simulcast_encoder_adapter(
+      new VideoEncoderFactoryAdapter(&internal_encoder_factory));
+  SetupEncoder(&simulcast_encoder_adapter);
+  TestPictureIdIncreaseAfterRecreateStreams({1, 3, 3, 1, 1});
+}
+
+// When using the simulcast encoder adapter, the picture id is randomly set
+// when the ssrc count is reduced and then increased. This means that we are
+// not spec compliant in that particular case.
+TEST_F(
+    PictureIdTest,
+    DISABLED_PictureIdIncreasingAfterStreamCountChangeSimulcastEncoderAdapter) {
+  cricket::InternalEncoderFactory internal_encoder_factory;
+  SimulcastEncoderAdapter simulcast_encoder_adapter(
+      new VideoEncoderFactoryAdapter(&internal_encoder_factory));
+  // Make sure that that the picture id is not reset if the stream count goes
+  // down and then up.
+  std::vector<int> ssrc_counts = {3, 1, 3};
+  SetupEncoder(&simulcast_encoder_adapter);
+  TestPictureIdContinuousAfterReconfigure(ssrc_counts);
+}
+
+}  // namespace webrtc