Simplify FakeReceiveStatistics in video send stream tests

webrtc/video/video_send_stream_tests.cc

 /*
  *  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 <algorithm>  // max
@@ skipping 356 matching lines @@
     }
 
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for timing frames.";
     }
   } test;
 
   RunBaseTest(&test);
 }
 
-class FakeReceiveStatistics : public NullReceiveStatistics {
+class FakeReceiveStatistics : public ReceiveStatisticsProvider {
  public:
   FakeReceiveStatistics(uint32_t send_ssrc,
                         uint32_t last_sequence_number,
                         uint32_t cumulative_lost,
-                        uint8_t fraction_lost)
-      : lossy_stats_(new LossyStatistician(last_sequence_number,
-                                           cumulative_lost,
-                                           fraction_lost)) {
-    stats_map_[send_ssrc] = lossy_stats_.get();
+                        uint8_t fraction_lost) {
+    stat_.SetMediaSsrc(send_ssrc);
+    stat_.SetExtHighestSeqNum(last_sequence_number);
+    stat_.SetCumulativeLost(cumulative_lost);
+    stat_.SetFractionLost(fraction_lost);
   }
 
-  StatisticianMap GetActiveStatisticians() const override { return stats_map_; }
-
-  StreamStatistician* GetStatistician(uint32_t ssrc) const override {
-    return lossy_stats_.get();
+  std::vector<rtcp::ReportBlock> RtcpReportBlocks(size_t max_blocks) override {
+    EXPECT_GE(max_blocks, 1u);
+    return {stat_};
   }
 
  private:
-  class LossyStatistician : public StreamStatistician {
-   public:
-    LossyStatistician(uint32_t extended_max_sequence_number,
-                      uint32_t cumulative_lost,
-                      uint8_t fraction_lost) {
-      stats_.fraction_lost = fraction_lost;
-      stats_.cumulative_lost = cumulative_lost;
-      stats_.extended_max_sequence_number = extended_max_sequence_number;
-    }
-    bool GetStatistics(RtcpStatistics* statistics, bool reset) override {
-      *statistics = stats_;
-      return true;
-    }
-    void GetDataCounters(size_t* bytes_received,
-                         uint32_t* packets_received) const override {
-      *bytes_received = 0;
-      *packets_received = 0;
-    }
-    void GetReceiveStreamDataCounters(
-        StreamDataCounters* data_counters) const override {}
-    uint32_t BitrateReceived() const override { return 0; }
-    bool IsRetransmitOfOldPacket(const RTPHeader& header,
-                                 int64_t min_rtt) const override {
-      return false;
-    }
-
-    bool IsPacketInOrder(uint16_t sequence_number) const override {
-      return true;
-    }
-
-    RtcpStatistics stats_;
-  };
-
-  std::unique_ptr<LossyStatistician> lossy_stats_;
-  StatisticianMap stats_map_;
+  rtcp::ReportBlock stat_;
 };
 
 class UlpfecObserver : public test::EndToEndTest {
  public:
   UlpfecObserver(bool header_extensions_enabled,
                  bool use_nack,
                  bool expect_red,
                  bool expect_ulpfec,
                  const std::string& codec,
                  VideoEncoder* encoder)
@@ skipping 3007 matching lines @@
       capturer_ = frame_generator_capturer;
     }
 
     test::FrameGeneratorCapturer* capturer_ = nullptr;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc