diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc
index 0f94e22..104b9d4 100644
--- a/video/end_to_end_tests/multi_stream_tester.cc
+++ b/video/end_to_end_tests/multi_stream_tester.cc
@@ -31,20 +31,23 @@
 
 namespace webrtc {
 
-MultiStreamTester::MultiStreamTester() {
+MultiStreamTester::MultiStreamTester(TaskQueueBase* task_queue)
+    : task_queue_(task_queue) {
   // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
   codec_settings[0] = {1, 640, 480};
   codec_settings[1] = {2, 320, 240};
   codec_settings[2] = {3, 240, 160};
+  class multi_stream_test {
+   public:
+    multi_stream_test();
+  };
 }
 
-MultiStreamTester::~MultiStreamTester() = default;
+MultiStreamTester::~MultiStreamTester() {}
 
 void MultiStreamTester::RunTest() {
   webrtc::RtcEventLogNull event_log;
   auto task_queue_factory = CreateDefaultTaskQueueFactory();
-  auto task_queue = task_queue_factory->CreateTaskQueue(
-      "TaskQueue", TaskQueueFactory::Priority::NORMAL);
   Call::Config config(&event_log);
   config.task_queue_factory = task_queue_factory.get();
   std::unique_ptr<Call> sender_call;
@@ -61,12 +64,12 @@
       CreateBuiltinVideoBitrateAllocatorFactory();
   InternalDecoderFactory decoder_factory;
 
-  SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
+  SendTask(RTC_FROM_HERE, task_queue_, [&]() {
     sender_call = absl::WrapUnique(Call::Create(config));
     receiver_call = absl::WrapUnique(Call::Create(config));
-    sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
+    sender_transport = CreateSendTransport(task_queue_, sender_call.get());
     receiver_transport =
-        CreateReceiveTransport(task_queue.get(), receiver_call.get());
+        CreateReceiveTransport(task_queue_, receiver_call.get());
 
     sender_transport->SetReceiver(receiver_call->Receiver());
     receiver_transport->SetReceiver(sender_call->Receiver());
@@ -122,7 +125,7 @@
 
   Wait();
 
-  SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
+  SendTask(RTC_FROM_HERE, task_queue_, [&]() {
     for (size_t i = 0; i < kNumStreams; ++i) {
       frame_generators[i]->Stop();
       sender_call->DestroyVideoSendStream(send_streams[i]);
diff --git a/video/end_to_end_tests/multi_stream_tester.h b/video/end_to_end_tests/multi_stream_tester.h
index 1753741..845442e 100644
--- a/video/end_to_end_tests/multi_stream_tester.h
+++ b/video/end_to_end_tests/multi_stream_tester.h
@@ -35,7 +35,7 @@
     int height;
   } codec_settings[kNumStreams];
 
-  MultiStreamTester();
+  explicit MultiStreamTester(TaskQueueBase* task_queue);
 
   virtual ~MultiStreamTester();
 
@@ -58,6 +58,8 @@
   virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(
       TaskQueueBase* task_queue,
       Call* receiver_call);
+
+  TaskQueueBase* const task_queue_;
 };
 }  // namespace webrtc
 #endif  // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_
diff --git a/video/end_to_end_tests/multi_stream_tests.cc b/video/end_to_end_tests/multi_stream_tests.cc
index e20d70f..0eed98d 100644
--- a/video/end_to_end_tests/multi_stream_tests.cc
+++ b/video/end_to_end_tests/multi_stream_tests.cc
@@ -21,14 +21,20 @@
 #include "call/video_receive_stream.h"
 #include "call/video_send_stream.h"
 #include "rtc_base/event.h"
+#include "test/call_test.h"
 #include "test/frame_generator_capturer.h"
 #include "test/gtest.h"
 #include "video/end_to_end_tests/multi_stream_tester.h"
 
 namespace webrtc {
+class MultiStreamEndToEndTest : public test::CallTest {
+ public:
+  MultiStreamEndToEndTest() = default;
+};
+
 // Each renderer verifies that it receives the expected resolution, and as soon
 // as every renderer has received a frame, the test finishes.
-TEST(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
+TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
   class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
    public:
     VideoOutputObserver(const MultiStreamTester::CodecSettings& settings,
@@ -45,7 +51,7 @@
 
     uint32_t Ssrc() { return ssrc_; }
 
-    bool Wait() { return done_.Wait(30 * 1000); }
+    bool Wait() { return done_.Wait(kDefaultTimeoutMs); }
 
    private:
     const MultiStreamTester::CodecSettings& settings_;
@@ -56,8 +62,9 @@
 
   class Tester : public MultiStreamTester {
    public:
-    Tester() = default;
-    ~Tester() override = default;
+    explicit Tester(TaskQueueBase* task_queue)
+        : MultiStreamTester(task_queue) {}
+    virtual ~Tester() {}
 
    protected:
     void Wait() override {
@@ -72,9 +79,9 @@
         VideoSendStream::Config* send_config,
         VideoEncoderConfig* encoder_config,
         test::FrameGeneratorCapturer** frame_generator) override {
-      observers_[stream_index] = std::make_unique<VideoOutputObserver>(
+      observers_[stream_index].reset(new VideoOutputObserver(
           codec_settings[stream_index], send_config->rtp.ssrcs.front(),
-          frame_generator);
+          frame_generator));
     }
 
     void UpdateReceiveConfig(
@@ -85,7 +92,7 @@
 
    private:
     std::unique_ptr<VideoOutputObserver> observers_[kNumStreams];
-  } tester;
+  } tester(task_queue());
 
   tester.RunTest();
 }
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 55c8bc4..0f7b737 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -29,13 +29,15 @@
 };
 }  // namespace
 
-TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
-  static constexpr int kSendRtxPayloadType = 98;
-  static constexpr int kDefaultTimeoutMs = 30 * 1000;
-  static constexpr int kNackRtpHistoryMs = 1000;
-  static constexpr uint32_t kSendRtxSsrcs[MultiStreamTester::kNumStreams] = {
-      0xBADCAFD, 0xBADCAFE, 0xBADCAFF};
+class TransportFeedbackEndToEndTest : public test::CallTest {
+ public:
+  TransportFeedbackEndToEndTest() {
+    RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                                      kTransportSequenceNumberExtensionId));
+  }
+};
 
+TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
     RtpExtensionHeaderObserver(
@@ -54,6 +56,7 @@
           parser_(RtpHeaderParser::CreateForTest()),
           first_media_ssrc_(first_media_ssrc),
           rtx_to_media_ssrcs_(ssrc_map),
+          padding_observed_(false),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
           started_(false) {
@@ -146,7 +149,6 @@
       return done_.Wait(kDefaultTimeoutMs);
     }
 
-   private:
     rtc::CriticalSection lock_;
     rtc::Event done_;
     std::unique_ptr<RtpHeaderParser> parser_;
@@ -156,6 +158,7 @@
     std::map<uint32_t, std::set<uint16_t>> dropped_seq_;
     const uint32_t& first_media_ssrc_;
     const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_;
+    bool padding_observed_;
     bool rtx_padding_observed_;
     bool retransmit_observed_;
     bool started_;
@@ -163,9 +166,11 @@
 
   class TransportSequenceNumberTester : public MultiStreamTester {
    public:
-    TransportSequenceNumberTester()
-        : first_media_ssrc_(0), observer_(nullptr) {}
-    ~TransportSequenceNumberTester() override = default;
+    explicit TransportSequenceNumberTester(TaskQueueBase* task_queue)
+        : MultiStreamTester(task_queue),
+          first_media_ssrc_(0),
+          observer_(nullptr) {}
+    virtual ~TransportSequenceNumberTester() {}
 
    protected:
     void Wait() override {
@@ -233,19 +238,11 @@
     uint32_t first_media_ssrc_;
     std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
     RtpExtensionHeaderObserver* observer_;
-  } tester;
+  } tester(task_queue());
 
   tester.RunTest();
 }
 
-class TransportFeedbackEndToEndTest : public test::CallTest {
- public:
-  TransportFeedbackEndToEndTest() {
-    RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
-                                      kTransportSequenceNumberExtensionId));
-  }
-};
-
 class TransportFeedbackTester : public test::EndToEndTest {
  public:
   TransportFeedbackTester(bool feedback_enabled,