diff --git a/modules/video_coding/video_receiver_unittest.cc b/modules/video_coding/video_receiver_unittest.cc
index f99dac4920..0d26fc515d 100644
--- a/modules/video_coding/video_receiver_unittest.cc
+++ b/modules/video_coding/video_receiver_unittest.cc
@@ -8,9 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include <memory>
-#include <vector>
-
 #include "api/test/mock_video_decoder.h"
 #include "modules/video_coding/include/mock/mock_vcm_callbacks.h"
 #include "modules/video_coding/include/video_coding.h"
@@ -31,110 +28,107 @@ namespace {
 class TestVideoReceiver : public ::testing::Test {
  protected:
   static const int kUnusedPayloadType = 10;
+  static const uint16_t kMaxWaitTimeMs = 100;
 
-  TestVideoReceiver() : clock_(0) {}
+  TestVideoReceiver()
+      : clock_(0), timing_(&clock_), receiver_(&clock_, &timing_) {}
 
   virtual void SetUp() {
-    timing_.reset(new VCMTiming(&clock_));
-    receiver_.reset(new VideoReceiver(&clock_, timing_.get()));
-    receiver_->RegisterExternalDecoder(&decoder_, kUnusedPayloadType);
+    // Register decoder.
+    receiver_.RegisterExternalDecoder(&decoder_, kUnusedPayloadType);
+    webrtc::test::CodecSettings(kVideoCodecVP8, &settings_);
+    settings_.plType = kUnusedPayloadType;
+    EXPECT_EQ(0, receiver_.RegisterReceiveCodec(&settings_, 1, true));
+
+    // Set protection mode.
     const size_t kMaxNackListSize = 250;
     const int kMaxPacketAgeToNack = 450;
-    receiver_->SetNackSettings(kMaxNackListSize, kMaxPacketAgeToNack, 0);
-
-    webrtc::test::CodecSettings(kVideoCodecVP8, &settings_);
-    settings_.plType = kUnusedPayloadType;  // Use the mocked encoder.
-    EXPECT_EQ(0, receiver_->RegisterReceiveCodec(&settings_, 1, true));
+    receiver_.SetNackSettings(kMaxNackListSize, kMaxPacketAgeToNack, 0);
+    EXPECT_EQ(0, receiver_.SetVideoProtection(kProtectionNack, true));
+    EXPECT_EQ(
+        0, receiver_.RegisterPacketRequestCallback(&packet_request_callback_));
 
     // Since we call Decode, we need to provide a valid receive callback.
     // However, for the purposes of these tests, we ignore the callbacks.
     EXPECT_CALL(receive_callback_, OnIncomingPayloadType(_)).Times(AnyNumber());
     EXPECT_CALL(receive_callback_, OnDecoderImplementationName(_))
         .Times(AnyNumber());
-    receiver_->RegisterReceiveCallback(&receive_callback_);
+    receiver_.RegisterReceiveCallback(&receive_callback_);
+  }
+
+  WebRtcRTPHeader GetDefaultVp8Header() const {
+    WebRtcRTPHeader header = {};
+    header.frameType = kEmptyFrame;
+    header.header.markerBit = false;
+    header.header.payloadType = kUnusedPayloadType;
+    header.header.ssrc = 1;
+    header.header.headerLength = 12;
+    header.video_header().codec = kVideoCodecVP8;
+    return header;
   }
 
   void InsertAndVerifyPaddingFrame(const uint8_t* payload,
                                    WebRtcRTPHeader* header) {
-    ASSERT_TRUE(header != NULL);
     for (int j = 0; j < 5; ++j) {
       // Padding only packets are passed to the VCM with payload size 0.
-      EXPECT_EQ(0, receiver_->IncomingPacket(payload, 0, *header));
+      EXPECT_EQ(0, receiver_.IncomingPacket(payload, 0, *header));
       ++header->header.sequenceNumber;
     }
-    receiver_->Process();
+    receiver_.Process();
     EXPECT_CALL(decoder_, Decode(_, _, _, _)).Times(0);
-    EXPECT_EQ(VCM_FRAME_NOT_READY, receiver_->Decode(100));
+    EXPECT_EQ(VCM_FRAME_NOT_READY, receiver_.Decode(kMaxWaitTimeMs));
   }
 
   void InsertAndVerifyDecodableFrame(const uint8_t* payload,
                                      size_t length,
                                      WebRtcRTPHeader* header) {
-    ASSERT_TRUE(header != NULL);
-    EXPECT_EQ(0, receiver_->IncomingPacket(payload, length, *header));
+    EXPECT_EQ(0, receiver_.IncomingPacket(payload, length, *header));
     ++header->header.sequenceNumber;
     EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
-    receiver_->Process();
+
+    receiver_.Process();
     EXPECT_CALL(decoder_, Decode(_, _, _, _)).Times(1);
-    EXPECT_EQ(0, receiver_->Decode(100));
+    EXPECT_EQ(0, receiver_.Decode(kMaxWaitTimeMs));
   }
 
   SimulatedClock clock_;
   VideoCodec settings_;
   NiceMock<MockVideoDecoder> decoder_;
   NiceMock<MockPacketRequestCallback> packet_request_callback_;
-
-  std::unique_ptr<VCMTiming> timing_;
+  VCMTiming timing_;
   MockVCMReceiveCallback receive_callback_;
-  std::unique_ptr<VideoReceiver> receiver_;
+  VideoReceiver receiver_;
 };
 
 TEST_F(TestVideoReceiver, PaddingOnlyFrames) {
-  EXPECT_EQ(0, receiver_->SetVideoProtection(kProtectionNack, true));
-  EXPECT_EQ(
-      0, receiver_->RegisterPacketRequestCallback(&packet_request_callback_));
   const size_t kPaddingSize = 220;
-  const uint8_t payload[kPaddingSize] = {0};
-  WebRtcRTPHeader header = {};
-  header.frameType = kEmptyFrame;
-  header.header.markerBit = false;
+  const uint8_t kPayload[kPaddingSize] = {0};
+  WebRtcRTPHeader header = GetDefaultVp8Header();
   header.header.paddingLength = kPaddingSize;
-  header.header.payloadType = kUnusedPayloadType;
-  header.header.ssrc = 1;
-  header.header.headerLength = 12;
-  header.video_header().codec = kVideoCodecVP8;
   for (int i = 0; i < 10; ++i) {
     EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
-    InsertAndVerifyPaddingFrame(payload, &header);
+    InsertAndVerifyPaddingFrame(kPayload, &header);
     clock_.AdvanceTimeMilliseconds(33);
     header.header.timestamp += 3000;
   }
 }
 
 TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
-  EXPECT_EQ(0, receiver_->SetVideoProtection(kProtectionNack, true));
-  EXPECT_EQ(
-      0, receiver_->RegisterPacketRequestCallback(&packet_request_callback_));
   const size_t kFrameSize = 1200;
   const size_t kPaddingSize = 220;
-  const uint8_t payload[kFrameSize] = {0};
-  WebRtcRTPHeader header = {};
-  header.frameType = kEmptyFrame;
-  header.header.markerBit = false;
+  const uint8_t kPayload[kFrameSize] = {0};
+  WebRtcRTPHeader header = GetDefaultVp8Header();
   header.header.paddingLength = kPaddingSize;
-  header.header.payloadType = kUnusedPayloadType;
-  header.header.ssrc = 1;
-  header.header.headerLength = 12;
-  header.video_header().codec = kVideoCodecVP8;
   header.video_header().video_type_header.emplace<RTPVideoHeaderVP8>();
+
   // Insert one video frame to get one frame decoded.
   header.frameType = kVideoFrameKey;
   header.video_header().is_first_packet_in_frame = true;
   header.header.markerBit = true;
-  InsertAndVerifyDecodableFrame(payload, kFrameSize, &header);
+  InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header);
+
   clock_.AdvanceTimeMilliseconds(33);
   header.header.timestamp += 3000;
-
   header.frameType = kEmptyFrame;
   header.video_header().is_first_packet_in_frame = false;
   header.header.markerBit = false;
@@ -155,7 +149,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
       } else {
         EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
       }
-      InsertAndVerifyPaddingFrame(payload, &header);
+      InsertAndVerifyPaddingFrame(kPayload, &header);
     }
     clock_.AdvanceTimeMilliseconds(33);
     header.header.timestamp += 3000;
@@ -163,25 +157,17 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
 }
 
 TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
-  EXPECT_EQ(0, receiver_->SetVideoProtection(kProtectionNack, true));
-  EXPECT_EQ(
-      0, receiver_->RegisterPacketRequestCallback(&packet_request_callback_));
   const size_t kFrameSize = 1200;
   const size_t kPaddingSize = 220;
-  const uint8_t payload[kFrameSize] = {0};
-  WebRtcRTPHeader header = {};
-  header.frameType = kEmptyFrame;
+  const uint8_t kPayload[kFrameSize] = {0};
+  WebRtcRTPHeader header = GetDefaultVp8Header();
   header.video_header().is_first_packet_in_frame = false;
-  header.header.markerBit = false;
   header.header.paddingLength = kPaddingSize;
-  header.header.payloadType = kUnusedPayloadType;
-  header.header.ssrc = 1;
-  header.header.headerLength = 12;
-  header.video_header().codec = kVideoCodecVP8;
   auto& vp8_header =
       header.video.video_type_header.emplace<RTPVideoHeaderVP8>();
   vp8_header.pictureId = -1;
   vp8_header.tl0PicIdx = -1;
+
   for (int i = 0; i < 3; ++i) {
     // Insert 2 video frames.
     for (int j = 0; j < 2; ++j) {
@@ -191,7 +177,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
         header.frameType = kVideoFrameDelta;
       header.video_header().is_first_packet_in_frame = true;
       header.header.markerBit = true;
-      InsertAndVerifyDecodableFrame(payload, kFrameSize, &header);
+      InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header);
       clock_.AdvanceTimeMilliseconds(33);
       header.header.timestamp += 3000;
     }
@@ -201,7 +187,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
     header.video_header().is_first_packet_in_frame = false;
     header.header.markerBit = false;
     for (int j = 0; j < 2; ++j) {
-      // InsertAndVerifyPaddingFrame(payload, &header);
+      // InsertAndVerifyPaddingFrame(kPayload, &header);
       clock_.AdvanceTimeMilliseconds(33);
       header.header.timestamp += 3000;
     }