diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index d88ce4221a..2ffee9e432 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -71,12 +71,12 @@ rtc_library("frame_dependencies_calculator") {
   ]
 }
 
-rtc_library("nack_module") {
+rtc_library("nack_requester") {
   sources = [
     "histogram.cc",
     "histogram.h",
-    "nack_module2.cc",
-    "nack_module2.h",
+    "nack_requester.cc",
+    "nack_requester.h",
   ]
 
   deps = [
@@ -965,8 +965,8 @@ if (rtc_include_tests) {
       "jitter_buffer_unittest.cc",
       "jitter_estimator_tests.cc",
       "loss_notification_controller_unittest.cc",
-      "nack_module2_unittest.cc",
       "nack_module_unittest.cc",
+      "nack_requester_unittest.cc",
       "packet_buffer_unittest.cc",
       "receiver_unittest.cc",
       "rtp_frame_reference_finder_unittest.cc",
@@ -1002,7 +1002,7 @@ if (rtc_include_tests) {
       ":codec_globals_headers",
       ":encoded_frame",
       ":frame_dependencies_calculator",
-      ":nack_module",
+      ":nack_requester",
       ":simulcast_test_fixture_impl",
       ":video_codec_interface",
       ":video_codecs_test_framework",
diff --git a/modules/video_coding/deprecated/BUILD.gn b/modules/video_coding/deprecated/BUILD.gn
index 487c0267d5..a6fa790f9c 100644
--- a/modules/video_coding/deprecated/BUILD.gn
+++ b/modules/video_coding/deprecated/BUILD.gn
@@ -15,7 +15,7 @@ rtc_library("nack_module") {
   ]
 
   deps = [
-    "..:nack_module",
+    "..:nack_requester",
     "../..:module_api",
     "../../../api/units:time_delta",
     "../../../api/units:timestamp",
diff --git a/modules/video_coding/nack_module2.cc b/modules/video_coding/nack_requester.cc
similarity index 85%
rename from modules/video_coding/nack_module2.cc
rename to modules/video_coding/nack_requester.cc
index 41a5b31cd2..6983576367 100644
--- a/modules/video_coding/nack_module2.cc
+++ b/modules/video_coding/nack_requester.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "modules/video_coding/nack_module2.h"
+#include "modules/video_coding/nack_requester.h"
 
 #include <algorithm>
 #include <limits>
@@ -52,7 +52,7 @@ NackPeriodicProcessor::NackPeriodicProcessor(TimeDelta update_interval)
 
 NackPeriodicProcessor::~NackPeriodicProcessor() {}
 
-void NackPeriodicProcessor::RegisterNackModule(NackModuleBase* module) {
+void NackPeriodicProcessor::RegisterNackModule(NackRequesterBase* module) {
   RTC_DCHECK_RUN_ON(&sequence_);
   modules_.push_back(module);
   if (modules_.size() != 1)
@@ -65,7 +65,7 @@ void NackPeriodicProcessor::RegisterNackModule(NackModuleBase* module) {
       });
 }
 
-void NackPeriodicProcessor::UnregisterNackModule(NackModuleBase* module) {
+void NackPeriodicProcessor::UnregisterNackModule(NackRequesterBase* module) {
   RTC_DCHECK_RUN_ON(&sequence_);
   auto it = std::find(modules_.begin(), modules_.end(), module);
   RTC_DCHECK(it != modules_.end());
@@ -76,12 +76,12 @@ void NackPeriodicProcessor::UnregisterNackModule(NackModuleBase* module) {
 
 // RTC_RUN_ON(sequence_)
 void NackPeriodicProcessor::ProcessNackModules() {
-  for (NackModuleBase* module : modules_)
+  for (NackRequesterBase* module : modules_)
     module->ProcessNacks();
 }
 
 ScopedNackPeriodicProcessorRegistration::
-    ScopedNackPeriodicProcessorRegistration(NackModuleBase* module,
+    ScopedNackPeriodicProcessorRegistration(NackRequesterBase* module,
                                             NackPeriodicProcessor* processor)
     : module_(module), processor_(processor) {
   processor_->RegisterNackModule(module_);
@@ -92,25 +92,25 @@ ScopedNackPeriodicProcessorRegistration::
   processor_->UnregisterNackModule(module_);
 }
 
-NackModule2::NackInfo::NackInfo()
+NackRequester::NackInfo::NackInfo()
     : seq_num(0), send_at_seq_num(0), sent_at_time(-1), retries(0) {}
 
-NackModule2::NackInfo::NackInfo(uint16_t seq_num,
-                                uint16_t send_at_seq_num,
-                                int64_t created_at_time)
+NackRequester::NackInfo::NackInfo(uint16_t seq_num,
+                                  uint16_t send_at_seq_num,
+                                  int64_t created_at_time)
     : seq_num(seq_num),
       send_at_seq_num(send_at_seq_num),
       created_at_time(created_at_time),
       sent_at_time(-1),
       retries(0) {}
 
-NackModule2::BackoffSettings::BackoffSettings(TimeDelta min_retry,
-                                              TimeDelta max_rtt,
-                                              double base)
+NackRequester::BackoffSettings::BackoffSettings(TimeDelta min_retry,
+                                                TimeDelta max_rtt,
+                                                double base)
     : min_retry_interval(min_retry), max_rtt(max_rtt), base(base) {}
 
-absl::optional<NackModule2::BackoffSettings>
-NackModule2::BackoffSettings::ParseFromFieldTrials() {
+absl::optional<NackRequester::BackoffSettings>
+NackRequester::BackoffSettings::ParseFromFieldTrials() {
   // Matches magic number in RTPSender::OnReceivedNack().
   const TimeDelta kDefaultMinRetryInterval = TimeDelta::Millis(5);
   // Upper bound on link-delay considered for exponential backoff.
@@ -129,17 +129,17 @@ NackModule2::BackoffSettings::ParseFromFieldTrials() {
                   field_trial::FindFullName("WebRTC-ExponentialNackBackoff"));
 
   if (enabled) {
-    return NackModule2::BackoffSettings(min_retry.Get(), max_rtt.Get(),
-                                        base.Get());
+    return NackRequester::BackoffSettings(min_retry.Get(), max_rtt.Get(),
+                                          base.Get());
   }
   return absl::nullopt;
 }
 
-NackModule2::NackModule2(TaskQueueBase* current_queue,
-                         NackPeriodicProcessor* periodic_processor,
-                         Clock* clock,
-                         NackSender* nack_sender,
-                         KeyFrameRequestSender* keyframe_request_sender)
+NackRequester::NackRequester(TaskQueueBase* current_queue,
+                             NackPeriodicProcessor* periodic_processor,
+                             Clock* clock,
+                             NackSender* nack_sender,
+                             KeyFrameRequestSender* keyframe_request_sender)
     : worker_thread_(current_queue),
       clock_(clock),
       nack_sender_(nack_sender),
@@ -158,11 +158,11 @@ NackModule2::NackModule2(TaskQueueBase* current_queue,
   RTC_DCHECK(worker_thread_->IsCurrent());
 }
 
-NackModule2::~NackModule2() {
+NackRequester::~NackRequester() {
   RTC_DCHECK_RUN_ON(worker_thread_);
 }
 
-void NackModule2::ProcessNacks() {
+void NackRequester::ProcessNacks() {
   RTC_DCHECK_RUN_ON(worker_thread_);
   std::vector<uint16_t> nack_batch = GetNackBatch(kTimeOnly);
   if (!nack_batch.empty()) {
@@ -172,14 +172,14 @@ void NackModule2::ProcessNacks() {
   }
 }
 
-int NackModule2::OnReceivedPacket(uint16_t seq_num, bool is_keyframe) {
+int NackRequester::OnReceivedPacket(uint16_t seq_num, bool is_keyframe) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   return OnReceivedPacket(seq_num, is_keyframe, false);
 }
 
-int NackModule2::OnReceivedPacket(uint16_t seq_num,
-                                  bool is_keyframe,
-                                  bool is_recovered) {
+int NackRequester::OnReceivedPacket(uint16_t seq_num,
+                                    bool is_keyframe,
+                                    bool is_recovered) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   // TODO(philipel): When the packet includes information whether it is
   //                 retransmitted or not, use that value instead. For
@@ -248,7 +248,7 @@ int NackModule2::OnReceivedPacket(uint16_t seq_num,
   return 0;
 }
 
-void NackModule2::ClearUpTo(uint16_t seq_num) {
+void NackRequester::ClearUpTo(uint16_t seq_num) {
   // Called via RtpVideoStreamReceiver2::FrameContinuous on the network thread.
   worker_thread_->PostTask(ToQueuedTask(task_safety_, [seq_num, this]() {
     RTC_DCHECK_RUN_ON(worker_thread_);
@@ -260,12 +260,12 @@ void NackModule2::ClearUpTo(uint16_t seq_num) {
   }));
 }
 
-void NackModule2::UpdateRtt(int64_t rtt_ms) {
+void NackRequester::UpdateRtt(int64_t rtt_ms) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   rtt_ms_ = rtt_ms;
 }
 
-bool NackModule2::RemovePacketsUntilKeyFrame() {
+bool NackRequester::RemovePacketsUntilKeyFrame() {
   // Called on worker_thread_.
   while (!keyframe_list_.empty()) {
     auto it = nack_list_.lower_bound(*keyframe_list_.begin());
@@ -284,8 +284,8 @@ bool NackModule2::RemovePacketsUntilKeyFrame() {
   return false;
 }
 
-void NackModule2::AddPacketsToNack(uint16_t seq_num_start,
-                                   uint16_t seq_num_end) {
+void NackRequester::AddPacketsToNack(uint16_t seq_num_start,
+                                     uint16_t seq_num_end) {
   // Called on worker_thread_.
   // Remove old packets.
   auto it = nack_list_.lower_bound(seq_num_end - kMaxPacketAge);
@@ -320,7 +320,7 @@ void NackModule2::AddPacketsToNack(uint16_t seq_num_start,
   }
 }
 
-std::vector<uint16_t> NackModule2::GetNackBatch(NackFilterOptions options) {
+std::vector<uint16_t> NackRequester::GetNackBatch(NackFilterOptions options) {
   // Called on worker_thread_.
 
   bool consider_seq_num = options != kTimeOnly;
@@ -367,14 +367,14 @@ std::vector<uint16_t> NackModule2::GetNackBatch(NackFilterOptions options) {
   return nack_batch;
 }
 
-void NackModule2::UpdateReorderingStatistics(uint16_t seq_num) {
+void NackRequester::UpdateReorderingStatistics(uint16_t seq_num) {
   // Running on worker_thread_.
   RTC_DCHECK(AheadOf(newest_seq_num_, seq_num));
   uint16_t diff = ReverseDiff(newest_seq_num_, seq_num);
   reordering_histogram_.Add(diff);
 }
 
-int NackModule2::WaitNumberOfPackets(float probability) const {
+int NackRequester::WaitNumberOfPackets(float probability) const {
   // Called on worker_thread_;
   if (reordering_histogram_.NumValues() == 0)
     return 0;
diff --git a/modules/video_coding/nack_module2.h b/modules/video_coding/nack_requester.h
similarity index 83%
rename from modules/video_coding/nack_module2.h
rename to modules/video_coding/nack_requester.h
index f1f212c94f..8b012379e2 100644
--- a/modules/video_coding/nack_module2.h
+++ b/modules/video_coding/nack_requester.h
@@ -8,8 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef MODULES_VIDEO_CODING_NACK_MODULE2_H_
-#define MODULES_VIDEO_CODING_NACK_MODULE2_H_
+#ifndef MODULES_VIDEO_CODING_NACK_REQUESTER_H_
+#define MODULES_VIDEO_CODING_NACK_REQUESTER_H_
 
 #include <stdint.h>
 
@@ -30,9 +30,9 @@
 
 namespace webrtc {
 
-class NackModuleBase {
+class NackRequesterBase {
  public:
-  virtual ~NackModuleBase() = default;
+  virtual ~NackRequesterBase() = default;
   virtual void ProcessNacks() = 0;
 };
 
@@ -41,40 +41,37 @@ class NackPeriodicProcessor {
   static constexpr TimeDelta kUpdateInterval = TimeDelta::Millis(20);
   explicit NackPeriodicProcessor(TimeDelta update_interval = kUpdateInterval);
   ~NackPeriodicProcessor();
-  void RegisterNackModule(NackModuleBase* module);
-  void UnregisterNackModule(NackModuleBase* module);
+  void RegisterNackModule(NackRequesterBase* module);
+  void UnregisterNackModule(NackRequesterBase* module);
 
  private:
   void ProcessNackModules() RTC_RUN_ON(sequence_);
 
   const TimeDelta update_interval_;
   RepeatingTaskHandle repeating_task_ RTC_GUARDED_BY(sequence_);
-  std::vector<NackModuleBase*> modules_ RTC_GUARDED_BY(sequence_);
+  std::vector<NackRequesterBase*> modules_ RTC_GUARDED_BY(sequence_);
   RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_;
 };
 
 class ScopedNackPeriodicProcessorRegistration {
  public:
-  ScopedNackPeriodicProcessorRegistration(NackModuleBase* module,
+  ScopedNackPeriodicProcessorRegistration(NackRequesterBase* module,
                                           NackPeriodicProcessor* processor);
   ~ScopedNackPeriodicProcessorRegistration();
 
  private:
-  NackModuleBase* const module_;
+  NackRequesterBase* const module_;
   NackPeriodicProcessor* const processor_;
 };
 
-// TODO(bugs.webrtc.org/11594): This class no longer implements the Module
-// interface and therefore "NackModule" may not be a descriptive name anymore.
-// Consider renaming to e.g. NackTracker or NackRequester.
-class NackModule2 final : public NackModuleBase {
+class NackRequester final : public NackRequesterBase {
  public:
-  NackModule2(TaskQueueBase* current_queue,
-              NackPeriodicProcessor* periodic_processor,
-              Clock* clock,
-              NackSender* nack_sender,
-              KeyFrameRequestSender* keyframe_request_sender);
-  ~NackModule2();
+  NackRequester(TaskQueueBase* current_queue,
+                NackPeriodicProcessor* periodic_processor,
+                Clock* clock,
+                NackSender* nack_sender,
+                KeyFrameRequestSender* keyframe_request_sender);
+  ~NackRequester();
 
   void ProcessNacks() override;
 
@@ -168,4 +165,4 @@ class NackModule2 final : public NackModuleBase {
 
 }  // namespace webrtc
 
-#endif  // MODULES_VIDEO_CODING_NACK_MODULE2_H_
+#endif  // MODULES_VIDEO_CODING_NACK_REQUESTER_H_
diff --git a/modules/video_coding/nack_module2_unittest.cc b/modules/video_coding/nack_requester_unittest.cc
similarity index 84%
rename from modules/video_coding/nack_module2_unittest.cc
rename to modules/video_coding/nack_requester_unittest.cc
index 7ffcc12891..c9659e37ea 100644
--- a/modules/video_coding/nack_module2_unittest.cc
+++ b/modules/video_coding/nack_requester_unittest.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "modules/video_coding/nack_module2.h"
+#include "modules/video_coding/nack_requester.h"
 
 #include <algorithm>
 #include <cstdint>
@@ -24,11 +24,11 @@ namespace webrtc {
 // TODO(bugs.webrtc.org/11594): Use the use the GlobalSimulatedTimeController
 // instead of RunLoop. At the moment we mix use of the Clock and the underlying
 // implementation of RunLoop, which is realtime.
-class TestNackModule2 : public ::testing::TestWithParam<bool>,
-                        public NackSender,
-                        public KeyFrameRequestSender {
+class TestNackRequester : public ::testing::TestWithParam<bool>,
+                          public NackSender,
+                          public KeyFrameRequestSender {
  protected:
-  TestNackModule2()
+  TestNackRequester()
       : clock_(new SimulatedClock(0)),
         field_trial_(GetParam()
                          ? "WebRTC-ExponentialNackBackoff/enabled:true/"
@@ -79,14 +79,14 @@ class TestNackModule2 : public ::testing::TestWithParam<bool>,
     return true;
   }
 
-  NackModule2& CreateNackModule(
+  NackRequester& CreateNackModule(
       TimeDelta interval = NackPeriodicProcessor::kUpdateInterval) {
     RTC_DCHECK(!nack_module_.get());
     nack_periodic_processor_ =
         std::make_unique<NackPeriodicProcessor>(interval);
-    nack_module_ = std::make_unique<NackModule2>(TaskQueueBase::Current(),
-                                                 nack_periodic_processor_.get(),
-                                                 clock_.get(), this, this);
+    nack_module_ = std::make_unique<NackRequester>(
+        TaskQueueBase::Current(), nack_periodic_processor_.get(), clock_.get(),
+        this, this);
     nack_module_->UpdateRtt(kDefaultRttMs);
     return *nack_module_.get();
   }
@@ -96,23 +96,23 @@ class TestNackModule2 : public ::testing::TestWithParam<bool>,
   std::unique_ptr<SimulatedClock> clock_;
   test::ScopedFieldTrials field_trial_;
   std::unique_ptr<NackPeriodicProcessor> nack_periodic_processor_;
-  std::unique_ptr<NackModule2> nack_module_;
+  std::unique_ptr<NackRequester> nack_module_;
   std::vector<uint16_t> sent_nacks_;
   int keyframes_requested_;
   bool waiting_for_send_nack_ = false;
   bool timed_out_ = false;
 };
 
-TEST_P(TestNackModule2, NackOnePacket) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, NackOnePacket) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(1, false, false);
   nack_module.OnReceivedPacket(3, false, false);
   ASSERT_EQ(1u, sent_nacks_.size());
   EXPECT_EQ(2, sent_nacks_[0]);
 }
 
-TEST_P(TestNackModule2, WrappingSeqNum) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, WrappingSeqNum) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(0xfffe, false, false);
   nack_module.OnReceivedPacket(1, false, false);
   ASSERT_EQ(2u, sent_nacks_.size());
@@ -120,8 +120,8 @@ TEST_P(TestNackModule2, WrappingSeqNum) {
   EXPECT_EQ(0, sent_nacks_[1]);
 }
 
-TEST_P(TestNackModule2, WrappingSeqNumClearToKeyframe) {
-  NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(10));
+TEST_P(TestNackRequester, WrappingSeqNumClearToKeyframe) {
+  NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(10));
   nack_module.OnReceivedPacket(0xfffe, false, false);
   nack_module.OnReceivedPacket(1, false, false);
   ASSERT_EQ(2u, sent_nacks_.size());
@@ -185,8 +185,8 @@ TEST_P(TestNackModule2, WrappingSeqNumClearToKeyframe) {
   EXPECT_EQ(1006, sent_nacks_[502]);
 }
 
-TEST_P(TestNackModule2, ResendNack) {
-  NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
+TEST_P(TestNackRequester, ResendNack) {
+  NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
   nack_module.OnReceivedPacket(1, false, false);
   nack_module.OnReceivedPacket(3, false, false);
   size_t expected_nacks_sent = 1;
@@ -239,8 +239,8 @@ TEST_P(TestNackModule2, ResendNack) {
   EXPECT_EQ(expected_nacks_sent, sent_nacks_.size());
 }
 
-TEST_P(TestNackModule2, ResendPacketMaxRetries) {
-  NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
+TEST_P(TestNackRequester, ResendPacketMaxRetries) {
+  NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
   nack_module.OnReceivedPacket(1, false, false);
   nack_module.OnReceivedPacket(3, false, false);
   ASSERT_EQ(1u, sent_nacks_.size());
@@ -260,8 +260,8 @@ TEST_P(TestNackModule2, ResendPacketMaxRetries) {
   EXPECT_EQ(10u, sent_nacks_.size());
 }
 
-TEST_P(TestNackModule2, TooLargeNackList) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, TooLargeNackList) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(0, false, false);
   nack_module.OnReceivedPacket(1001, false, false);
   EXPECT_EQ(1000u, sent_nacks_.size());
@@ -274,8 +274,8 @@ TEST_P(TestNackModule2, TooLargeNackList) {
   EXPECT_EQ(1, keyframes_requested_);
 }
 
-TEST_P(TestNackModule2, TooLargeNackListWithKeyFrame) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, TooLargeNackListWithKeyFrame) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(0, false, false);
   nack_module.OnReceivedPacket(1, true, false);
   nack_module.OnReceivedPacket(1001, false, false);
@@ -289,8 +289,8 @@ TEST_P(TestNackModule2, TooLargeNackListWithKeyFrame) {
   EXPECT_EQ(1, keyframes_requested_);
 }
 
-TEST_P(TestNackModule2, ClearUpTo) {
-  NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
+TEST_P(TestNackRequester, ClearUpTo) {
+  NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
   nack_module.OnReceivedPacket(0, false, false);
   nack_module.OnReceivedPacket(100, false, false);
   EXPECT_EQ(99u, sent_nacks_.size());
@@ -303,8 +303,8 @@ TEST_P(TestNackModule2, ClearUpTo) {
   EXPECT_EQ(50, sent_nacks_[0]);
 }
 
-TEST_P(TestNackModule2, ClearUpToWrap) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, ClearUpToWrap) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(0xfff0, false, false);
   nack_module.OnReceivedPacket(0xf, false, false);
   EXPECT_EQ(30u, sent_nacks_.size());
@@ -317,8 +317,8 @@ TEST_P(TestNackModule2, ClearUpToWrap) {
   EXPECT_EQ(0, sent_nacks_[0]);
 }
 
-TEST_P(TestNackModule2, PacketNackCount) {
-  NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
+TEST_P(TestNackRequester, PacketNackCount) {
+  NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
   EXPECT_EQ(0, nack_module.OnReceivedPacket(0, false, false));
   EXPECT_EQ(0, nack_module.OnReceivedPacket(2, false, false));
   EXPECT_EQ(1, nack_module.OnReceivedPacket(1, false, false));
@@ -340,8 +340,8 @@ TEST_P(TestNackModule2, PacketNackCount) {
   EXPECT_EQ(0, nack_module.OnReceivedPacket(4, false, false));
 }
 
-TEST_P(TestNackModule2, NackListFullAndNoOverlapWithKeyframes) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, NackListFullAndNoOverlapWithKeyframes) {
+  NackRequester& nack_module = CreateNackModule();
   const int kMaxNackPackets = 1000;
   const unsigned int kFirstGap = kMaxNackPackets - 20;
   const unsigned int kSecondGap = 200;
@@ -356,8 +356,8 @@ TEST_P(TestNackModule2, NackListFullAndNoOverlapWithKeyframes) {
   EXPECT_EQ(kSecondGap, sent_nacks_.size());
 }
 
-TEST_P(TestNackModule2, HandleFecRecoveredPacket) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, HandleFecRecoveredPacket) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(1, false, false);
   nack_module.OnReceivedPacket(4, false, true);
   EXPECT_EQ(0u, sent_nacks_.size());
@@ -365,22 +365,22 @@ TEST_P(TestNackModule2, HandleFecRecoveredPacket) {
   EXPECT_EQ(2u, sent_nacks_.size());
 }
 
-TEST_P(TestNackModule2, SendNackWithoutDelay) {
-  NackModule2& nack_module = CreateNackModule();
+TEST_P(TestNackRequester, SendNackWithoutDelay) {
+  NackRequester& nack_module = CreateNackModule();
   nack_module.OnReceivedPacket(0, false, false);
   nack_module.OnReceivedPacket(100, false, false);
   EXPECT_EQ(99u, sent_nacks_.size());
 }
 
 INSTANTIATE_TEST_SUITE_P(WithAndWithoutBackoff,
-                         TestNackModule2,
+                         TestNackRequester,
                          ::testing::Values(true, false));
 
-class TestNackModule2WithFieldTrial : public ::testing::Test,
-                                      public NackSender,
-                                      public KeyFrameRequestSender {
+class TestNackRequesterWithFieldTrial : public ::testing::Test,
+                                        public NackSender,
+                                        public KeyFrameRequestSender {
  protected:
-  TestNackModule2WithFieldTrial()
+  TestNackRequesterWithFieldTrial()
       : nack_delay_field_trial_("WebRTC-SendNackDelayMs/10/"),
         clock_(new SimulatedClock(0)),
         nack_module_(TaskQueueBase::Current(),
@@ -401,12 +401,12 @@ class TestNackModule2WithFieldTrial : public ::testing::Test,
   test::ScopedFieldTrials nack_delay_field_trial_;
   std::unique_ptr<SimulatedClock> clock_;
   NackPeriodicProcessor nack_periodic_processor_;
-  NackModule2 nack_module_;
+  NackRequester nack_module_;
   std::vector<uint16_t> sent_nacks_;
   int keyframes_requested_;
 };
 
-TEST_F(TestNackModule2WithFieldTrial, SendNackWithDelay) {
+TEST_F(TestNackRequesterWithFieldTrial, SendNackWithDelay) {
   nack_module_.OnReceivedPacket(0, false, false);
   nack_module_.OnReceivedPacket(100, false, false);
   EXPECT_EQ(0u, sent_nacks_.size());
diff --git a/video/BUILD.gn b/video/BUILD.gn
index 7743aba944..4bdd94f345 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -95,7 +95,7 @@ rtc_library("video") {
     "../modules/utility",
     "../modules/video_coding",
     "../modules/video_coding:codec_globals_headers",
-    "../modules/video_coding:nack_module",
+    "../modules/video_coding:nack_requester",
     "../modules/video_coding:video_codec_interface",
     "../modules/video_coding:video_coding_utility",
     "../modules/video_processing",
diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index 8929ab4f1c..daddae9433 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc
@@ -39,7 +39,7 @@
 #include "modules/video_coding/frame_object.h"
 #include "modules/video_coding/h264_sprop_parameter_sets.h"
 #include "modules/video_coding/h264_sps_pps_tracker.h"
-#include "modules/video_coding/nack_module2.h"
+#include "modules/video_coding/nack_requester.h"
 #include "modules/video_coding/packet_buffer.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/location.h"
@@ -103,7 +103,7 @@ std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
   return rtp_rtcp;
 }
 
-std::unique_ptr<NackModule2> MaybeConstructNackModule(
+std::unique_ptr<NackRequester> MaybeConstructNackModule(
     TaskQueueBase* current_queue,
     NackPeriodicProcessor* nack_periodic_processor,
     const VideoReceiveStream::Config& config,
@@ -114,9 +114,9 @@ std::unique_ptr<NackModule2> MaybeConstructNackModule(
     return nullptr;
 
   // TODO(bugs.webrtc.org/12420): pass rtp_history_ms to the nack module.
-  return std::make_unique<NackModule2>(current_queue, nack_periodic_processor,
-                                       clock, nack_sender,
-                                       keyframe_request_sender);
+  return std::make_unique<NackRequester>(current_queue, nack_periodic_processor,
+                                         clock, nack_sender,
+                                         keyframe_request_sender);
 }
 
 static const int kPacketLogIntervalMs = 10000;
diff --git a/video/rtp_video_stream_receiver2.h b/video/rtp_video_stream_receiver2.h
index d97f5211a7..3b20e1c53b 100644
--- a/video/rtp_video_stream_receiver2.h
+++ b/video/rtp_video_stream_receiver2.h
@@ -39,7 +39,7 @@
 #include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
 #include "modules/video_coding/h264_sps_pps_tracker.h"
 #include "modules/video_coding/loss_notification_controller.h"
-#include "modules/video_coding/nack_module2.h"
+#include "modules/video_coding/nack_requester.h"
 #include "modules/video_coding/packet_buffer.h"
 #include "modules/video_coding/rtp_frame_reference_finder.h"
 #include "modules/video_coding/unique_timestamp_counter.h"
@@ -53,7 +53,7 @@
 
 namespace webrtc {
 
-class NackModule2;
+class NackRequester;
 class PacketRouter;
 class ReceiveStatistics;
 class RtcpRttStats;
@@ -316,7 +316,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
   KeyFrameRequestSender* const keyframe_request_sender_;
 
   RtcpFeedbackBuffer rtcp_feedback_buffer_;
-  const std::unique_ptr<NackModule2> nack_module_;
+  const std::unique_ptr<NackRequester> nack_module_;
   std::unique_ptr<LossNotificationController> loss_notification_controller_;
 
   video_coding::PacketBuffer packet_buffer_
diff --git a/video/video_receive_stream2.h b/video/video_receive_stream2.h
index 9ed5942453..2d19514abd 100644
--- a/video/video_receive_stream2.h
+++ b/video/video_receive_stream2.h
@@ -25,7 +25,7 @@
 #include "modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "modules/rtp_rtcp/source/source_tracker.h"
 #include "modules/video_coding/frame_buffer2.h"
-#include "modules/video_coding/nack_module2.h"
+#include "modules/video_coding/nack_requester.h"
 #include "modules/video_coding/video_receiver2.h"
 #include "rtc_base/system/no_unique_address.h"
 #include "rtc_base/task_queue.h"