diff --git a/BUILD.gn b/BUILD.gn
index 3ad9c97..461138a 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -638,7 +638,6 @@
       "test:test_common",
       "test:test_main",
       "test:video_test_common",
-      "video:video_legacy_tests",
       "video:video_tests",
       "video/adaptation:video_adaptation_tests",
     ]
diff --git a/video/BUILD.gn b/video/BUILD.gn
index 381cad0..35e12e4 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -166,81 +166,6 @@
   }
 }
 
-rtc_source_set("video_legacy") {
-  sources = [
-    "call_stats.cc",
-    "call_stats.h",
-    "receive_statistics_proxy.cc",
-    "receive_statistics_proxy.h",
-    "video_quality_observer.cc",
-    "video_quality_observer.h",
-  ]
-  deps = [
-    ":frame_dumping_decoder",
-    ":unique_timestamp_counter",
-    ":video",
-    "../api:array_view",
-    "../api:field_trials_view",
-    "../api:scoped_refptr",
-    "../api:sequence_checker",
-    "../api/crypto:frame_decryptor_interface",
-    "../api/task_queue",
-    "../api/transport:field_trial_based_config",
-    "../api/units:timestamp",
-    "../api/video:encoded_image",
-    "../api/video:recordable_encoded_frame",
-    "../api/video:video_frame",
-    "../api/video:video_rtp_headers",
-    "../call:call_interfaces",
-    "../call:rtp_interfaces",
-    "../call:rtp_receiver",  # For RtxReceiveStream.
-    "../call:video_stream_api",
-    "../common_video",
-    "../modules:module_api",
-    "../modules/pacing",
-    "../modules/remote_bitrate_estimator",
-    "../modules/rtp_rtcp",
-    "../modules/rtp_rtcp:rtp_rtcp_format",
-    "../modules/rtp_rtcp:rtp_rtcp_legacy",
-    "../modules/rtp_rtcp:rtp_video_header",
-    "../modules/utility",
-    "../modules/video_coding",
-    "../modules/video_coding:packet_buffer",
-    "../modules/video_coding:video_codec_interface",
-    "../modules/video_coding:video_coding_utility",
-    "../modules/video_coding/deprecated:nack_module",
-    "../rtc_base:checks",
-    "../rtc_base:histogram_percentile_counter",
-    "../rtc_base:location",
-    "../rtc_base:logging",
-    "../rtc_base:macromagic",
-    "../rtc_base:moving_max_counter",
-    "../rtc_base:platform_thread",
-    "../rtc_base:rate_statistics",
-    "../rtc_base:rate_tracker",
-    "../rtc_base:rtc_numerics",
-    "../rtc_base:rtc_task_queue",
-    "../rtc_base:sample_counter",
-    "../rtc_base:stringutils",
-    "../rtc_base:timeutils",
-    "../rtc_base/experiments:field_trial_parser",
-    "../rtc_base/experiments:keyframe_interval_settings_experiment",
-    "../rtc_base/synchronization:mutex",
-    "../rtc_base/system:no_unique_address",
-    "../rtc_base/task_utils:to_queued_task",
-    "../system_wrappers",
-    "../system_wrappers:field_trial",
-    "../system_wrappers:metrics",
-  ]
-  if (!build_with_mozilla) {
-    deps += [ "../media:rtc_media_base" ]
-  }
-  absl_deps = [
-    "//third_party/abseil-cpp/absl/algorithm:container",
-    "//third_party/abseil-cpp/absl/types:optional",
-  ]
-}
-
 rtc_library("video_stream_decoder_impl") {
   visibility = [ "*" ]
 
@@ -1001,40 +926,4 @@
       deps += [ "../media:rtc_media_base" ]
     }
   }
-  rtc_library("video_legacy_tests") {
-    testonly = true
-    sources = [
-      "call_stats_unittest.cc",
-      "receive_statistics_proxy_unittest.cc",
-    ]
-    deps = [
-      ":video_legacy",
-      "../api:scoped_refptr",
-      "../api/video:video_frame",
-      "../api/video:video_frame_type",
-      "../api/video:video_rtp_headers",
-      "../call:mock_rtp_interfaces",
-      "../common_video",
-      "../media:rtc_media_base",
-      "../modules/rtp_rtcp",
-      "../modules/rtp_rtcp:rtp_rtcp_format",
-      "../modules/utility",
-      "../modules/video_coding",
-      "../modules/video_coding:video_codec_interface",
-      "../rtc_base:byte_buffer",
-      "../rtc_base:location",
-      "../rtc_base:logging",
-      "../rtc_base:rtc_event",
-      "../rtc_base/task_utils:to_queued_task",
-      "../system_wrappers",
-      "../system_wrappers:field_trial",
-      "../system_wrappers:metrics",
-      "../test:field_trial",
-      "../test:mock_frame_transformer",
-      "../test:mock_transport",
-      "../test:scoped_key_value_config",
-      "../test:test_support",
-    ]
-    absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
-  }
 }
diff --git a/video/call_stats.cc b/video/call_stats.cc
deleted file mode 100644
index 9fd6802..0000000
--- a/video/call_stats.cc
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- *  Copyright (c) 2012 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 "video/call_stats.h"
-
-#include <algorithm>
-#include <memory>
-
-#include "absl/algorithm/container.h"
-#include "modules/utility/include/process_thread.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/location.h"
-#include "rtc_base/task_utils/to_queued_task.h"
-#include "system_wrappers/include/metrics.h"
-
-namespace webrtc {
-namespace {
-
-void RemoveOldReports(int64_t now, std::list<CallStats::RttTime>* reports) {
-  static constexpr const int64_t kRttTimeoutMs = 1500;
-  reports->remove_if(
-      [&now](CallStats::RttTime& r) { return now - r.time > kRttTimeoutMs; });
-}
-
-int64_t GetMaxRttMs(const std::list<CallStats::RttTime>& reports) {
-  int64_t max_rtt_ms = -1;
-  for (const CallStats::RttTime& rtt_time : reports)
-    max_rtt_ms = std::max(rtt_time.rtt, max_rtt_ms);
-  return max_rtt_ms;
-}
-
-int64_t GetAvgRttMs(const std::list<CallStats::RttTime>& reports) {
-  RTC_DCHECK(!reports.empty());
-  int64_t sum = 0;
-  for (std::list<CallStats::RttTime>::const_iterator it = reports.begin();
-       it != reports.end(); ++it) {
-    sum += it->rtt;
-  }
-  return sum / reports.size();
-}
-
-int64_t GetNewAvgRttMs(const std::list<CallStats::RttTime>& reports,
-                       int64_t prev_avg_rtt) {
-  if (reports.empty())
-    return -1;  // Reset (invalid average).
-
-  int64_t cur_rtt_ms = GetAvgRttMs(reports);
-  if (prev_avg_rtt == -1)
-    return cur_rtt_ms;  // New initial average value.
-
-  // Weight factor to apply to the average rtt.
-  // We weigh the old average at 70% against the new average (30%).
-  constexpr const float kWeightFactor = 0.3f;
-  return prev_avg_rtt * (1.0f - kWeightFactor) + cur_rtt_ms * kWeightFactor;
-}
-
-// This class is used to de-register a Module from a ProcessThread to satisfy
-// threading requirements of the Module (CallStats).
-// The guarantee offered by TemporaryDeregistration is that while its in scope,
-// no calls to `TimeUntilNextProcess` or `Process()` will occur and therefore
-// synchronization with those methods, is not necessary.
-class TemporaryDeregistration {
- public:
-  TemporaryDeregistration(Module* module,
-                          ProcessThread* process_thread,
-                          bool thread_running)
-      : module_(module),
-        process_thread_(process_thread),
-        deregistered_(thread_running) {
-    if (thread_running)
-      process_thread_->DeRegisterModule(module_);
-  }
-  ~TemporaryDeregistration() {
-    if (deregistered_)
-      process_thread_->RegisterModule(module_, RTC_FROM_HERE);
-  }
-
- private:
-  Module* const module_;
-  ProcessThread* const process_thread_;
-  const bool deregistered_;
-};
-
-}  // namespace
-
-CallStats::CallStats(Clock* clock, ProcessThread* process_thread)
-    : clock_(clock),
-      last_process_time_(clock_->TimeInMilliseconds()),
-      max_rtt_ms_(-1),
-      avg_rtt_ms_(-1),
-      sum_avg_rtt_ms_(0),
-      num_avg_rtt_(0),
-      time_of_first_rtt_ms_(-1),
-      process_thread_(process_thread),
-      process_thread_running_(false) {
-  RTC_DCHECK(process_thread_);
-  process_thread_checker_.Detach();
-}
-
-CallStats::~CallStats() {
-  RTC_DCHECK_RUN_ON(&construction_thread_checker_);
-  RTC_DCHECK(!process_thread_running_);
-  RTC_DCHECK(observers_.empty());
-
-  UpdateHistograms();
-}
-
-int64_t CallStats::TimeUntilNextProcess() {
-  RTC_DCHECK_RUN_ON(&process_thread_checker_);
-  return last_process_time_ + kUpdateIntervalMs - clock_->TimeInMilliseconds();
-}
-
-void CallStats::Process() {
-  RTC_DCHECK_RUN_ON(&process_thread_checker_);
-  int64_t now = clock_->TimeInMilliseconds();
-  last_process_time_ = now;
-
-  // `avg_rtt_ms_` is allowed to be read on the process thread since that's the
-  // only thread that modifies the value.
-  int64_t avg_rtt_ms = avg_rtt_ms_;
-  RemoveOldReports(now, &reports_);
-  max_rtt_ms_ = GetMaxRttMs(reports_);
-  avg_rtt_ms = GetNewAvgRttMs(reports_, avg_rtt_ms);
-  {
-    MutexLock lock(&avg_rtt_ms_lock_);
-    avg_rtt_ms_ = avg_rtt_ms;
-  }
-
-  // If there is a valid rtt, update all observers with the max rtt.
-  if (max_rtt_ms_ >= 0) {
-    RTC_DCHECK_GE(avg_rtt_ms, 0);
-    for (CallStatsObserver* observer : observers_)
-      observer->OnRttUpdate(avg_rtt_ms, max_rtt_ms_);
-    // Sum for Histogram of average RTT reported over the entire call.
-    sum_avg_rtt_ms_ += avg_rtt_ms;
-    ++num_avg_rtt_;
-  }
-}
-
-void CallStats::ProcessThreadAttached(ProcessThread* process_thread) {
-  RTC_DCHECK_RUN_ON(&construction_thread_checker_);
-  RTC_DCHECK(!process_thread || process_thread_ == process_thread);
-  process_thread_running_ = process_thread != nullptr;
-
-  // Whether we just got attached or detached, we clear the
-  // `process_thread_checker_` so that it can be used to protect variables
-  // in either the process thread when it starts again, or UpdateHistograms()
-  // (mutually exclusive).
-  process_thread_checker_.Detach();
-}
-
-void CallStats::RegisterStatsObserver(CallStatsObserver* observer) {
-  RTC_DCHECK_RUN_ON(&construction_thread_checker_);
-  TemporaryDeregistration deregister(this, process_thread_,
-                                     process_thread_running_);
-
-  if (!absl::c_linear_search(observers_, observer))
-    observers_.push_back(observer);
-}
-
-void CallStats::DeregisterStatsObserver(CallStatsObserver* observer) {
-  RTC_DCHECK_RUN_ON(&construction_thread_checker_);
-  TemporaryDeregistration deregister(this, process_thread_,
-                                     process_thread_running_);
-  observers_.remove(observer);
-}
-
-int64_t CallStats::LastProcessedRtt() const {
-  // TODO(tommi): This currently gets called from the construction thread of
-  // Call as well as from the process thread. Look into restricting this to
-  // allow only reading this from the process thread (or TQ once we get there)
-  // so that the lock isn't necessary.
-
-  MutexLock lock(&avg_rtt_ms_lock_);
-  return avg_rtt_ms_;
-}
-
-void CallStats::OnRttUpdate(int64_t rtt) {
-  RTC_DCHECK_RUN_ON(&process_thread_checker_);
-
-  int64_t now_ms = clock_->TimeInMilliseconds();
-  reports_.push_back(RttTime(rtt, now_ms));
-  if (time_of_first_rtt_ms_ == -1)
-    time_of_first_rtt_ms_ = now_ms;
-
-  // Make sure Process() will be called and deliver the updates asynchronously.
-  last_process_time_ -= kUpdateIntervalMs;
-  process_thread_->WakeUp(this);
-}
-
-void CallStats::UpdateHistograms() {
-  RTC_DCHECK_RUN_ON(&construction_thread_checker_);
-  RTC_DCHECK(!process_thread_running_);
-
-  // The extra scope is because we have two 'dcheck run on' thread checkers.
-  // This is a special case since it's safe to access variables on the current
-  // thread that normally are only touched on the process thread.
-  // Since we're not attached to the process thread and/or the process thread
-  // isn't running, it's OK to touch these variables here.
-  {
-    // This method is called on the ctor thread (usually from the dtor, unless
-    // a test calls it). It's a requirement that the function be called when
-    // the process thread is not running (a condition that's met at destruction
-    // time), and thanks to that, we don't need a lock to synchronize against
-    // it.
-    RTC_DCHECK_RUN_ON(&process_thread_checker_);
-
-    if (time_of_first_rtt_ms_ == -1 || num_avg_rtt_ < 1)
-      return;
-
-    int64_t elapsed_sec =
-        (clock_->TimeInMilliseconds() - time_of_first_rtt_ms_) / 1000;
-    if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
-      int64_t avg_rtt_ms = (sum_avg_rtt_ms_ + num_avg_rtt_ / 2) / num_avg_rtt_;
-      RTC_HISTOGRAM_COUNTS_10000(
-          "WebRTC.Video.AverageRoundTripTimeInMilliseconds", avg_rtt_ms);
-    }
-  }
-}
-
-}  // namespace webrtc
diff --git a/video/call_stats.h b/video/call_stats.h
deleted file mode 100644
index d198223..0000000
--- a/video/call_stats.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- *  Copyright (c) 2012 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.
- */
-
-#ifndef VIDEO_CALL_STATS_H_
-#define VIDEO_CALL_STATS_H_
-
-#include <list>
-#include <memory>
-
-#include "api/sequence_checker.h"
-#include "modules/include/module.h"
-#include "modules/include/module_common_types.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "rtc_base/synchronization/mutex.h"
-#include "system_wrappers/include/clock.h"
-
-namespace webrtc {
-
-// CallStats keeps track of statistics for a call.
-// TODO(webrtc:11489): Make call_stats_ not depend on ProcessThread and
-// make callbacks on the worker thread (TQ).
-class CallStats : public Module, public RtcpRttStats {
- public:
-  // Time interval for updating the observers.
-  static constexpr int64_t kUpdateIntervalMs = 1000;
-
-  CallStats(Clock* clock, ProcessThread* process_thread);
-  ~CallStats() override;
-
-  CallStats(const CallStats&) = delete;
-  CallStats& operator=(const CallStats&) = delete;
-
-  // Registers/deregisters a new observer to receive statistics updates.
-  // Must be called from the construction thread.
-  void RegisterStatsObserver(CallStatsObserver* observer);
-  void DeregisterStatsObserver(CallStatsObserver* observer);
-
-  // Expose `LastProcessedRtt()` from RtcpRttStats to the public interface, as
-  // it is the part of the API that is needed by direct users of CallStats.
-  // TODO(tommi): Threading or lifetime guarantees are not explicit in how
-  // CallStats is used as RtcpRttStats or how pointers are cached in a
-  // few different places (distributed via Call). It would be good to clarify
-  // from what thread/TQ calls to OnRttUpdate and LastProcessedRtt need to be
-  // allowed.
-  int64_t LastProcessedRtt() const override;
-
-  // Exposed for tests to test histogram support.
-  void UpdateHistogramsForTest() { UpdateHistograms(); }
-
-  // Helper struct keeping track of the time a rtt value is reported.
-  struct RttTime {
-    RttTime(int64_t new_rtt, int64_t rtt_time) : rtt(new_rtt), time(rtt_time) {}
-    const int64_t rtt;
-    const int64_t time;
-  };
-
- private:
-  // RtcpRttStats implementation.
-  void OnRttUpdate(int64_t rtt) override;
-
-  // Implements Module, to use the process thread.
-  int64_t TimeUntilNextProcess() override;
-  void Process() override;
-
-  // TODO(tommi): Use this to know when we're attached to the process thread?
-  // Alternatively, inject that pointer via the ctor since the call_stats
-  // test code, isn't using a processthread atm.
-  void ProcessThreadAttached(ProcessThread* process_thread) override;
-
-  // This method must only be called when the process thread is not
-  // running, and from the construction thread.
-  void UpdateHistograms();
-
-  Clock* const clock_;
-
-  // The last time 'Process' resulted in statistic update.
-  int64_t last_process_time_ RTC_GUARDED_BY(process_thread_checker_);
-  // The last RTT in the statistics update (zero if there is no valid estimate).
-  int64_t max_rtt_ms_ RTC_GUARDED_BY(process_thread_checker_);
-
-  // Accessed from random threads (seemingly). Consider atomic.
-  // `avg_rtt_ms_` is allowed to be read on the process thread without a lock.
-  // `avg_rtt_ms_lock_` must be held elsewhere for reading.
-  // `avg_rtt_ms_lock_` must be held on the process thread for writing.
-  int64_t avg_rtt_ms_;
-
-  // Protects `avg_rtt_ms_`.
-  mutable Mutex avg_rtt_ms_lock_;
-
-  // `sum_avg_rtt_ms_`, `num_avg_rtt_` and `time_of_first_rtt_ms_` are only used
-  // on the ProcessThread when running. When the Process Thread is not running,
-  // (and only then) they can be used in UpdateHistograms(), usually called from
-  // the dtor.
-  int64_t sum_avg_rtt_ms_ RTC_GUARDED_BY(process_thread_checker_);
-  int64_t num_avg_rtt_ RTC_GUARDED_BY(process_thread_checker_);
-  int64_t time_of_first_rtt_ms_ RTC_GUARDED_BY(process_thread_checker_);
-
-  // All Rtt reports within valid time interval, oldest first.
-  std::list<RttTime> reports_ RTC_GUARDED_BY(process_thread_checker_);
-
-  // Observers getting stats reports.
-  // When attached to ProcessThread, this is read-only. In order to allow
-  // modification, we detach from the process thread while the observer
-  // list is updated, to avoid races. This allows us to not require a lock
-  // for the observers_ list, which makes the most common case lock free.
-  std::list<CallStatsObserver*> observers_;
-
-  SequenceChecker construction_thread_checker_;
-  SequenceChecker process_thread_checker_;
-  ProcessThread* const process_thread_;
-  bool process_thread_running_ RTC_GUARDED_BY(construction_thread_checker_);
-};
-
-}  // namespace webrtc
-
-#endif  // VIDEO_CALL_STATS_H_
diff --git a/video/call_stats_unittest.cc b/video/call_stats_unittest.cc
deleted file mode 100644
index e85c4f8..0000000
--- a/video/call_stats_unittest.cc
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- *  Copyright (c) 2012 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 "video/call_stats.h"
-
-#include <memory>
-
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "modules/utility/include/process_thread.h"
-#include "rtc_base/event.h"
-#include "rtc_base/location.h"
-#include "rtc_base/task_utils/to_queued_task.h"
-#include "system_wrappers/include/metrics.h"
-#include "test/gmock.h"
-#include "test/gtest.h"
-
-using ::testing::AnyNumber;
-using ::testing::InvokeWithoutArgs;
-using ::testing::Return;
-
-namespace webrtc {
-
-class MockStatsObserver : public CallStatsObserver {
- public:
-  MockStatsObserver() {}
-  virtual ~MockStatsObserver() {}
-
-  MOCK_METHOD(void, OnRttUpdate, (int64_t, int64_t), (override));
-};
-
-class CallStatsTest : public ::testing::Test {
- public:
-  CallStatsTest() {
-    process_thread_->RegisterModule(&call_stats_, RTC_FROM_HERE);
-    process_thread_->Start();
-  }
-  ~CallStatsTest() override {
-    process_thread_->Stop();
-    process_thread_->DeRegisterModule(&call_stats_);
-  }
-
-  // Queues an rtt update call on the process thread.
-  void AsyncSimulateRttUpdate(int64_t rtt) {
-    RtcpRttStats* rtcp_rtt_stats = &call_stats_;
-    process_thread_->PostTask(ToQueuedTask(
-        [rtcp_rtt_stats, rtt] { rtcp_rtt_stats->OnRttUpdate(rtt); }));
-  }
-
- protected:
-  std::unique_ptr<ProcessThread> process_thread_{
-      ProcessThread::Create("CallStats")};
-  SimulatedClock fake_clock_{12345};
-  CallStats call_stats_{&fake_clock_, process_thread_.get()};
-};
-
-TEST_F(CallStatsTest, AddAndTriggerCallback) {
-  rtc::Event event;
-
-  static constexpr const int64_t kRtt = 25;
-
-  MockStatsObserver stats_observer;
-  EXPECT_CALL(stats_observer, OnRttUpdate(kRtt, kRtt))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([&event] { event.Set(); }));
-
-  RtcpRttStats* rtcp_rtt_stats = &call_stats_;
-  call_stats_.RegisterStatsObserver(&stats_observer);
-  EXPECT_EQ(-1, rtcp_rtt_stats->LastProcessedRtt());
-
-  AsyncSimulateRttUpdate(kRtt);
-
-  EXPECT_TRUE(event.Wait(1000));
-
-  EXPECT_EQ(kRtt, rtcp_rtt_stats->LastProcessedRtt());
-
-  call_stats_.DeregisterStatsObserver(&stats_observer);
-}
-
-TEST_F(CallStatsTest, ProcessTime) {
-  rtc::Event event;
-
-  static constexpr const int64_t kRtt = 100;
-  static constexpr const int64_t kRtt2 = 80;
-
-  RtcpRttStats* rtcp_rtt_stats = &call_stats_;
-
-  MockStatsObserver stats_observer;
-
-  EXPECT_CALL(stats_observer, OnRttUpdate(kRtt, kRtt))
-      .Times(2)
-      .WillOnce(InvokeWithoutArgs([this] {
-        // Advance clock and verify we get an update.
-        fake_clock_.AdvanceTimeMilliseconds(CallStats::kUpdateIntervalMs);
-      }))
-      .WillRepeatedly(InvokeWithoutArgs([this, rtcp_rtt_stats] {
-        rtcp_rtt_stats->OnRttUpdate(kRtt2);
-        // Advance clock just too little to get an update.
-        fake_clock_.AdvanceTimeMilliseconds(CallStats::kUpdateIntervalMs - 1);
-      }));
-
-  // In case you're reading this and wondering how this number is arrived at,
-  // please see comments in the ChangeRtt test that go into some detail.
-  static constexpr const int64_t kLastAvg = 94;
-  EXPECT_CALL(stats_observer, OnRttUpdate(kLastAvg, kRtt2))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([&event] { event.Set(); }));
-
-  call_stats_.RegisterStatsObserver(&stats_observer);
-
-  AsyncSimulateRttUpdate(kRtt);
-  EXPECT_TRUE(event.Wait(1000));
-
-  call_stats_.DeregisterStatsObserver(&stats_observer);
-}
-
-// Verify all observers get correct estimates and observers can be added and
-// removed.
-TEST_F(CallStatsTest, MultipleObservers) {
-  MockStatsObserver stats_observer_1;
-  call_stats_.RegisterStatsObserver(&stats_observer_1);
-  // Add the second observer twice, there should still be only one report to the
-  // observer.
-  MockStatsObserver stats_observer_2;
-  call_stats_.RegisterStatsObserver(&stats_observer_2);
-  call_stats_.RegisterStatsObserver(&stats_observer_2);
-
-  static constexpr const int64_t kRtt = 100;
-
-  // Verify both observers are updated.
-  rtc::Event ev1;
-  rtc::Event ev2;
-  EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt))
-      .Times(AnyNumber())
-      .WillOnce(InvokeWithoutArgs([&ev1] { ev1.Set(); }))
-      .WillRepeatedly(Return());
-  EXPECT_CALL(stats_observer_2, OnRttUpdate(kRtt, kRtt))
-      .Times(AnyNumber())
-      .WillOnce(InvokeWithoutArgs([&ev2] { ev2.Set(); }))
-      .WillRepeatedly(Return());
-  AsyncSimulateRttUpdate(kRtt);
-  ASSERT_TRUE(ev1.Wait(100));
-  ASSERT_TRUE(ev2.Wait(100));
-
-  // Deregister the second observer and verify update is only sent to the first
-  // observer.
-  call_stats_.DeregisterStatsObserver(&stats_observer_2);
-
-  EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt))
-      .Times(AnyNumber())
-      .WillOnce(InvokeWithoutArgs([&ev1] { ev1.Set(); }))
-      .WillRepeatedly(Return());
-  EXPECT_CALL(stats_observer_2, OnRttUpdate(kRtt, kRtt)).Times(0);
-  AsyncSimulateRttUpdate(kRtt);
-  ASSERT_TRUE(ev1.Wait(100));
-
-  // Deregister the first observer.
-  call_stats_.DeregisterStatsObserver(&stats_observer_1);
-
-  // Now make sure we don't get any callbacks.
-  EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt)).Times(0);
-  EXPECT_CALL(stats_observer_2, OnRttUpdate(kRtt, kRtt)).Times(0);
-  AsyncSimulateRttUpdate(kRtt);
-
-  // Force a call to Process().
-  process_thread_->WakeUp(&call_stats_);
-
-  // Flush the queue on the process thread to make sure we return after
-  // Process() has been called.
-  rtc::Event event;
-  process_thread_->PostTask(ToQueuedTask([&event] { event.Set(); }));
-  event.Wait(rtc::Event::kForever);
-}
-
-// Verify increasing and decreasing rtt triggers callbacks with correct values.
-TEST_F(CallStatsTest, ChangeRtt) {
-  // TODO(tommi): This test assumes things about how old reports are removed
-  // inside of call_stats.cc. The threshold ms value is 1500ms, but it's not
-  // clear here that how the clock is advanced, affects that algorithm and
-  // subsequently the average reported rtt.
-
-  MockStatsObserver stats_observer;
-  call_stats_.RegisterStatsObserver(&stats_observer);
-  RtcpRttStats* rtcp_rtt_stats = &call_stats_;
-
-  rtc::Event event;
-
-  static constexpr const int64_t kFirstRtt = 100;
-  static constexpr const int64_t kLowRtt = kFirstRtt - 20;
-  static constexpr const int64_t kHighRtt = kFirstRtt + 20;
-
-  EXPECT_CALL(stats_observer, OnRttUpdate(kFirstRtt, kFirstRtt))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([&rtcp_rtt_stats, this] {
-        fake_clock_.AdvanceTimeMilliseconds(1000);
-        rtcp_rtt_stats->OnRttUpdate(kHighRtt);  // Reported at T1 (1000ms).
-      }));
-
-  // TODO(tommi): This relies on the internal algorithms of call_stats.cc.
-  // There's a weight factor there (0.3), that weighs the previous average to
-  // the new one by 70%, so the number 103 in this case is arrived at like so:
-  // (100) / 1 * 0.7 + (100+120)/2 * 0.3 = 103
-  static constexpr const int64_t kAvgRtt1 = 103;
-  EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt1, kHighRtt))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([&rtcp_rtt_stats, this] {
-        // This interacts with an internal implementation detail in call_stats
-        // that decays the oldest rtt value. See more below.
-        fake_clock_.AdvanceTimeMilliseconds(1000);
-        rtcp_rtt_stats->OnRttUpdate(kLowRtt);  // Reported at T2 (2000ms).
-      }));
-
-  // Increase time enough for a new update, but not too much to make the
-  // rtt invalid. Report a lower rtt and verify the old/high value still is sent
-  // in the callback.
-
-  // Here, enough time must have passed in order to remove exactly the first
-  // report and nothing else (>1500ms has passed since the first rtt).
-  // So, this value is arrived by doing:
-  // (kAvgRtt1)/1 * 0.7 + (kHighRtt+kLowRtt)/2 * 0.3 = 102.1
-  static constexpr const int64_t kAvgRtt2 = 102;
-  EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt2, kHighRtt))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([this] {
-        // Advance time to make the high report invalid, the lower rtt should
-        // now be in the callback.
-        fake_clock_.AdvanceTimeMilliseconds(1000);
-      }));
-
-  static constexpr const int64_t kAvgRtt3 = 95;
-  EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt3, kLowRtt))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([&event] { event.Set(); }));
-
-  // Trigger the first rtt value and set off the chain of callbacks.
-  AsyncSimulateRttUpdate(kFirstRtt);  // Reported at T0 (0ms).
-  EXPECT_TRUE(event.Wait(1000));
-
-  call_stats_.DeregisterStatsObserver(&stats_observer);
-}
-
-TEST_F(CallStatsTest, LastProcessedRtt) {
-  rtc::Event event;
-  MockStatsObserver stats_observer;
-  call_stats_.RegisterStatsObserver(&stats_observer);
-  RtcpRttStats* rtcp_rtt_stats = &call_stats_;
-
-  static constexpr const int64_t kRttLow = 10;
-  static constexpr const int64_t kRttHigh = 30;
-  // The following two average numbers dependend on average + weight
-  // calculations in call_stats.cc.
-  static constexpr const int64_t kAvgRtt1 = 13;
-  static constexpr const int64_t kAvgRtt2 = 15;
-
-  EXPECT_CALL(stats_observer, OnRttUpdate(kRttLow, kRttLow))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([rtcp_rtt_stats] {
-        EXPECT_EQ(kRttLow, rtcp_rtt_stats->LastProcessedRtt());
-        // Don't advance the clock to make sure that low and high rtt values
-        // are associated with the same time stamp.
-        rtcp_rtt_stats->OnRttUpdate(kRttHigh);
-      }));
-
-  EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt1, kRttHigh))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([rtcp_rtt_stats, this] {
-        EXPECT_EQ(kAvgRtt1, rtcp_rtt_stats->LastProcessedRtt());
-        fake_clock_.AdvanceTimeMilliseconds(CallStats::kUpdateIntervalMs);
-        rtcp_rtt_stats->OnRttUpdate(kRttLow);
-        rtcp_rtt_stats->OnRttUpdate(kRttHigh);
-      }));
-
-  EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt2, kRttHigh))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs([rtcp_rtt_stats, &event] {
-        EXPECT_EQ(kAvgRtt2, rtcp_rtt_stats->LastProcessedRtt());
-        event.Set();
-      }));
-
-  // Set a first values and verify that LastProcessedRtt initially returns the
-  // average rtt.
-  fake_clock_.AdvanceTimeMilliseconds(CallStats::kUpdateIntervalMs);
-  AsyncSimulateRttUpdate(kRttLow);
-  EXPECT_TRUE(event.Wait(1000));
-  EXPECT_EQ(kAvgRtt2, rtcp_rtt_stats->LastProcessedRtt());
-
-  call_stats_.DeregisterStatsObserver(&stats_observer);
-}
-
-TEST_F(CallStatsTest, ProducesHistogramMetrics) {
-  metrics::Reset();
-  rtc::Event event;
-  static constexpr const int64_t kRtt = 123;
-  MockStatsObserver stats_observer;
-  call_stats_.RegisterStatsObserver(&stats_observer);
-  EXPECT_CALL(stats_observer, OnRttUpdate(kRtt, kRtt))
-      .Times(AnyNumber())
-      .WillRepeatedly(InvokeWithoutArgs([&event] { event.Set(); }));
-
-  AsyncSimulateRttUpdate(kRtt);
-  EXPECT_TRUE(event.Wait(1000));
-  fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds *
-                                      CallStats::kUpdateIntervalMs);
-  AsyncSimulateRttUpdate(kRtt);
-  EXPECT_TRUE(event.Wait(1000));
-
-  call_stats_.DeregisterStatsObserver(&stats_observer);
-
-  process_thread_->Stop();
-  call_stats_.UpdateHistogramsForTest();
-
-  EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                          "WebRTC.Video.AverageRoundTripTimeInMilliseconds"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.AverageRoundTripTimeInMilliseconds",
-                            kRtt));
-}
-
-}  // namespace webrtc
diff --git a/video/receive_statistics_proxy.cc b/video/receive_statistics_proxy.cc
deleted file mode 100644
index 06873d8..0000000
--- a/video/receive_statistics_proxy.cc
+++ /dev/null
@@ -1,945 +0,0 @@
-/*
- *  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 "video/receive_statistics_proxy.h"
-
-#include <algorithm>
-#include <cmath>
-#include <utility>
-
-#include "modules/video_coding/include/video_codec_interface.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/strings/string_builder.h"
-#include "rtc_base/time_utils.h"
-#include "system_wrappers/include/clock.h"
-#include "system_wrappers/include/metrics.h"
-
-namespace webrtc {
-namespace {
-// Periodic time interval for processing samples for `freq_offset_counter_`.
-const int64_t kFreqOffsetProcessIntervalMs = 40000;
-
-// Configuration for bad call detection.
-const int kBadCallMinRequiredSamples = 10;
-const int kMinSampleLengthMs = 990;
-const int kNumMeasurements = 10;
-const int kNumMeasurementsVariance = kNumMeasurements * 1.5;
-const float kBadFraction = 0.8f;
-// For fps:
-// Low means low enough to be bad, high means high enough to be good
-const int kLowFpsThreshold = 12;
-const int kHighFpsThreshold = 14;
-// For qp and fps variance:
-// Low means low enough to be good, high means high enough to be bad
-const int kLowQpThresholdVp8 = 60;
-const int kHighQpThresholdVp8 = 70;
-const int kLowVarianceThreshold = 1;
-const int kHighVarianceThreshold = 2;
-
-// Some metrics are reported as a maximum over this period.
-// This should be synchronized with a typical getStats polling interval in
-// the clients.
-const int kMovingMaxWindowMs = 1000;
-
-// How large window we use to calculate the framerate/bitrate.
-const int kRateStatisticsWindowSizeMs = 1000;
-
-// Some sane ballpark estimate for maximum common value of inter-frame delay.
-// Values below that will be stored explicitly in the array,
-// values above - in the map.
-const int kMaxCommonInterframeDelayMs = 500;
-
-const char* UmaPrefixForContentType(VideoContentType content_type) {
-  if (videocontenttypehelpers::IsScreenshare(content_type))
-    return "WebRTC.Video.Screenshare";
-  return "WebRTC.Video";
-}
-
-std::string UmaSuffixForContentType(VideoContentType content_type) {
-  char ss_buf[1024];
-  rtc::SimpleStringBuilder ss(ss_buf);
-  int simulcast_id = videocontenttypehelpers::GetSimulcastId(content_type);
-  if (simulcast_id > 0) {
-    ss << ".S" << simulcast_id - 1;
-  }
-  int experiment_id = videocontenttypehelpers::GetExperimentId(content_type);
-  if (experiment_id > 0) {
-    ss << ".ExperimentGroup" << experiment_id - 1;
-  }
-  return ss.str();
-}
-
-bool EnableDecodeTimeHistogram(const FieldTrialsView* field_trials) {
-  if (field_trials == nullptr) {
-    return true;
-  }
-  return !field_trials->IsEnabled("WebRTC-DecodeTimeHistogramsKillSwitch");
-}
-
-}  // namespace
-
-ReceiveStatisticsProxy::ReceiveStatisticsProxy(
-    uint32_t remote_ssrc,
-    Clock* clock,
-    const FieldTrialsView* field_trials)
-    : clock_(clock),
-      start_ms_(clock->TimeInMilliseconds()),
-      enable_decode_time_histograms_(EnableDecodeTimeHistogram(field_trials)),
-      last_sample_time_(clock->TimeInMilliseconds()),
-      fps_threshold_(kLowFpsThreshold,
-                     kHighFpsThreshold,
-                     kBadFraction,
-                     kNumMeasurements),
-      qp_threshold_(kLowQpThresholdVp8,
-                    kHighQpThresholdVp8,
-                    kBadFraction,
-                    kNumMeasurements),
-      variance_threshold_(kLowVarianceThreshold,
-                          kHighVarianceThreshold,
-                          kBadFraction,
-                          kNumMeasurementsVariance),
-      num_bad_states_(0),
-      num_certain_states_(0),
-      // 1000ms window, scale 1000 for ms to s.
-      decode_fps_estimator_(1000, 1000),
-      renders_fps_estimator_(1000, 1000),
-      render_fps_tracker_(100, 10u),
-      render_pixel_tracker_(100, 10u),
-      video_quality_observer_(
-          new VideoQualityObserver(VideoContentType::UNSPECIFIED)),
-      interframe_delay_max_moving_(kMovingMaxWindowMs),
-      freq_offset_counter_(clock, nullptr, kFreqOffsetProcessIntervalMs),
-      avg_rtt_ms_(0),
-      last_content_type_(VideoContentType::UNSPECIFIED),
-      last_codec_type_(kVideoCodecVP8),
-      num_delayed_frames_rendered_(0),
-      sum_missed_render_deadline_ms_(0),
-      timing_frame_info_counter_(kMovingMaxWindowMs) {
-  decode_thread_.Detach();
-  network_thread_.Detach();
-  stats_.ssrc = remote_ssrc;
-}
-
-void ReceiveStatisticsProxy::UpdateHistograms(
-    absl::optional<int> fraction_lost,
-    const StreamDataCounters& rtp_stats,
-    const StreamDataCounters* rtx_stats) {
-  // Not actually running on the decoder thread, but must be called after
-  // DecoderThreadStopped, which detaches the thread checker. It is therefore
-  // safe to access `qp_counters_`, which were updated on the decode thread
-  // earlier.
-  RTC_DCHECK_RUN_ON(&decode_thread_);
-
-  MutexLock lock(&mutex_);
-
-  char log_stream_buf[8 * 1024];
-  rtc::SimpleStringBuilder log_stream(log_stream_buf);
-  int stream_duration_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
-  if (stats_.frame_counts.key_frames > 0 ||
-      stats_.frame_counts.delta_frames > 0) {
-    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.ReceiveStreamLifetimeInSeconds",
-                                stream_duration_sec);
-    log_stream << "WebRTC.Video.ReceiveStreamLifetimeInSeconds "
-               << stream_duration_sec << '\n';
-  }
-
-  log_stream << "Frames decoded " << stats_.frames_decoded << '\n';
-
-  if (num_unique_frames_) {
-    int num_dropped_frames = *num_unique_frames_ - stats_.frames_decoded;
-    RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DroppedFrames.Receiver",
-                              num_dropped_frames);
-    log_stream << "WebRTC.Video.DroppedFrames.Receiver " << num_dropped_frames
-               << '\n';
-  }
-
-  if (fraction_lost && stream_duration_sec >= metrics::kMinRunTimeInSeconds) {
-    RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.ReceivedPacketsLostInPercent",
-                             *fraction_lost);
-    log_stream << "WebRTC.Video.ReceivedPacketsLostInPercent " << *fraction_lost
-               << '\n';
-  }
-
-  if (first_decoded_frame_time_ms_) {
-    const int64_t elapsed_ms =
-        (clock_->TimeInMilliseconds() - *first_decoded_frame_time_ms_);
-    if (elapsed_ms >=
-        metrics::kMinRunTimeInSeconds * rtc::kNumMillisecsPerSec) {
-      int decoded_fps = static_cast<int>(
-          (stats_.frames_decoded * 1000.0f / elapsed_ms) + 0.5f);
-      RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.DecodedFramesPerSecond",
-                               decoded_fps);
-      log_stream << "WebRTC.Video.DecodedFramesPerSecond " << decoded_fps
-                 << '\n';
-
-      const uint32_t frames_rendered = stats_.frames_rendered;
-      if (frames_rendered > 0) {
-        RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DelayedFramesToRenderer",
-                                 static_cast<int>(num_delayed_frames_rendered_ *
-                                                  100 / frames_rendered));
-        if (num_delayed_frames_rendered_ > 0) {
-          RTC_HISTOGRAM_COUNTS_1000(
-              "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs",
-              static_cast<int>(sum_missed_render_deadline_ms_ /
-                               num_delayed_frames_rendered_));
-        }
-      }
-    }
-  }
-
-  const int kMinRequiredSamples = 200;
-  int samples = static_cast<int>(render_fps_tracker_.TotalSampleCount());
-  if (samples >= kMinRequiredSamples) {
-    int rendered_fps = round(render_fps_tracker_.ComputeTotalRate());
-    RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.RenderFramesPerSecond",
-                             rendered_fps);
-    log_stream << "WebRTC.Video.RenderFramesPerSecond " << rendered_fps << '\n';
-    RTC_HISTOGRAM_COUNTS_100000(
-        "WebRTC.Video.RenderSqrtPixelsPerSecond",
-        round(render_pixel_tracker_.ComputeTotalRate()));
-  }
-
-  absl::optional<int> sync_offset_ms =
-      sync_offset_counter_.Avg(kMinRequiredSamples);
-  if (sync_offset_ms) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs",
-                               *sync_offset_ms);
-    log_stream << "WebRTC.Video.AVSyncOffsetInMs " << *sync_offset_ms << '\n';
-  }
-  AggregatedStats freq_offset_stats = freq_offset_counter_.GetStats();
-  if (freq_offset_stats.num_samples > 0) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtpToNtpFreqOffsetInKhz",
-                               freq_offset_stats.average);
-    log_stream << "WebRTC.Video.RtpToNtpFreqOffsetInKhz "
-               << freq_offset_stats.ToString() << '\n';
-  }
-
-  int num_total_frames =
-      stats_.frame_counts.key_frames + stats_.frame_counts.delta_frames;
-  if (num_total_frames >= kMinRequiredSamples) {
-    int num_key_frames = stats_.frame_counts.key_frames;
-    int key_frames_permille =
-        (num_key_frames * 1000 + num_total_frames / 2) / num_total_frames;
-    RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesReceivedInPermille",
-                              key_frames_permille);
-    log_stream << "WebRTC.Video.KeyFramesReceivedInPermille "
-               << key_frames_permille << '\n';
-  }
-
-  absl::optional<int> qp = qp_counters_.vp8.Avg(kMinRequiredSamples);
-  if (qp) {
-    RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", *qp);
-    log_stream << "WebRTC.Video.Decoded.Vp8.Qp " << *qp << '\n';
-  }
-  absl::optional<int> decode_ms = decode_time_counter_.Avg(kMinRequiredSamples);
-  if (decode_ms) {
-    RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", *decode_ms);
-    log_stream << "WebRTC.Video.DecodeTimeInMs " << *decode_ms << '\n';
-  }
-  absl::optional<int> jb_delay_ms =
-      jitter_buffer_delay_counter_.Avg(kMinRequiredSamples);
-  if (jb_delay_ms) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs",
-                               *jb_delay_ms);
-    log_stream << "WebRTC.Video.JitterBufferDelayInMs " << *jb_delay_ms << '\n';
-  }
-
-  absl::optional<int> target_delay_ms =
-      target_delay_counter_.Avg(kMinRequiredSamples);
-  if (target_delay_ms) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs",
-                               *target_delay_ms);
-    log_stream << "WebRTC.Video.TargetDelayInMs " << *target_delay_ms << '\n';
-  }
-  absl::optional<int> current_delay_ms =
-      current_delay_counter_.Avg(kMinRequiredSamples);
-  if (current_delay_ms) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.CurrentDelayInMs",
-                               *current_delay_ms);
-    log_stream << "WebRTC.Video.CurrentDelayInMs " << *current_delay_ms << '\n';
-  }
-  absl::optional<int> delay_ms = delay_counter_.Avg(kMinRequiredSamples);
-  if (delay_ms)
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.OnewayDelayInMs", *delay_ms);
-
-  // Aggregate content_specific_stats_ by removing experiment or simulcast
-  // information;
-  std::map<VideoContentType, ContentSpecificStats> aggregated_stats;
-  for (const auto& it : content_specific_stats_) {
-    // Calculate simulcast specific metrics (".S0" ... ".S2" suffixes).
-    VideoContentType content_type = it.first;
-    if (videocontenttypehelpers::GetSimulcastId(content_type) > 0) {
-      // Aggregate on experiment id.
-      videocontenttypehelpers::SetExperimentId(&content_type, 0);
-      aggregated_stats[content_type].Add(it.second);
-    }
-    // Calculate experiment specific metrics (".ExperimentGroup[0-7]" suffixes).
-    content_type = it.first;
-    if (videocontenttypehelpers::GetExperimentId(content_type) > 0) {
-      // Aggregate on simulcast id.
-      videocontenttypehelpers::SetSimulcastId(&content_type, 0);
-      aggregated_stats[content_type].Add(it.second);
-    }
-    // Calculate aggregated metrics (no suffixes. Aggregated on everything).
-    content_type = it.first;
-    videocontenttypehelpers::SetSimulcastId(&content_type, 0);
-    videocontenttypehelpers::SetExperimentId(&content_type, 0);
-    aggregated_stats[content_type].Add(it.second);
-  }
-
-  for (const auto& it : aggregated_stats) {
-    // For the metric Foo we report the following slices:
-    // WebRTC.Video.Foo,
-    // WebRTC.Video.Screenshare.Foo,
-    // WebRTC.Video.Foo.S[0-3],
-    // WebRTC.Video.Foo.ExperimentGroup[0-7],
-    // WebRTC.Video.Screenshare.Foo.S[0-3],
-    // WebRTC.Video.Screenshare.Foo.ExperimentGroup[0-7].
-    auto content_type = it.first;
-    auto stats = it.second;
-    std::string uma_prefix = UmaPrefixForContentType(content_type);
-    std::string uma_suffix = UmaSuffixForContentType(content_type);
-    // Metrics can be sliced on either simulcast id or experiment id but not
-    // both.
-    RTC_DCHECK(videocontenttypehelpers::GetExperimentId(content_type) == 0 ||
-               videocontenttypehelpers::GetSimulcastId(content_type) == 0);
-
-    absl::optional<int> e2e_delay_ms =
-        stats.e2e_delay_counter.Avg(kMinRequiredSamples);
-    if (e2e_delay_ms) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-          uma_prefix + ".EndToEndDelayInMs" + uma_suffix, *e2e_delay_ms);
-      log_stream << uma_prefix << ".EndToEndDelayInMs" << uma_suffix << " "
-                 << *e2e_delay_ms << '\n';
-    }
-    absl::optional<int> e2e_delay_max_ms = stats.e2e_delay_counter.Max();
-    if (e2e_delay_max_ms && e2e_delay_ms) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_100000(
-          uma_prefix + ".EndToEndDelayMaxInMs" + uma_suffix, *e2e_delay_max_ms);
-      log_stream << uma_prefix << ".EndToEndDelayMaxInMs" << uma_suffix << " "
-                 << *e2e_delay_max_ms << '\n';
-    }
-    absl::optional<int> interframe_delay_ms =
-        stats.interframe_delay_counter.Avg(kMinRequiredSamples);
-    if (interframe_delay_ms) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-          uma_prefix + ".InterframeDelayInMs" + uma_suffix,
-          *interframe_delay_ms);
-      log_stream << uma_prefix << ".InterframeDelayInMs" << uma_suffix << " "
-                 << *interframe_delay_ms << '\n';
-    }
-    absl::optional<int> interframe_delay_max_ms =
-        stats.interframe_delay_counter.Max();
-    if (interframe_delay_max_ms && interframe_delay_ms) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-          uma_prefix + ".InterframeDelayMaxInMs" + uma_suffix,
-          *interframe_delay_max_ms);
-      log_stream << uma_prefix << ".InterframeDelayMaxInMs" << uma_suffix << " "
-                 << *interframe_delay_max_ms << '\n';
-    }
-
-    absl::optional<uint32_t> interframe_delay_95p_ms =
-        stats.interframe_delay_percentiles.GetPercentile(0.95f);
-    if (interframe_delay_95p_ms && interframe_delay_ms != -1) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-          uma_prefix + ".InterframeDelay95PercentileInMs" + uma_suffix,
-          *interframe_delay_95p_ms);
-      log_stream << uma_prefix << ".InterframeDelay95PercentileInMs"
-                 << uma_suffix << " " << *interframe_delay_95p_ms << '\n';
-    }
-
-    absl::optional<int> width = stats.received_width.Avg(kMinRequiredSamples);
-    if (width) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-          uma_prefix + ".ReceivedWidthInPixels" + uma_suffix, *width);
-      log_stream << uma_prefix << ".ReceivedWidthInPixels" << uma_suffix << " "
-                 << *width << '\n';
-    }
-
-    absl::optional<int> height = stats.received_height.Avg(kMinRequiredSamples);
-    if (height) {
-      RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-          uma_prefix + ".ReceivedHeightInPixels" + uma_suffix, *height);
-      log_stream << uma_prefix << ".ReceivedHeightInPixels" << uma_suffix << " "
-                 << *height << '\n';
-    }
-
-    if (content_type != VideoContentType::UNSPECIFIED) {
-      // Don't report these 3 metrics unsliced, as more precise variants
-      // are reported separately in this method.
-      float flow_duration_sec = stats.flow_duration_ms / 1000.0;
-      if (flow_duration_sec >= metrics::kMinRunTimeInSeconds) {
-        int media_bitrate_kbps = static_cast<int>(stats.total_media_bytes * 8 /
-                                                  flow_duration_sec / 1000);
-        RTC_HISTOGRAM_COUNTS_SPARSE_10000(
-            uma_prefix + ".MediaBitrateReceivedInKbps" + uma_suffix,
-            media_bitrate_kbps);
-        log_stream << uma_prefix << ".MediaBitrateReceivedInKbps" << uma_suffix
-                   << " " << media_bitrate_kbps << '\n';
-      }
-
-      int num_total_frames2 =
-          stats.frame_counts.key_frames + stats.frame_counts.delta_frames;
-      if (num_total_frames2 >= kMinRequiredSamples) {
-        int num_key_frames = stats.frame_counts.key_frames;
-        int key_frames_permille =
-            (num_key_frames * 1000 + num_total_frames2 / 2) / num_total_frames2;
-        RTC_HISTOGRAM_COUNTS_SPARSE_1000(
-            uma_prefix + ".KeyFramesReceivedInPermille" + uma_suffix,
-            key_frames_permille);
-        log_stream << uma_prefix << ".KeyFramesReceivedInPermille" << uma_suffix
-                   << " " << key_frames_permille << '\n';
-      }
-
-      absl::optional<int> qp2 = stats.qp_counter.Avg(kMinRequiredSamples);
-      if (qp2) {
-        RTC_HISTOGRAM_COUNTS_SPARSE_200(
-            uma_prefix + ".Decoded.Vp8.Qp" + uma_suffix, *qp2);
-        log_stream << uma_prefix << ".Decoded.Vp8.Qp" << uma_suffix << " "
-                   << *qp2 << '\n';
-      }
-    }
-  }
-
-  StreamDataCounters rtp_rtx_stats = rtp_stats;
-  if (rtx_stats)
-    rtp_rtx_stats.Add(*rtx_stats);
-  int64_t elapsed_sec =
-      rtp_rtx_stats.TimeSinceFirstPacketInMs(clock_->TimeInMilliseconds()) /
-      1000;
-  if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.BitrateReceivedInKbps",
-        static_cast<int>(rtp_rtx_stats.transmitted.TotalBytes() * 8 /
-                         elapsed_sec / 1000));
-    int media_bitrate_kbs = static_cast<int>(rtp_stats.MediaPayloadBytes() * 8 /
-                                             elapsed_sec / 1000);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.MediaBitrateReceivedInKbps",
-                               media_bitrate_kbs);
-    log_stream << "WebRTC.Video.MediaBitrateReceivedInKbps "
-               << media_bitrate_kbs << '\n';
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.PaddingBitrateReceivedInKbps",
-        static_cast<int>(rtp_rtx_stats.transmitted.padding_bytes * 8 /
-                         elapsed_sec / 1000));
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.RetransmittedBitrateReceivedInKbps",
-        static_cast<int>(rtp_rtx_stats.retransmitted.TotalBytes() * 8 /
-                         elapsed_sec / 1000));
-    if (rtx_stats) {
-      RTC_HISTOGRAM_COUNTS_10000(
-          "WebRTC.Video.RtxBitrateReceivedInKbps",
-          static_cast<int>(rtx_stats->transmitted.TotalBytes() * 8 /
-                           elapsed_sec / 1000));
-    }
-    const RtcpPacketTypeCounter& counters = stats_.rtcp_packet_type_counts;
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.NackPacketsSentPerMinute",
-                               counters.nack_packets * 60 / elapsed_sec);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FirPacketsSentPerMinute",
-                               counters.fir_packets * 60 / elapsed_sec);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PliPacketsSentPerMinute",
-                               counters.pli_packets * 60 / elapsed_sec);
-    if (counters.nack_requests > 0) {
-      RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.UniqueNackRequestsSentInPercent",
-                               counters.UniqueNackRequestsInPercent());
-    }
-  }
-
-  if (num_certain_states_ >= kBadCallMinRequiredSamples) {
-    RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.Any",
-                             100 * num_bad_states_ / num_certain_states_);
-  }
-  absl::optional<double> fps_fraction =
-      fps_threshold_.FractionHigh(kBadCallMinRequiredSamples);
-  if (fps_fraction) {
-    RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.FrameRate",
-                             static_cast<int>(100 * (1 - *fps_fraction)));
-  }
-  absl::optional<double> variance_fraction =
-      variance_threshold_.FractionHigh(kBadCallMinRequiredSamples);
-  if (variance_fraction) {
-    RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.FrameRateVariance",
-                             static_cast<int>(100 * *variance_fraction));
-  }
-  absl::optional<double> qp_fraction =
-      qp_threshold_.FractionHigh(kBadCallMinRequiredSamples);
-  if (qp_fraction) {
-    RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.Qp",
-                             static_cast<int>(100 * *qp_fraction));
-  }
-
-  RTC_LOG(LS_INFO) << log_stream.str();
-  video_quality_observer_->UpdateHistograms();
-}
-
-void ReceiveStatisticsProxy::QualitySample() {
-  int64_t now = clock_->TimeInMilliseconds();
-  if (last_sample_time_ + kMinSampleLengthMs > now)
-    return;
-
-  double fps =
-      render_fps_tracker_.ComputeRateForInterval(now - last_sample_time_);
-  absl::optional<int> qp = qp_sample_.Avg(1);
-
-  bool prev_fps_bad = !fps_threshold_.IsHigh().value_or(true);
-  bool prev_qp_bad = qp_threshold_.IsHigh().value_or(false);
-  bool prev_variance_bad = variance_threshold_.IsHigh().value_or(false);
-  bool prev_any_bad = prev_fps_bad || prev_qp_bad || prev_variance_bad;
-
-  fps_threshold_.AddMeasurement(static_cast<int>(fps));
-  if (qp)
-    qp_threshold_.AddMeasurement(*qp);
-  absl::optional<double> fps_variance_opt = fps_threshold_.CalculateVariance();
-  double fps_variance = fps_variance_opt.value_or(0);
-  if (fps_variance_opt) {
-    variance_threshold_.AddMeasurement(static_cast<int>(fps_variance));
-  }
-
-  bool fps_bad = !fps_threshold_.IsHigh().value_or(true);
-  bool qp_bad = qp_threshold_.IsHigh().value_or(false);
-  bool variance_bad = variance_threshold_.IsHigh().value_or(false);
-  bool any_bad = fps_bad || qp_bad || variance_bad;
-
-  if (!prev_any_bad && any_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (any) start: " << now;
-  } else if (prev_any_bad && !any_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (any) end: " << now;
-  }
-
-  if (!prev_fps_bad && fps_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (fps) start: " << now;
-  } else if (prev_fps_bad && !fps_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (fps) end: " << now;
-  }
-
-  if (!prev_qp_bad && qp_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (qp) start: " << now;
-  } else if (prev_qp_bad && !qp_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (qp) end: " << now;
-  }
-
-  if (!prev_variance_bad && variance_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (variance) start: " << now;
-  } else if (prev_variance_bad && !variance_bad) {
-    RTC_LOG(LS_INFO) << "Bad call (variance) end: " << now;
-  }
-
-  RTC_LOG(LS_VERBOSE) << "SAMPLE: sample_length: " << (now - last_sample_time_)
-                      << " fps: " << fps << " fps_bad: " << fps_bad
-                      << " qp: " << qp.value_or(-1) << " qp_bad: " << qp_bad
-                      << " variance_bad: " << variance_bad
-                      << " fps_variance: " << fps_variance;
-
-  last_sample_time_ = now;
-  qp_sample_.Reset();
-
-  if (fps_threshold_.IsHigh() || variance_threshold_.IsHigh() ||
-      qp_threshold_.IsHigh()) {
-    if (any_bad)
-      ++num_bad_states_;
-    ++num_certain_states_;
-  }
-}
-
-void ReceiveStatisticsProxy::UpdateFramerate(int64_t now_ms) const {
-  int64_t old_frames_ms = now_ms - kRateStatisticsWindowSizeMs;
-  while (!frame_window_.empty() &&
-         frame_window_.begin()->first < old_frames_ms) {
-    frame_window_.erase(frame_window_.begin());
-  }
-
-  size_t framerate =
-      (frame_window_.size() * 1000 + 500) / kRateStatisticsWindowSizeMs;
-  stats_.network_frame_rate = static_cast<int>(framerate);
-}
-
-void ReceiveStatisticsProxy::UpdateDecodeTimeHistograms(
-    int width,
-    int height,
-    int decode_time_ms) const {
-  bool is_4k = (width == 3840 || width == 4096) && height == 2160;
-  bool is_hd = width == 1920 && height == 1080;
-  // Only update histograms for 4k/HD and VP9/H264.
-  if ((is_4k || is_hd) && (last_codec_type_ == kVideoCodecVP9 ||
-                           last_codec_type_ == kVideoCodecH264)) {
-    const std::string kDecodeTimeUmaPrefix =
-        "WebRTC.Video.DecodeTimePerFrameInMs.";
-
-    // Each histogram needs its own line for it to not be reused in the wrong
-    // way when the format changes.
-    if (last_codec_type_ == kVideoCodecVP9) {
-      bool is_sw_decoder =
-          stats_.decoder_implementation_name.compare(0, 6, "libvpx") == 0;
-      if (is_4k) {
-        if (is_sw_decoder)
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.4k.Sw",
-                                    decode_time_ms);
-        else
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.4k.Hw",
-                                    decode_time_ms);
-      } else {
-        if (is_sw_decoder)
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.Hd.Sw",
-                                    decode_time_ms);
-        else
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.Hd.Hw",
-                                    decode_time_ms);
-      }
-    } else {
-      bool is_sw_decoder =
-          stats_.decoder_implementation_name.compare(0, 6, "FFmpeg") == 0;
-      if (is_4k) {
-        if (is_sw_decoder)
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.4k.Sw",
-                                    decode_time_ms);
-        else
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.4k.Hw",
-                                    decode_time_ms);
-
-      } else {
-        if (is_sw_decoder)
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.Hd.Sw",
-                                    decode_time_ms);
-        else
-          RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.Hd.Hw",
-                                    decode_time_ms);
-      }
-    }
-  }
-}
-
-absl::optional<int64_t>
-ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs(
-    int64_t now_ms) const {
-  if (!last_estimated_playout_ntp_timestamp_ms_ ||
-      !last_estimated_playout_time_ms_) {
-    return absl::nullopt;
-  }
-  int64_t elapsed_ms = now_ms - *last_estimated_playout_time_ms_;
-  return *last_estimated_playout_ntp_timestamp_ms_ + elapsed_ms;
-}
-
-VideoReceiveStreamInterface::Stats ReceiveStatisticsProxy::GetStats() const {
-  MutexLock lock(&mutex_);
-  // Get current frame rates here, as only updating them on new frames prevents
-  // us from ever correctly displaying frame rate of 0.
-  int64_t now_ms = clock_->TimeInMilliseconds();
-  UpdateFramerate(now_ms);
-  stats_.render_frame_rate = renders_fps_estimator_.Rate(now_ms).value_or(0);
-  stats_.decode_frame_rate = decode_fps_estimator_.Rate(now_ms).value_or(0);
-  stats_.interframe_delay_max_ms =
-      interframe_delay_max_moving_.Max(now_ms).value_or(-1);
-  stats_.freeze_count = video_quality_observer_->NumFreezes();
-  stats_.pause_count = video_quality_observer_->NumPauses();
-  stats_.total_freezes_duration_ms =
-      video_quality_observer_->TotalFreezesDurationMs();
-  stats_.total_pauses_duration_ms =
-      video_quality_observer_->TotalPausesDurationMs();
-  stats_.total_frames_duration_ms =
-      video_quality_observer_->TotalFramesDurationMs();
-  stats_.sum_squared_frame_durations =
-      video_quality_observer_->SumSquaredFrameDurationsSec();
-  stats_.content_type = last_content_type_;
-  stats_.timing_frame_info = timing_frame_info_counter_.Max(now_ms);
-  stats_.jitter_buffer_delay_seconds =
-      static_cast<double>(current_delay_counter_.Sum(1).value_or(0)) /
-      rtc::kNumMillisecsPerSec;
-  stats_.jitter_buffer_emitted_count = current_delay_counter_.NumSamples();
-  stats_.estimated_playout_ntp_timestamp_ms =
-      GetCurrentEstimatedPlayoutNtpTimestampMs(now_ms);
-  return stats_;
-}
-
-void ReceiveStatisticsProxy::OnIncomingPayloadType(int payload_type) {
-  MutexLock lock(&mutex_);
-  stats_.current_payload_type = payload_type;
-}
-
-void ReceiveStatisticsProxy::OnDecoderImplementationName(
-    const char* implementation_name) {
-  MutexLock lock(&mutex_);
-  stats_.decoder_implementation_name = implementation_name;
-}
-
-void ReceiveStatisticsProxy::OnFrameBufferTimingsUpdated(
-    int max_decode_ms,
-    int current_delay_ms,
-    int target_delay_ms,
-    int jitter_buffer_ms,
-    int min_playout_delay_ms,
-    int render_delay_ms) {
-  MutexLock lock(&mutex_);
-  stats_.max_decode_ms = max_decode_ms;
-  stats_.current_delay_ms = current_delay_ms;
-  stats_.target_delay_ms = target_delay_ms;
-  stats_.jitter_buffer_ms = jitter_buffer_ms;
-  stats_.min_playout_delay_ms = min_playout_delay_ms;
-  stats_.render_delay_ms = render_delay_ms;
-  jitter_buffer_delay_counter_.Add(jitter_buffer_ms);
-  target_delay_counter_.Add(target_delay_ms);
-  current_delay_counter_.Add(current_delay_ms);
-  // Network delay (rtt/2) + target_delay_ms (jitter delay + decode time +
-  // render delay).
-  delay_counter_.Add(target_delay_ms + avg_rtt_ms_ / 2);
-}
-
-void ReceiveStatisticsProxy::OnUniqueFramesCounted(int num_unique_frames) {
-  MutexLock lock(&mutex_);
-  num_unique_frames_.emplace(num_unique_frames);
-}
-
-void ReceiveStatisticsProxy::OnTimingFrameInfoUpdated(
-    const TimingFrameInfo& info) {
-  MutexLock lock(&mutex_);
-  if (info.flags != VideoSendTiming::kInvalid) {
-    int64_t now_ms = clock_->TimeInMilliseconds();
-    timing_frame_info_counter_.Add(info, now_ms);
-  }
-
-  // Measure initial decoding latency between the first frame arriving and the
-  // first frame being decoded.
-  if (!first_frame_received_time_ms_.has_value()) {
-    first_frame_received_time_ms_ = info.receive_finish_ms;
-  }
-  if (stats_.first_frame_received_to_decoded_ms == -1 &&
-      first_decoded_frame_time_ms_) {
-    stats_.first_frame_received_to_decoded_ms =
-        *first_decoded_frame_time_ms_ - *first_frame_received_time_ms_;
-  }
-}
-
-void ReceiveStatisticsProxy::RtcpPacketTypesCounterUpdated(
-    uint32_t ssrc,
-    const RtcpPacketTypeCounter& packet_counter) {
-  MutexLock lock(&mutex_);
-  if (stats_.ssrc != ssrc)
-    return;
-  stats_.rtcp_packet_type_counts = packet_counter;
-}
-
-void ReceiveStatisticsProxy::OnCname(uint32_t ssrc, absl::string_view cname) {
-  MutexLock lock(&mutex_);
-  // TODO(pbos): Handle both local and remote ssrcs here and RTC_DCHECK that we
-  // receive stats from one of them.
-  if (stats_.ssrc != ssrc)
-    return;
-  stats_.c_name = std::string(cname);
-}
-
-void ReceiveStatisticsProxy::OnDecodedFrame(const VideoFrame& frame,
-                                            absl::optional<uint8_t> qp,
-                                            int32_t decode_time_ms,
-                                            VideoContentType content_type) {
-  MutexLock lock(&mutex_);
-
-  uint64_t now_ms = clock_->TimeInMilliseconds();
-
-  if (videocontenttypehelpers::IsScreenshare(content_type) !=
-      videocontenttypehelpers::IsScreenshare(last_content_type_)) {
-    // Reset the quality observer if content type is switched. But first report
-    // stats for the previous part of the call.
-    video_quality_observer_->UpdateHistograms();
-    video_quality_observer_.reset(new VideoQualityObserver(content_type));
-  }
-
-  video_quality_observer_->OnDecodedFrame(frame, qp, last_codec_type_);
-
-  ContentSpecificStats* content_specific_stats =
-      &content_specific_stats_[content_type];
-  ++stats_.frames_decoded;
-  if (qp) {
-    if (!stats_.qp_sum) {
-      if (stats_.frames_decoded != 1) {
-        RTC_LOG(LS_WARNING)
-            << "Frames decoded was not 1 when first qp value was received.";
-      }
-      stats_.qp_sum = 0;
-    }
-    *stats_.qp_sum += *qp;
-    content_specific_stats->qp_counter.Add(*qp);
-  } else if (stats_.qp_sum) {
-    RTC_LOG(LS_WARNING)
-        << "QP sum was already set and no QP was given for a frame.";
-    stats_.qp_sum.reset();
-  }
-  decode_time_counter_.Add(decode_time_ms);
-  stats_.decode_ms = decode_time_ms;
-  stats_.total_decode_time_ms += decode_time_ms;
-  if (enable_decode_time_histograms_) {
-    UpdateDecodeTimeHistograms(frame.width(), frame.height(), decode_time_ms);
-  }
-
-  last_content_type_ = content_type;
-  decode_fps_estimator_.Update(1, now_ms);
-  if (last_decoded_frame_time_ms_) {
-    int64_t interframe_delay_ms = now_ms - *last_decoded_frame_time_ms_;
-    RTC_DCHECK_GE(interframe_delay_ms, 0);
-    double interframe_delay = interframe_delay_ms / 1000.0;
-    stats_.total_inter_frame_delay += interframe_delay;
-    stats_.total_squared_inter_frame_delay +=
-        interframe_delay * interframe_delay;
-    interframe_delay_max_moving_.Add(interframe_delay_ms, now_ms);
-    content_specific_stats->interframe_delay_counter.Add(interframe_delay_ms);
-    content_specific_stats->interframe_delay_percentiles.Add(
-        interframe_delay_ms);
-    content_specific_stats->flow_duration_ms += interframe_delay_ms;
-  }
-  if (stats_.frames_decoded == 1) {
-    first_decoded_frame_time_ms_.emplace(now_ms);
-  }
-  last_decoded_frame_time_ms_.emplace(now_ms);
-}
-
-void ReceiveStatisticsProxy::OnRenderedFrame(const VideoFrame& frame) {
-  int width = frame.width();
-  int height = frame.height();
-  RTC_DCHECK_GT(width, 0);
-  RTC_DCHECK_GT(height, 0);
-  int64_t now_ms = clock_->TimeInMilliseconds();
-  MutexLock lock(&mutex_);
-
-  video_quality_observer_->OnRenderedFrame(frame, now_ms);
-
-  ContentSpecificStats* content_specific_stats =
-      &content_specific_stats_[last_content_type_];
-  renders_fps_estimator_.Update(1, now_ms);
-  ++stats_.frames_rendered;
-  stats_.width = width;
-  stats_.height = height;
-  render_fps_tracker_.AddSamples(1);
-  render_pixel_tracker_.AddSamples(sqrt(width * height));
-  content_specific_stats->received_width.Add(width);
-  content_specific_stats->received_height.Add(height);
-
-  // Consider taking stats_.render_delay_ms into account.
-  const int64_t time_until_rendering_ms = frame.render_time_ms() - now_ms;
-  if (time_until_rendering_ms < 0) {
-    sum_missed_render_deadline_ms_ += -time_until_rendering_ms;
-    ++num_delayed_frames_rendered_;
-  }
-
-  if (frame.ntp_time_ms() > 0) {
-    int64_t delay_ms = clock_->CurrentNtpInMilliseconds() - frame.ntp_time_ms();
-    if (delay_ms >= 0) {
-      content_specific_stats->e2e_delay_counter.Add(delay_ms);
-    }
-  }
-  QualitySample();
-}
-
-void ReceiveStatisticsProxy::OnSyncOffsetUpdated(int64_t video_playout_ntp_ms,
-                                                 int64_t sync_offset_ms,
-                                                 double estimated_freq_khz) {
-  MutexLock lock(&mutex_);
-  sync_offset_counter_.Add(std::abs(sync_offset_ms));
-  stats_.sync_offset_ms = sync_offset_ms;
-  last_estimated_playout_ntp_timestamp_ms_ = video_playout_ntp_ms;
-  last_estimated_playout_time_ms_ = clock_->TimeInMilliseconds();
-
-  const double kMaxFreqKhz = 10000.0;
-  int offset_khz = kMaxFreqKhz;
-  // Should not be zero or negative. If so, report max.
-  if (estimated_freq_khz < kMaxFreqKhz && estimated_freq_khz > 0.0)
-    offset_khz = static_cast<int>(std::fabs(estimated_freq_khz - 90.0) + 0.5);
-
-  freq_offset_counter_.Add(offset_khz);
-}
-
-void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe,
-                                             size_t size_bytes,
-                                             VideoContentType content_type) {
-  MutexLock lock(&mutex_);
-  if (is_keyframe) {
-    ++stats_.frame_counts.key_frames;
-  } else {
-    ++stats_.frame_counts.delta_frames;
-  }
-
-  // Content type extension is set only for keyframes and should be propagated
-  // for all the following delta frames. Here we may receive frames out of order
-  // and miscategorise some delta frames near the layer switch.
-  // This may slightly offset calculated bitrate and keyframes permille metrics.
-  VideoContentType propagated_content_type =
-      is_keyframe ? content_type : last_content_type_;
-
-  ContentSpecificStats* content_specific_stats =
-      &content_specific_stats_[propagated_content_type];
-
-  content_specific_stats->total_media_bytes += size_bytes;
-  if (is_keyframe) {
-    ++content_specific_stats->frame_counts.key_frames;
-  } else {
-    ++content_specific_stats->frame_counts.delta_frames;
-  }
-
-  int64_t now_ms = clock_->TimeInMilliseconds();
-  frame_window_.insert(std::make_pair(now_ms, size_bytes));
-  UpdateFramerate(now_ms);
-}
-
-void ReceiveStatisticsProxy::OnDroppedFrames(uint32_t frames_dropped) {
-  MutexLock lock(&mutex_);
-  stats_.frames_dropped += frames_dropped;
-}
-
-void ReceiveStatisticsProxy::OnPreDecode(VideoCodecType codec_type, int qp) {
-  RTC_DCHECK_RUN_ON(&decode_thread_);
-  MutexLock lock(&mutex_);
-  last_codec_type_ = codec_type;
-  if (last_codec_type_ == kVideoCodecVP8 && qp != -1) {
-    qp_counters_.vp8.Add(qp);
-    qp_sample_.Add(qp);
-  }
-}
-
-void ReceiveStatisticsProxy::OnStreamInactive() {
-  // TODO(sprang): Figure out any other state that should be reset.
-
-  MutexLock lock(&mutex_);
-  // Don't report inter-frame delay if stream was paused.
-  last_decoded_frame_time_ms_.reset();
-  video_quality_observer_->OnStreamInactive();
-}
-
-void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms,
-                                         int64_t max_rtt_ms) {
-  MutexLock lock(&mutex_);
-  avg_rtt_ms_ = avg_rtt_ms;
-}
-
-void ReceiveStatisticsProxy::DecoderThreadStarting() {
-  RTC_DCHECK_RUN_ON(&main_thread_);
-}
-
-void ReceiveStatisticsProxy::DecoderThreadStopped() {
-  RTC_DCHECK_RUN_ON(&main_thread_);
-  decode_thread_.Detach();
-}
-
-ReceiveStatisticsProxy::ContentSpecificStats::ContentSpecificStats()
-    : interframe_delay_percentiles(kMaxCommonInterframeDelayMs) {}
-
-ReceiveStatisticsProxy::ContentSpecificStats::~ContentSpecificStats() = default;
-
-void ReceiveStatisticsProxy::ContentSpecificStats::Add(
-    const ContentSpecificStats& other) {
-  e2e_delay_counter.Add(other.e2e_delay_counter);
-  interframe_delay_counter.Add(other.interframe_delay_counter);
-  flow_duration_ms += other.flow_duration_ms;
-  total_media_bytes += other.total_media_bytes;
-  received_height.Add(other.received_height);
-  received_width.Add(other.received_width);
-  qp_counter.Add(other.qp_counter);
-  frame_counts.key_frames += other.frame_counts.key_frames;
-  frame_counts.delta_frames += other.frame_counts.delta_frames;
-  interframe_delay_percentiles.Add(other.interframe_delay_percentiles);
-}
-}  // namespace webrtc
diff --git a/video/receive_statistics_proxy.h b/video/receive_statistics_proxy.h
deleted file mode 100644
index f0b5148..0000000
--- a/video/receive_statistics_proxy.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- *  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.
- */
-
-#ifndef VIDEO_RECEIVE_STATISTICS_PROXY_H_
-#define VIDEO_RECEIVE_STATISTICS_PROXY_H_
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "absl/types/optional.h"
-#include "api/field_trials_view.h"
-#include "api/sequence_checker.h"
-#include "call/video_receive_stream.h"
-#include "modules/include/module_common_types.h"
-#include "modules/video_coding/include/video_coding_defines.h"
-#include "rtc_base/numerics/histogram_percentile_counter.h"
-#include "rtc_base/numerics/moving_max_counter.h"
-#include "rtc_base/numerics/sample_counter.h"
-#include "rtc_base/rate_statistics.h"
-#include "rtc_base/rate_tracker.h"
-#include "rtc_base/synchronization/mutex.h"
-#include "rtc_base/thread_annotations.h"
-#include "video/quality_threshold.h"
-#include "video/stats_counter.h"
-#include "video/video_quality_observer.h"
-
-namespace webrtc {
-
-class Clock;
-struct CodecSpecificInfo;
-
-class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
-                               public RtcpCnameCallback,
-                               public RtcpPacketTypeCounterObserver,
-                               public CallStatsObserver {
- public:
-  ReceiveStatisticsProxy(uint32_t remote_ssrc,
-                         Clock* clock,
-                         const FieldTrialsView* field_trials = nullptr);
-  ~ReceiveStatisticsProxy() = default;
-
-  VideoReceiveStreamInterface::Stats GetStats() const;
-
-  void OnDecodedFrame(const VideoFrame& frame,
-                      absl::optional<uint8_t> qp,
-                      int32_t decode_time_ms,
-                      VideoContentType content_type);
-  void OnSyncOffsetUpdated(int64_t video_playout_ntp_ms,
-                           int64_t sync_offset_ms,
-                           double estimated_freq_khz);
-  void OnRenderedFrame(const VideoFrame& frame);
-  void OnIncomingPayloadType(int payload_type);
-  void OnDecoderImplementationName(const char* implementation_name);
-
-  void OnPreDecode(VideoCodecType codec_type, int qp);
-
-  void OnUniqueFramesCounted(int num_unique_frames);
-
-  // Indicates video stream has been paused (no incoming packets).
-  void OnStreamInactive();
-
-  // Overrides VCMReceiveStatisticsCallback.
-  void OnCompleteFrame(bool is_keyframe,
-                       size_t size_bytes,
-                       VideoContentType content_type) override;
-  void OnDroppedFrames(uint32_t frames_dropped) override;
-  void OnFrameBufferTimingsUpdated(int max_decode_ms,
-                                   int current_delay_ms,
-                                   int target_delay_ms,
-                                   int jitter_buffer_ms,
-                                   int min_playout_delay_ms,
-                                   int render_delay_ms) override;
-
-  void OnTimingFrameInfoUpdated(const TimingFrameInfo& info) override;
-
-  // Overrides RtcpCnameCallback.
-  void OnCname(uint32_t ssrc, absl::string_view cname) override;
-
-  // Overrides RtcpPacketTypeCounterObserver.
-  void RtcpPacketTypesCounterUpdated(
-      uint32_t ssrc,
-      const RtcpPacketTypeCounter& packet_counter) override;
-
-  // Implements CallStatsObserver.
-  void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
-
-  // Notification methods that are used to check our internal state and validate
-  // threading assumptions. These are called by VideoReceiveStreamInterface.
-  void DecoderThreadStarting();
-  void DecoderThreadStopped();
-
-  // Produce histograms. Must be called after DecoderThreadStopped(), typically
-  // at the end of the call.
-  void UpdateHistograms(absl::optional<int> fraction_lost,
-                        const StreamDataCounters& rtp_stats,
-                        const StreamDataCounters* rtx_stats);
-
- private:
-  struct QpCounters {
-    rtc::SampleCounter vp8;
-  };
-
-  struct ContentSpecificStats {
-    ContentSpecificStats();
-    ~ContentSpecificStats();
-
-    void Add(const ContentSpecificStats& other);
-
-    rtc::SampleCounter e2e_delay_counter;
-    rtc::SampleCounter interframe_delay_counter;
-    int64_t flow_duration_ms = 0;
-    int64_t total_media_bytes = 0;
-    rtc::SampleCounter received_width;
-    rtc::SampleCounter received_height;
-    rtc::SampleCounter qp_counter;
-    FrameCounts frame_counts;
-    rtc::HistogramPercentileCounter interframe_delay_percentiles;
-  };
-
-  void QualitySample() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
-  // Removes info about old frames and then updates the framerate.
-  void UpdateFramerate(int64_t now_ms) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
-  void UpdateDecodeTimeHistograms(int width,
-                                  int height,
-                                  int decode_time_ms) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
-  absl::optional<int64_t> GetCurrentEstimatedPlayoutNtpTimestampMs(
-      int64_t now_ms) const RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
-  Clock* const clock_;
-  const int64_t start_ms_;
-  const bool enable_decode_time_histograms_;
-
-  mutable Mutex mutex_;
-  int64_t last_sample_time_ RTC_GUARDED_BY(mutex_);
-  QualityThreshold fps_threshold_ RTC_GUARDED_BY(mutex_);
-  QualityThreshold qp_threshold_ RTC_GUARDED_BY(mutex_);
-  QualityThreshold variance_threshold_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter qp_sample_ RTC_GUARDED_BY(mutex_);
-  int num_bad_states_ RTC_GUARDED_BY(mutex_);
-  int num_certain_states_ RTC_GUARDED_BY(mutex_);
-  // Note: The `stats_.rtp_stats` member is not used or populated by this class.
-  mutable VideoReceiveStreamInterface::Stats stats_ RTC_GUARDED_BY(mutex_);
-  RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(mutex_);
-  RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(mutex_);
-  rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(mutex_);
-  rtc::RateTracker render_pixel_tracker_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter sync_offset_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter decode_time_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter jitter_buffer_delay_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter target_delay_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter current_delay_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter delay_counter_ RTC_GUARDED_BY(mutex_);
-  std::unique_ptr<VideoQualityObserver> video_quality_observer_
-      RTC_GUARDED_BY(mutex_);
-  mutable rtc::MovingMaxCounter<int> interframe_delay_max_moving_
-      RTC_GUARDED_BY(mutex_);
-  std::map<VideoContentType, ContentSpecificStats> content_specific_stats_
-      RTC_GUARDED_BY(mutex_);
-  MaxCounter freq_offset_counter_ RTC_GUARDED_BY(mutex_);
-  QpCounters qp_counters_ RTC_GUARDED_BY(decode_thread_);
-  int64_t avg_rtt_ms_ RTC_GUARDED_BY(mutex_);
-  mutable std::map<int64_t, size_t> frame_window_ RTC_GUARDED_BY(&mutex_);
-  VideoContentType last_content_type_ RTC_GUARDED_BY(&mutex_);
-  VideoCodecType last_codec_type_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> first_frame_received_time_ms_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> first_decoded_frame_time_ms_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> last_decoded_frame_time_ms_ RTC_GUARDED_BY(&mutex_);
-  size_t num_delayed_frames_rendered_ RTC_GUARDED_BY(&mutex_);
-  int64_t sum_missed_render_deadline_ms_ RTC_GUARDED_BY(&mutex_);
-  // Mutable because calling Max() on MovingMaxCounter is not const. Yet it is
-  // called from const GetStats().
-  mutable rtc::MovingMaxCounter<TimingFrameInfo> timing_frame_info_counter_
-      RTC_GUARDED_BY(&mutex_);
-  absl::optional<int> num_unique_frames_ RTC_GUARDED_BY(mutex_);
-  absl::optional<int64_t> last_estimated_playout_ntp_timestamp_ms_
-      RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> last_estimated_playout_time_ms_
-      RTC_GUARDED_BY(&mutex_);
-  SequenceChecker decode_thread_;
-  SequenceChecker network_thread_;
-  SequenceChecker main_thread_;
-};
-
-}  // namespace webrtc
-#endif  // VIDEO_RECEIVE_STATISTICS_PROXY_H_
diff --git a/video/receive_statistics_proxy_unittest.cc b/video/receive_statistics_proxy_unittest.cc
deleted file mode 100644
index 1bef646..0000000
--- a/video/receive_statistics_proxy_unittest.cc
+++ /dev/null
@@ -1,1827 +0,0 @@
-/*
- *  Copyright 2016 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 "video/receive_statistics_proxy.h"
-
-#include <limits>
-#include <memory>
-#include <string>
-#include <tuple>
-#include <utility>
-
-#include "absl/types/optional.h"
-#include "api/scoped_refptr.h"
-#include "api/video/i420_buffer.h"
-#include "api/video/video_frame.h"
-#include "api/video/video_frame_buffer.h"
-#include "api/video/video_rotation.h"
-#include "system_wrappers/include/metrics.h"
-#include "test/gtest.h"
-#include "test/scoped_key_value_config.h"
-
-namespace webrtc {
-namespace {
-const int64_t kFreqOffsetProcessIntervalInMs = 40000;
-const uint32_t kLocalSsrc = 123;
-const uint32_t kRemoteSsrc = 456;
-const int kMinRequiredSamples = 200;
-const int kWidth = 1280;
-const int kHeight = 720;
-}  // namespace
-
-// TODO(sakal): ReceiveStatisticsProxy is lacking unittesting.
-class ReceiveStatisticsProxyTest : public ::testing::Test {
- public:
-  explicit ReceiveStatisticsProxyTest(std::string field_trials = "")
-      : field_trials_(field_trials),
-        fake_clock_(1234),
-        config_(GetTestConfig()) {}
-  virtual ~ReceiveStatisticsProxyTest() {}
-
- protected:
-  virtual void SetUp() {
-    metrics::Reset();
-    statistics_proxy_.reset(new ReceiveStatisticsProxy(
-        config_.rtp.remote_ssrc, &fake_clock_, &field_trials_));
-  }
-
-  VideoReceiveStreamInterface::Config GetTestConfig() {
-    VideoReceiveStreamInterface::Config config(nullptr);
-    config.rtp.local_ssrc = kLocalSsrc;
-    config.rtp.remote_ssrc = kRemoteSsrc;
-    return config;
-  }
-
-  VideoFrame CreateFrame(int width, int height) {
-    return CreateVideoFrame(width, height, 0);
-  }
-
-  VideoFrame CreateFrameWithRenderTimeMs(int64_t render_time_ms) {
-    return CreateVideoFrame(kWidth, kHeight, render_time_ms);
-  }
-
-  VideoFrame CreateVideoFrame(int width, int height, int64_t render_time_ms) {
-    VideoFrame frame =
-        VideoFrame::Builder()
-            .set_video_frame_buffer(I420Buffer::Create(width, height))
-            .set_timestamp_rtp(0)
-            .set_timestamp_ms(render_time_ms)
-            .set_rotation(kVideoRotation_0)
-            .build();
-    frame.set_ntp_time_ms(fake_clock_.CurrentNtpInMilliseconds());
-    return frame;
-  }
-
-  test::ScopedKeyValueConfig field_trials_;
-  SimulatedClock fake_clock_;
-  const VideoReceiveStreamInterface::Config config_;
-  std::unique_ptr<ReceiveStatisticsProxy> statistics_proxy_;
-};
-
-TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesFramesDecoded) {
-  EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  for (uint32_t i = 1; i <= 3; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                      VideoContentType::UNSPECIFIED);
-    EXPECT_EQ(i, statistics_proxy_->GetStats().frames_decoded);
-  }
-}
-
-TEST_F(ReceiveStatisticsProxyTest, DecodedFpsIsReported) {
-  const int kFps = 20;
-  const int kRequiredSamples = metrics::kMinRunTimeInSeconds * kFps;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  for (int i = 0; i < kRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                      VideoContentType::UNSPECIFIED);
-    fake_clock_.AdvanceTimeMilliseconds(1000 / kFps);
-  }
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DecodedFramesPerSecond", kFps));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, DecodedFpsIsNotReportedForTooFewSamples) {
-  const int kFps = 20;
-  const int kRequiredSamples = metrics::kMinRunTimeInSeconds * kFps;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  for (int i = 0; i < kRequiredSamples - 1; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                      VideoContentType::UNSPECIFIED);
-    fake_clock_.AdvanceTimeMilliseconds(1000 / kFps);
-  }
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       OnDecodedFrameWithQpDoesNotResetFramesDecodedOrTotalDecodeTime) {
-  EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  unsigned int expected_total_decode_time_ms = 0;
-  unsigned int expected_frames_decoded = 0;
-  for (uint32_t i = 1; i <= 3; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 1,
-                                      VideoContentType::UNSPECIFIED);
-    expected_total_decode_time_ms += 1;
-    ++expected_frames_decoded;
-    EXPECT_EQ(expected_frames_decoded,
-              statistics_proxy_->GetStats().frames_decoded);
-    EXPECT_EQ(expected_total_decode_time_ms,
-              statistics_proxy_->GetStats().total_decode_time_ms);
-  }
-  statistics_proxy_->OnDecodedFrame(frame, 1u, 3,
-                                    VideoContentType::UNSPECIFIED);
-  ++expected_frames_decoded;
-  expected_total_decode_time_ms += 3;
-  EXPECT_EQ(expected_frames_decoded,
-            statistics_proxy_->GetStats().frames_decoded);
-  EXPECT_EQ(expected_total_decode_time_ms,
-            statistics_proxy_->GetStats().total_decode_time_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesQpSum) {
-  EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, 3u, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(3u, statistics_proxy_->GetStats().qp_sum);
-  statistics_proxy_->OnDecodedFrame(frame, 127u, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(130u, statistics_proxy_->GetStats().qp_sum);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesTotalDecodeTime) {
-  EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, 3u, 4,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(4u, statistics_proxy_->GetStats().total_decode_time_ms);
-  statistics_proxy_->OnDecodedFrame(frame, 127u, 7,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(11u, statistics_proxy_->GetStats().total_decode_time_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsContentType) {
-  const std::string kRealtimeString("realtime");
-  const std::string kScreenshareString("screen");
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  EXPECT_EQ(kRealtimeString, videocontenttypehelpers::ToString(
-                                 statistics_proxy_->GetStats().content_type));
-  statistics_proxy_->OnDecodedFrame(frame, 3u, 0,
-                                    VideoContentType::SCREENSHARE);
-  EXPECT_EQ(kScreenshareString,
-            videocontenttypehelpers::ToString(
-                statistics_proxy_->GetStats().content_type));
-  statistics_proxy_->OnDecodedFrame(frame, 3u, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(kRealtimeString, videocontenttypehelpers::ToString(
-                                 statistics_proxy_->GetStats().content_type));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsMaxTotalInterFrameDelay) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  const TimeDelta kInterFrameDelay1 = TimeDelta::Millis(100);
-  const TimeDelta kInterFrameDelay2 = TimeDelta::Millis(200);
-  const TimeDelta kInterFrameDelay3 = TimeDelta::Millis(300);
-  double expected_total_inter_frame_delay = 0;
-  double expected_total_squared_inter_frame_delay = 0;
-  EXPECT_EQ(expected_total_inter_frame_delay,
-            statistics_proxy_->GetStats().total_inter_frame_delay);
-  EXPECT_EQ(expected_total_squared_inter_frame_delay,
-            statistics_proxy_->GetStats().total_squared_inter_frame_delay);
-
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_DOUBLE_EQ(expected_total_inter_frame_delay,
-                   statistics_proxy_->GetStats().total_inter_frame_delay);
-  EXPECT_DOUBLE_EQ(
-      expected_total_squared_inter_frame_delay,
-      statistics_proxy_->GetStats().total_squared_inter_frame_delay);
-
-  fake_clock_.AdvanceTime(kInterFrameDelay1);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  expected_total_inter_frame_delay += kInterFrameDelay1.seconds<double>();
-  expected_total_squared_inter_frame_delay +=
-      pow(kInterFrameDelay1.seconds<double>(), 2.0);
-  EXPECT_DOUBLE_EQ(expected_total_inter_frame_delay,
-                   statistics_proxy_->GetStats().total_inter_frame_delay);
-  EXPECT_DOUBLE_EQ(
-      expected_total_squared_inter_frame_delay,
-      statistics_proxy_->GetStats().total_squared_inter_frame_delay);
-
-  fake_clock_.AdvanceTime(kInterFrameDelay2);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  expected_total_inter_frame_delay += kInterFrameDelay2.seconds<double>();
-  expected_total_squared_inter_frame_delay +=
-      pow(kInterFrameDelay2.seconds<double>(), 2.0);
-  EXPECT_DOUBLE_EQ(expected_total_inter_frame_delay,
-                   statistics_proxy_->GetStats().total_inter_frame_delay);
-  EXPECT_DOUBLE_EQ(
-      expected_total_squared_inter_frame_delay,
-      statistics_proxy_->GetStats().total_squared_inter_frame_delay);
-
-  fake_clock_.AdvanceTime(kInterFrameDelay3);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  expected_total_inter_frame_delay += kInterFrameDelay3.seconds<double>();
-  expected_total_squared_inter_frame_delay +=
-      pow(kInterFrameDelay3.seconds<double>(), 2.0);
-  EXPECT_DOUBLE_EQ(expected_total_inter_frame_delay,
-                   statistics_proxy_->GetStats().total_inter_frame_delay);
-  EXPECT_DOUBLE_EQ(
-      expected_total_squared_inter_frame_delay,
-      statistics_proxy_->GetStats().total_squared_inter_frame_delay);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsMaxInterframeDelay) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  const int64_t kInterframeDelayMs1 = 100;
-  const int64_t kInterframeDelayMs2 = 200;
-  const int64_t kInterframeDelayMs3 = 100;
-  EXPECT_EQ(-1, statistics_proxy_->GetStats().interframe_delay_max_ms);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(-1, statistics_proxy_->GetStats().interframe_delay_max_ms);
-
-  fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs1);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(kInterframeDelayMs1,
-            statistics_proxy_->GetStats().interframe_delay_max_ms);
-
-  fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs2);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(kInterframeDelayMs2,
-            statistics_proxy_->GetStats().interframe_delay_max_ms);
-
-  fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs3);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  // kInterframeDelayMs3 is smaller than kInterframeDelayMs2.
-  EXPECT_EQ(kInterframeDelayMs2,
-            statistics_proxy_->GetStats().interframe_delay_max_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportInterframeDelayInWindow) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  const int64_t kInterframeDelayMs1 = 900;
-  const int64_t kInterframeDelayMs2 = 750;
-  const int64_t kInterframeDelayMs3 = 700;
-  EXPECT_EQ(-1, statistics_proxy_->GetStats().interframe_delay_max_ms);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(-1, statistics_proxy_->GetStats().interframe_delay_max_ms);
-
-  fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs1);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(kInterframeDelayMs1,
-            statistics_proxy_->GetStats().interframe_delay_max_ms);
-
-  fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs2);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  // Still first delay is the maximum
-  EXPECT_EQ(kInterframeDelayMs1,
-            statistics_proxy_->GetStats().interframe_delay_max_ms);
-
-  fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs3);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  // Now the first sample is out of the window, so the second is the maximum.
-  EXPECT_EQ(kInterframeDelayMs2,
-            statistics_proxy_->GetStats().interframe_delay_max_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsFreezeMetrics) {
-  const int64_t kFreezeDurationMs = 1000;
-
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(0u, stats.freeze_count);
-  EXPECT_FALSE(stats.total_freezes_duration_ms);
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  for (size_t i = 0; i < VideoQualityObserver::kMinFrameSamplesToDetectFreeze;
-       ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(30);
-    statistics_proxy_->OnRenderedFrame(frame);
-  }
-
-  // Freeze.
-  fake_clock_.AdvanceTimeMilliseconds(kFreezeDurationMs);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(1u, stats.freeze_count);
-  EXPECT_EQ(kFreezeDurationMs, stats.total_freezes_duration_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsPauseMetrics) {
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  ASSERT_EQ(0u, stats.pause_count);
-  ASSERT_EQ(0u, stats.total_pauses_duration_ms);
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  // Pause.
-  fake_clock_.AdvanceTimeMilliseconds(5432);
-  statistics_proxy_->OnStreamInactive();
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(1u, stats.pause_count);
-  EXPECT_EQ(5432u, stats.total_pauses_duration_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, PauseBeforeFirstAndAfterLastFrameIgnored) {
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  ASSERT_EQ(0u, stats.pause_count);
-  ASSERT_EQ(0u, stats.total_pauses_duration_ms);
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  // Pause -> Frame -> Pause
-  fake_clock_.AdvanceTimeMilliseconds(5000);
-  statistics_proxy_->OnStreamInactive();
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  fake_clock_.AdvanceTimeMilliseconds(30);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  fake_clock_.AdvanceTimeMilliseconds(5000);
-  statistics_proxy_->OnStreamInactive();
-
-  stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(0u, stats.pause_count);
-  EXPECT_EQ(0u, stats.total_pauses_duration_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsFramesDuration) {
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  ASSERT_EQ(0u, stats.total_frames_duration_ms);
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  // Emulate delay before first frame is rendered. This is needed to ensure
-  // that frame duration only covers time since first frame is rendered and
-  // not the total time.
-  fake_clock_.AdvanceTimeMilliseconds(5432);
-
-  for (int i = 0; i <= 10; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(30);
-    statistics_proxy_->OnRenderedFrame(frame);
-  }
-
-  stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(10 * 30u, stats.total_frames_duration_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsSumSquaredFrameDurations) {
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  ASSERT_EQ(0u, stats.sum_squared_frame_durations);
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  for (int i = 0; i <= 10; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(30);
-    statistics_proxy_->OnRenderedFrame(frame);
-  }
-
-  stats = statistics_proxy_->GetStats();
-  const double kExpectedSumSquaredFrameDurationsSecs =
-      10 * (30 / 1000.0 * 30 / 1000.0);
-  EXPECT_EQ(kExpectedSumSquaredFrameDurationsSecs,
-            stats.sum_squared_frame_durations);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameWithoutQpQpSumWontExist) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameWithoutQpResetsQpSum) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
-  statistics_proxy_->OnDecodedFrame(frame, 3u, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(3u, statistics_proxy_->GetStats().qp_sum);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-  EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, OnRenderedFrameIncreasesFramesRendered) {
-  EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_rendered);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  for (uint32_t i = 1; i <= 3; ++i) {
-    statistics_proxy_->OnRenderedFrame(frame);
-    EXPECT_EQ(i, statistics_proxy_->GetStats().frames_rendered);
-  }
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsSsrc) {
-  EXPECT_EQ(kRemoteSsrc, statistics_proxy_->GetStats().ssrc);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsIncomingPayloadType) {
-  const int kPayloadType = 111;
-  statistics_proxy_->OnIncomingPayloadType(kPayloadType);
-  EXPECT_EQ(kPayloadType, statistics_proxy_->GetStats().current_payload_type);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDecoderImplementationName) {
-  const char* kName = "decoderName";
-  statistics_proxy_->OnDecoderImplementationName(kName);
-  EXPECT_STREQ(
-      kName, statistics_proxy_->GetStats().decoder_implementation_name.c_str());
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsOnCompleteFrame) {
-  const int kFrameSizeBytes = 1000;
-  statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
-                                     VideoContentType::UNSPECIFIED);
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(1, stats.network_frame_rate);
-  EXPECT_EQ(1, stats.frame_counts.key_frames);
-  EXPECT_EQ(0, stats.frame_counts.delta_frames);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsOnDroppedFrame) {
-  unsigned int dropped_frames = 0;
-  for (int i = 0; i < 10; ++i) {
-    statistics_proxy_->OnDroppedFrames(i);
-    dropped_frames += i;
-  }
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(dropped_frames, stats.frames_dropped);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDecodeTimingStats) {
-  const int kMaxDecodeMs = 2;
-  const int kCurrentDelayMs = 3;
-  const int kTargetDelayMs = 4;
-  const int kJitterBufferMs = 5;
-  const int kMinPlayoutDelayMs = 6;
-  const int kRenderDelayMs = 7;
-  const int64_t kRttMs = 8;
-  statistics_proxy_->OnRttUpdate(kRttMs, 0);
-  statistics_proxy_->OnFrameBufferTimingsUpdated(
-      kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
-      kMinPlayoutDelayMs, kRenderDelayMs);
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(kMaxDecodeMs, stats.max_decode_ms);
-  EXPECT_EQ(kCurrentDelayMs, stats.current_delay_ms);
-  EXPECT_EQ(kTargetDelayMs, stats.target_delay_ms);
-  EXPECT_EQ(kJitterBufferMs, stats.jitter_buffer_ms);
-  EXPECT_EQ(kMinPlayoutDelayMs, stats.min_playout_delay_ms);
-  EXPECT_EQ(kRenderDelayMs, stats.render_delay_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsRtcpPacketTypeCounts) {
-  const uint32_t kFirPackets = 33;
-  const uint32_t kPliPackets = 44;
-  const uint32_t kNackPackets = 55;
-  RtcpPacketTypeCounter counter;
-  counter.fir_packets = kFirPackets;
-  counter.pli_packets = kPliPackets;
-  counter.nack_packets = kNackPackets;
-  statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(kFirPackets, stats.rtcp_packet_type_counts.fir_packets);
-  EXPECT_EQ(kPliPackets, stats.rtcp_packet_type_counts.pli_packets);
-  EXPECT_EQ(kNackPackets, stats.rtcp_packet_type_counts.nack_packets);
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       GetStatsReportsNoRtcpPacketTypeCountsForUnknownSsrc) {
-  RtcpPacketTypeCounter counter;
-  counter.fir_packets = 33;
-  statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc + 1, counter);
-  EXPECT_EQ(0u,
-            statistics_proxy_->GetStats().rtcp_packet_type_counts.fir_packets);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsFrameCounts) {
-  const int kKeyFrames = 3;
-  const int kDeltaFrames = 22;
-  for (int i = 0; i < kKeyFrames; i++) {
-    statistics_proxy_->OnCompleteFrame(true, 0, VideoContentType::UNSPECIFIED);
-  }
-  for (int i = 0; i < kDeltaFrames; i++) {
-    statistics_proxy_->OnCompleteFrame(false, 0, VideoContentType::UNSPECIFIED);
-  }
-
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(kKeyFrames, stats.frame_counts.key_frames);
-  EXPECT_EQ(kDeltaFrames, stats.frame_counts.delta_frames);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsCName) {
-  const char* kName = "cName";
-  statistics_proxy_->OnCname(kRemoteSsrc, kName);
-  EXPECT_STREQ(kName, statistics_proxy_->GetStats().c_name.c_str());
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsNoCNameForUnknownSsrc) {
-  const char* kName = "cName";
-  statistics_proxy_->OnCname(kRemoteSsrc + 1, kName);
-  EXPECT_STREQ("", statistics_proxy_->GetStats().c_name.c_str());
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReportsLongestTimingFrameInfo) {
-  const int64_t kShortEndToEndDelay = 10;
-  const int64_t kMedEndToEndDelay = 20;
-  const int64_t kLongEndToEndDelay = 100;
-  const uint32_t kExpectedRtpTimestamp = 2;
-  TimingFrameInfo info;
-  absl::optional<TimingFrameInfo> result;
-  info.rtp_timestamp = kExpectedRtpTimestamp - 1;
-  info.capture_time_ms = 0;
-  info.decode_finish_ms = kShortEndToEndDelay;
-  statistics_proxy_->OnTimingFrameInfoUpdated(info);
-  info.rtp_timestamp =
-      kExpectedRtpTimestamp;  // this frame should be reported in the end.
-  info.capture_time_ms = 0;
-  info.decode_finish_ms = kLongEndToEndDelay;
-  statistics_proxy_->OnTimingFrameInfoUpdated(info);
-  info.rtp_timestamp = kExpectedRtpTimestamp + 1;
-  info.capture_time_ms = 0;
-  info.decode_finish_ms = kMedEndToEndDelay;
-  statistics_proxy_->OnTimingFrameInfoUpdated(info);
-  result = statistics_proxy_->GetStats().timing_frame_info;
-  EXPECT_TRUE(result);
-  EXPECT_EQ(kExpectedRtpTimestamp, result->rtp_timestamp);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, RespectsReportingIntervalForTimingFrames) {
-  TimingFrameInfo info;
-  const int64_t kShortEndToEndDelay = 10;
-  const uint32_t kExpectedRtpTimestamp = 2;
-  const int64_t kShortDelayMs = 1000;
-  const int64_t kLongDelayMs = 10000;
-  absl::optional<TimingFrameInfo> result;
-  info.rtp_timestamp = kExpectedRtpTimestamp;
-  info.capture_time_ms = 0;
-  info.decode_finish_ms = kShortEndToEndDelay;
-  statistics_proxy_->OnTimingFrameInfoUpdated(info);
-  fake_clock_.AdvanceTimeMilliseconds(kShortDelayMs);
-  result = statistics_proxy_->GetStats().timing_frame_info;
-  EXPECT_TRUE(result);
-  EXPECT_EQ(kExpectedRtpTimestamp, result->rtp_timestamp);
-  fake_clock_.AdvanceTimeMilliseconds(kLongDelayMs);
-  result = statistics_proxy_->GetStats().timing_frame_info;
-  EXPECT_FALSE(result);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, LifetimeHistogramIsUpdated) {
-  const int64_t kTimeSec = 3;
-  fake_clock_.AdvanceTimeMilliseconds(kTimeSec * 1000);
-  // Need at least one frame to report stream lifetime.
-  statistics_proxy_->OnCompleteFrame(true, 1000, VideoContentType::UNSPECIFIED);
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(
-      1, metrics::NumSamples("WebRTC.Video.ReceiveStreamLifetimeInSeconds"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.ReceiveStreamLifetimeInSeconds",
-                            kTimeSec));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       LifetimeHistogramNotReportedForEmptyStreams) {
-  const int64_t kTimeSec = 3;
-  fake_clock_.AdvanceTimeMilliseconds(kTimeSec * 1000);
-  // No frames received.
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.ReceiveStreamLifetimeInSeconds"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, BadCallHistogramsAreUpdated) {
-  // Based on the tuning parameters this will produce 7 uncertain states,
-  // then 10 certainly bad states. There has to be 10 certain states before
-  // any histograms are recorded.
-  const int kNumBadSamples = 17;
-  // We only count one sample per second.
-  const int kBadFameIntervalMs = 1100;
-
-  StreamDataCounters counters;
-  counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kNumBadSamples; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(kBadFameIntervalMs);
-    statistics_proxy_->OnRenderedFrame(frame);
-  }
-  statistics_proxy_->UpdateHistograms(absl::nullopt, counters, nullptr);
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.BadCall.Any"));
-  EXPECT_METRIC_EQ(1, metrics::NumEvents("WebRTC.Video.BadCall.Any", 100));
-
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.BadCall.FrameRate"));
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumEvents("WebRTC.Video.BadCall.FrameRate", 100));
-
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.BadCall.FrameRateVariance"));
-
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.BadCall.Qp"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, PacketLossHistogramIsUpdated) {
-  statistics_proxy_->UpdateHistograms(10, StreamDataCounters(), nullptr);
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent"));
-
-  // Restart
-  SetUp();
-
-  // Min run time has passed.
-  fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000);
-  statistics_proxy_->UpdateHistograms(10, StreamDataCounters(), nullptr);
-  EXPECT_METRIC_EQ(
-      1, metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.ReceivedPacketsLostInPercent", 10));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsPlayoutTimestamp) {
-  const int64_t kVideoNtpMs = 21;
-  const int64_t kSyncOffsetMs = 22;
-  const double kFreqKhz = 90.0;
-  EXPECT_EQ(absl::nullopt,
-            statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms);
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz);
-  EXPECT_EQ(kVideoNtpMs,
-            statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms);
-  fake_clock_.AdvanceTimeMilliseconds(13);
-  EXPECT_EQ(kVideoNtpMs + 13,
-            statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms);
-  fake_clock_.AdvanceTimeMilliseconds(5);
-  EXPECT_EQ(kVideoNtpMs + 13 + 5,
-            statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsAvSyncOffset) {
-  const int64_t kVideoNtpMs = 21;
-  const int64_t kSyncOffsetMs = 22;
-  const double kFreqKhz = 90.0;
-  EXPECT_EQ(std::numeric_limits<int>::max(),
-            statistics_proxy_->GetStats().sync_offset_ms);
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz);
-  EXPECT_EQ(kSyncOffsetMs, statistics_proxy_->GetStats().sync_offset_ms);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, AvSyncOffsetHistogramIsUpdated) {
-  const int64_t kVideoNtpMs = 21;
-  const int64_t kSyncOffsetMs = 22;
-  const double kFreqKhz = 90.0;
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs,
-                                           kFreqKhz);
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.AVSyncOffsetInMs"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.AVSyncOffsetInMs", kSyncOffsetMs));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, RtpToNtpFrequencyOffsetHistogramIsUpdated) {
-  const int64_t kVideoNtpMs = 21;
-  const int64_t kSyncOffsetMs = 22;
-  const double kFreqKhz = 90.0;
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz);
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs,
-                                         kFreqKhz + 2.2);
-  fake_clock_.AdvanceTimeMilliseconds(kFreqOffsetProcessIntervalInMs);
-  // Process interval passed, max diff: 2.
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs,
-                                         kFreqKhz + 1.1);
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs,
-                                         kFreqKhz - 4.2);
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs,
-                                         kFreqKhz - 0.9);
-  fake_clock_.AdvanceTimeMilliseconds(kFreqOffsetProcessIntervalInMs);
-  // Process interval passed, max diff: 4.
-  statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz);
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  // Average reported: (2 + 4) / 2 = 3.
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.RtpToNtpFreqOffsetInKhz"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.RtpToNtpFreqOffsetInKhz", 3));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, Vp8QpHistogramIsUpdated) {
-  const int kQp = 22;
-
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnPreDecode(kVideoCodecVP8, kQp);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.Decoded.Vp8.Qp"));
-  EXPECT_METRIC_EQ(1, metrics::NumEvents("WebRTC.Video.Decoded.Vp8.Qp", kQp));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, Vp8QpHistogramIsNotUpdatedForTooFewSamples) {
-  const int kQp = 22;
-
-  for (int i = 0; i < kMinRequiredSamples - 1; ++i)
-    statistics_proxy_->OnPreDecode(kVideoCodecVP8, kQp);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.Decoded.Vp8.Qp"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, Vp8QpHistogramIsNotUpdatedIfNoQpValue) {
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnPreDecode(kVideoCodecVP8, -1);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.Decoded.Vp8.Qp"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       KeyFrameHistogramNotUpdatedForTooFewSamples) {
-  const bool kIsKeyFrame = false;
-  const int kFrameSizeBytes = 1000;
-
-  for (int i = 0; i < kMinRequiredSamples - 1; ++i)
-    statistics_proxy_->OnCompleteFrame(kIsKeyFrame, kFrameSizeBytes,
-                                       VideoContentType::UNSPECIFIED);
-
-  EXPECT_EQ(0, statistics_proxy_->GetStats().frame_counts.key_frames);
-  EXPECT_EQ(kMinRequiredSamples - 1,
-            statistics_proxy_->GetStats().frame_counts.delta_frames);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       KeyFrameHistogramUpdatedForMinRequiredSamples) {
-  const bool kIsKeyFrame = false;
-  const int kFrameSizeBytes = 1000;
-
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnCompleteFrame(kIsKeyFrame, kFrameSizeBytes,
-                                       VideoContentType::UNSPECIFIED);
-
-  EXPECT_EQ(0, statistics_proxy_->GetStats().frame_counts.key_frames);
-  EXPECT_EQ(kMinRequiredSamples,
-            statistics_proxy_->GetStats().frame_counts.delta_frames);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(
-      1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.KeyFramesReceivedInPermille", 0));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, KeyFrameHistogramIsUpdated) {
-  const int kFrameSizeBytes = 1000;
-
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
-                                       VideoContentType::UNSPECIFIED);
-
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnCompleteFrame(false, kFrameSizeBytes,
-                                       VideoContentType::UNSPECIFIED);
-
-  EXPECT_EQ(kMinRequiredSamples,
-            statistics_proxy_->GetStats().frame_counts.key_frames);
-  EXPECT_EQ(kMinRequiredSamples,
-            statistics_proxy_->GetStats().frame_counts.delta_frames);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(
-      1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.KeyFramesReceivedInPermille", 500));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, TimingHistogramsNotUpdatedForTooFewSamples) {
-  const int kMaxDecodeMs = 2;
-  const int kCurrentDelayMs = 3;
-  const int kTargetDelayMs = 4;
-  const int kJitterBufferMs = 5;
-  const int kMinPlayoutDelayMs = 6;
-  const int kRenderDelayMs = 7;
-
-  for (int i = 0; i < kMinRequiredSamples - 1; ++i) {
-    statistics_proxy_->OnFrameBufferTimingsUpdated(
-        kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
-        kMinPlayoutDelayMs, kRenderDelayMs);
-  }
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.DecodeTimeInMs"));
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.JitterBufferDelayInMs"));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.TargetDelayInMs"));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.CurrentDelayInMs"));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.OnewayDelayInMs"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, TimingHistogramsAreUpdated) {
-  const int kMaxDecodeMs = 2;
-  const int kCurrentDelayMs = 3;
-  const int kTargetDelayMs = 4;
-  const int kJitterBufferMs = 5;
-  const int kMinPlayoutDelayMs = 6;
-  const int kRenderDelayMs = 7;
-
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnFrameBufferTimingsUpdated(
-        kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
-        kMinPlayoutDelayMs, kRenderDelayMs);
-  }
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.JitterBufferDelayInMs"));
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.TargetDelayInMs"));
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.CurrentDelayInMs"));
-  EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.OnewayDelayInMs"));
-
-  EXPECT_METRIC_EQ(1, metrics::NumEvents("WebRTC.Video.JitterBufferDelayInMs",
-                                         kJitterBufferMs));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.TargetDelayInMs", kTargetDelayMs));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.CurrentDelayInMs", kCurrentDelayMs));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.OnewayDelayInMs", kTargetDelayMs));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, DoesNotReportStaleFramerates) {
-  const int kDefaultFps = 30;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kDefaultFps; ++i) {
-    // Since OnRenderedFrame is never called the fps in each sample will be 0,
-    // i.e. bad
-    frame.set_ntp_time_ms(fake_clock_.CurrentNtpInMilliseconds());
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                      VideoContentType::UNSPECIFIED);
-    statistics_proxy_->OnRenderedFrame(frame);
-    fake_clock_.AdvanceTimeMilliseconds(1000 / kDefaultFps);
-  }
-
-  EXPECT_EQ(kDefaultFps, statistics_proxy_->GetStats().decode_frame_rate);
-  EXPECT_EQ(kDefaultFps, statistics_proxy_->GetStats().render_frame_rate);
-
-  // FPS trackers in stats proxy have a 1000ms sliding window.
-  fake_clock_.AdvanceTimeMilliseconds(1000);
-  EXPECT_EQ(0, statistics_proxy_->GetStats().decode_frame_rate);
-  EXPECT_EQ(0, statistics_proxy_->GetStats().render_frame_rate);
-}
-
-TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsReceivedFrameStats) {
-  EXPECT_EQ(0, statistics_proxy_->GetStats().width);
-  EXPECT_EQ(0, statistics_proxy_->GetStats().height);
-  EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_rendered);
-
-  statistics_proxy_->OnRenderedFrame(CreateFrame(kWidth, kHeight));
-
-  EXPECT_EQ(kWidth, statistics_proxy_->GetStats().width);
-  EXPECT_EQ(kHeight, statistics_proxy_->GetStats().height);
-  EXPECT_EQ(1u, statistics_proxy_->GetStats().frames_rendered);
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       ReceivedFrameHistogramsAreNotUpdatedForTooFewSamples) {
-  for (int i = 0; i < kMinRequiredSamples - 1; ++i)
-    statistics_proxy_->OnRenderedFrame(CreateFrame(kWidth, kHeight));
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.ReceivedWidthInPixels"));
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.ReceivedHeightInPixels"));
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.RenderFramesPerSecond"));
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.RenderSqrtPixelsPerSecond"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ReceivedFrameHistogramsAreUpdated) {
-  for (int i = 0; i < kMinRequiredSamples; ++i)
-    statistics_proxy_->OnRenderedFrame(CreateFrame(kWidth, kHeight));
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.ReceivedWidthInPixels"));
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.ReceivedHeightInPixels"));
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.RenderFramesPerSecond"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumSamples("WebRTC.Video.RenderSqrtPixelsPerSecond"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.ReceivedWidthInPixels", kWidth));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.ReceivedHeightInPixels", kHeight));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, ZeroDelayReportedIfFrameNotDelayed) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-
-  // Frame not delayed, delayed frames to render: 0%.
-  const int64_t kNowMs = fake_clock_.TimeInMilliseconds();
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs));
-
-  // Min run time has passed.
-  fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000));
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DelayedFramesToRenderer", 0));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples(
-                          "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       DelayedFrameHistogramsAreNotUpdatedIfMinRuntimeHasNotPassed) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-
-  // Frame not delayed, delayed frames to render: 0%.
-  const int64_t kNowMs = fake_clock_.TimeInMilliseconds();
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs));
-
-  // Min run time has not passed.
-  fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000) -
-                                      1);
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer"));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples(
-                          "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       DelayedFramesHistogramsAreNotUpdatedIfNoRenderedFrames) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-
-  // Min run time has passed. No rendered frames.
-  fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000));
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer"));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples(
-                          "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, DelayReportedIfFrameIsDelayed) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-
-  // Frame delayed 1 ms, delayed frames to render: 100%.
-  const int64_t kNowMs = fake_clock_.TimeInMilliseconds();
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs - 1));
-
-  // Min run time has passed.
-  fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000));
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DelayedFramesToRenderer", 100));
-  EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                          "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs",
-                            1));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, AverageDelayOfDelayedFramesIsReported) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0,
-                                    VideoContentType::UNSPECIFIED);
-
-  // Two frames delayed (6 ms, 10 ms), delayed frames to render: 50%.
-  const int64_t kNowMs = fake_clock_.TimeInMilliseconds();
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs - 10));
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs - 6));
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs));
-  statistics_proxy_->OnRenderedFrame(CreateFrameWithRenderTimeMs(kNowMs + 1));
-
-  // Min run time has passed.
-  fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000));
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DelayedFramesToRenderer", 50));
-  EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                          "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs",
-                            8));
-}
-
-TEST_F(ReceiveStatisticsProxyTest,
-       RtcpHistogramsNotUpdatedIfMinRuntimeHasNotPassed) {
-  StreamDataCounters data_counters;
-  data_counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
-
-  fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000) -
-                                      1);
-
-  RtcpPacketTypeCounter counter;
-  statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, data_counters, nullptr);
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.FirPacketsSentPerMinute"));
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.PliPacketsSentPerMinute"));
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.NackPacketsSentPerMinute"));
-}
-
-TEST_F(ReceiveStatisticsProxyTest, RtcpHistogramsAreUpdated) {
-  StreamDataCounters data_counters;
-  data_counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
-  fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000);
-
-  const uint32_t kFirPackets = 100;
-  const uint32_t kPliPackets = 200;
-  const uint32_t kNackPackets = 300;
-
-  RtcpPacketTypeCounter counter;
-  counter.fir_packets = kFirPackets;
-  counter.pli_packets = kPliPackets;
-  counter.nack_packets = kNackPackets;
-  statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, data_counters, nullptr);
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.FirPacketsSentPerMinute"));
-  EXPECT_METRIC_EQ(1,
-                   metrics::NumSamples("WebRTC.Video.PliPacketsSentPerMinute"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumSamples("WebRTC.Video.NackPacketsSentPerMinute"));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.FirPacketsSentPerMinute",
-                            kFirPackets * 60 / metrics::kMinRunTimeInSeconds));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.PliPacketsSentPerMinute",
-                            kPliPackets * 60 / metrics::kMinRunTimeInSeconds));
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.NackPacketsSentPerMinute",
-                            kNackPackets * 60 / metrics::kMinRunTimeInSeconds));
-}
-
-class ReceiveStatisticsProxyTestWithFreezeDuration
-    : public ReceiveStatisticsProxyTest,
-      public ::testing::WithParamInterface<
-          std::tuple<uint32_t, uint32_t, uint32_t>> {
- protected:
-  const uint32_t frame_duration_ms_ = {std::get<0>(GetParam())};
-  const uint32_t freeze_duration_ms_ = {std::get<1>(GetParam())};
-  const uint32_t expected_freeze_count_ = {std::get<2>(GetParam())};
-};
-
-// It is a freeze if:
-// frame_duration_ms >= max(3 * avg_frame_duration, avg_frame_duration + 150)
-// where avg_frame_duration is average duration of last 30 frames including
-// the current one.
-//
-// Condition 1: 3 * avg_frame_duration > avg_frame_duration + 150
-const auto kFreezeDetectionCond1Freeze = std::make_tuple(150, 483, 1);
-const auto kFreezeDetectionCond1NotFreeze = std::make_tuple(150, 482, 0);
-// Condition 2: 3 * avg_frame_duration < avg_frame_duration + 150
-const auto kFreezeDetectionCond2Freeze = std::make_tuple(30, 185, 1);
-const auto kFreezeDetectionCond2NotFreeze = std::make_tuple(30, 184, 0);
-
-INSTANTIATE_TEST_SUITE_P(_,
-                         ReceiveStatisticsProxyTestWithFreezeDuration,
-                         ::testing::Values(kFreezeDetectionCond1Freeze,
-                                           kFreezeDetectionCond1NotFreeze,
-                                           kFreezeDetectionCond2Freeze,
-                                           kFreezeDetectionCond2NotFreeze));
-
-TEST_P(ReceiveStatisticsProxyTestWithFreezeDuration, FreezeDetection) {
-  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(0u, stats.freeze_count);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  // Add a very long frame. This is need to verify that average frame
-  // duration, which is supposed to be calculated as mean of durations of
-  // last 30 frames, is calculated correctly.
-  statistics_proxy_->OnRenderedFrame(frame);
-  fake_clock_.AdvanceTimeMilliseconds(2000);
-
-  for (size_t i = 0;
-       i <= VideoQualityObserver::kAvgInterframeDelaysWindowSizeFrames; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(frame_duration_ms_);
-    statistics_proxy_->OnRenderedFrame(frame);
-  }
-
-  fake_clock_.AdvanceTimeMilliseconds(freeze_duration_ms_);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  stats = statistics_proxy_->GetStats();
-  EXPECT_EQ(stats.freeze_count, expected_freeze_count_);
-}
-
-class ReceiveStatisticsProxyTestWithContent
-    : public ReceiveStatisticsProxyTest,
-      public ::testing::WithParamInterface<webrtc::VideoContentType> {
- protected:
-  const webrtc::VideoContentType content_type_{GetParam()};
-};
-
-INSTANTIATE_TEST_SUITE_P(ContentTypes,
-                         ReceiveStatisticsProxyTestWithContent,
-                         ::testing::Values(VideoContentType::UNSPECIFIED,
-                                           VideoContentType::SCREENSHARE));
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, InterFrameDelaysAreReported) {
-  const int kInterFrameDelayMs = 33;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // One extra with double the interval.
-  fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  const int kExpectedInterFrame =
-      (kInterFrameDelayMs * (kMinRequiredSamples - 1) +
-       kInterFrameDelayMs * 2) /
-      kMinRequiredSamples;
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kExpectedInterFrame,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(
-        kInterFrameDelayMs * 2,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
-  } else {
-    EXPECT_METRIC_EQ(kExpectedInterFrame,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(kInterFrameDelayMs * 2,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayMaxInMs"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent,
-       InterFrameDelaysPercentilesAreReported) {
-  const int kInterFrameDelayMs = 33;
-  const int kLastFivePercentsSamples = kMinRequiredSamples * 5 / 100;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i <= kMinRequiredSamples - kLastFivePercentsSamples; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-  }
-  // Last 5% of intervals are double in size.
-  for (int i = 0; i < kLastFivePercentsSamples; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(2 * kInterFrameDelayMs);
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-  }
-  // Final sample is outlier and 10 times as big.
-  fake_clock_.AdvanceTimeMilliseconds(10 * kInterFrameDelayMs);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  const int kExpectedInterFrame = kInterFrameDelayMs * 2;
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kExpectedInterFrame,
-        metrics::MinSample(
-            "WebRTC.Video.Screenshare.InterframeDelay95PercentileInMs"));
-  } else {
-    EXPECT_METRIC_EQ(
-        kExpectedInterFrame,
-        metrics::MinSample("WebRTC.Video.InterframeDelay95PercentileInMs"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent,
-       MaxInterFrameDelayOnlyWithValidAverage) {
-  const int kInterFrameDelayMs = 33;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-
-  // `kMinRequiredSamples` samples, and thereby intervals, is required. That
-  // means we're one frame short of having a valid data set.
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(0, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs"));
-  EXPECT_METRIC_EQ(0,
-                   metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs"));
-  EXPECT_METRIC_EQ(
-      0, metrics::NumSamples("WebRTC.Video.Screenshare.InterframeDelayInMs"));
-  EXPECT_METRIC_EQ(0, metrics::NumSamples(
-                          "WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, MaxInterFrameDelayOnlyWithPause) {
-  const int kInterFrameDelayMs = 33;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i <= kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-
-  // At this state, we should have a valid inter-frame delay.
-  // Indicate stream paused and make a large jump in time.
-  statistics_proxy_->OnStreamInactive();
-  fake_clock_.AdvanceTimeMilliseconds(5000);
-
-  // Insert two more frames. The interval during the pause should be disregarded
-  // in the stats.
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-  fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.Screenshare.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                            "WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
-    EXPECT_METRIC_EQ(
-        kInterFrameDelayMs,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(
-        kInterFrameDelayMs,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
-  } else {
-    EXPECT_METRIC_EQ(1,
-                     metrics::NumSamples("WebRTC.Video.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs"));
-    EXPECT_METRIC_EQ(kInterFrameDelayMs,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(kInterFrameDelayMs,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayMaxInMs"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, FreezesAreReported) {
-  const int kInterFrameDelayMs = 33;
-  const int kFreezeDelayMs = 200;
-  const int kCallDurationMs =
-      kMinRequiredSamples * kInterFrameDelayMs + kFreezeDelayMs;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    statistics_proxy_->OnRenderedFrame(frame);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // Add extra freeze.
-  fake_clock_.AdvanceTimeMilliseconds(kFreezeDelayMs);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  const int kExpectedTimeBetweenFreezes =
-      kInterFrameDelayMs * (kMinRequiredSamples - 1);
-  const int kExpectedNumberFreezesPerMinute = 60 * 1000 / kCallDurationMs;
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kFreezeDelayMs + kInterFrameDelayMs,
-        metrics::MinSample("WebRTC.Video.Screenshare.MeanFreezeDurationMs"));
-    EXPECT_METRIC_EQ(kExpectedTimeBetweenFreezes,
-                     metrics::MinSample(
-                         "WebRTC.Video.Screenshare.MeanTimeBetweenFreezesMs"));
-    EXPECT_METRIC_EQ(
-        kExpectedNumberFreezesPerMinute,
-        metrics::MinSample("WebRTC.Video.Screenshare.NumberFreezesPerMinute"));
-  } else {
-    EXPECT_METRIC_EQ(kFreezeDelayMs + kInterFrameDelayMs,
-                     metrics::MinSample("WebRTC.Video.MeanFreezeDurationMs"));
-    EXPECT_METRIC_EQ(
-        kExpectedTimeBetweenFreezes,
-        metrics::MinSample("WebRTC.Video.MeanTimeBetweenFreezesMs"));
-    EXPECT_METRIC_EQ(kExpectedNumberFreezesPerMinute,
-                     metrics::MinSample("WebRTC.Video.NumberFreezesPerMinute"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, HarmonicFrameRateIsReported) {
-  const int kFrameDurationMs = 33;
-  const int kFreezeDurationMs = 200;
-  const int kPauseDurationMs = 10000;
-  const int kCallDurationMs = kMinRequiredSamples * kFrameDurationMs +
-                              kFreezeDurationMs + kPauseDurationMs;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(kFrameDurationMs);
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    statistics_proxy_->OnRenderedFrame(frame);
-  }
-
-  // Freezes and pauses should be included into harmonic frame rate.
-  // Add freeze.
-  fake_clock_.AdvanceTimeMilliseconds(kFreezeDurationMs);
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  // Add pause.
-  fake_clock_.AdvanceTimeMilliseconds(kPauseDurationMs);
-  statistics_proxy_->OnStreamInactive();
-  statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  double kSumSquaredFrameDurationSecs =
-      (kMinRequiredSamples - 1) *
-      (kFrameDurationMs / 1000.0 * kFrameDurationMs / 1000.0);
-  kSumSquaredFrameDurationSecs +=
-      kFreezeDurationMs / 1000.0 * kFreezeDurationMs / 1000.0;
-  kSumSquaredFrameDurationSecs +=
-      kPauseDurationMs / 1000.0 * kPauseDurationMs / 1000.0;
-  const int kExpectedHarmonicFrameRateFps =
-      std::round(kCallDurationMs / (1000 * kSumSquaredFrameDurationSecs));
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kExpectedHarmonicFrameRateFps,
-        metrics::MinSample("WebRTC.Video.Screenshare.HarmonicFrameRate"));
-  } else {
-    EXPECT_METRIC_EQ(kExpectedHarmonicFrameRateFps,
-                     metrics::MinSample("WebRTC.Video.HarmonicFrameRate"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, PausesAreIgnored) {
-  const int kInterFrameDelayMs = 33;
-  const int kPauseDurationMs = 10000;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i <= kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    statistics_proxy_->OnRenderedFrame(frame);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // Add a pause.
-  fake_clock_.AdvanceTimeMilliseconds(kPauseDurationMs);
-  statistics_proxy_->OnStreamInactive();
-
-  // Second playback interval with triple the length.
-  for (int i = 0; i <= kMinRequiredSamples * 3; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    statistics_proxy_->OnRenderedFrame(frame);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  // Average of two playback intervals.
-  const int kExpectedTimeBetweenFreezes =
-      kInterFrameDelayMs * kMinRequiredSamples * 2;
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(-1, metrics::MinSample(
-                             "WebRTC.Video.Screenshare.MeanFreezeDurationMs"));
-    EXPECT_METRIC_EQ(kExpectedTimeBetweenFreezes,
-                     metrics::MinSample(
-                         "WebRTC.Video.Screenshare.MeanTimeBetweenFreezesMs"));
-  } else {
-    EXPECT_METRIC_EQ(-1,
-                     metrics::MinSample("WebRTC.Video.MeanFreezeDurationMs"));
-    EXPECT_METRIC_EQ(
-        kExpectedTimeBetweenFreezes,
-        metrics::MinSample("WebRTC.Video.MeanTimeBetweenFreezesMs"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, ManyPausesAtTheBeginning) {
-  const int kInterFrameDelayMs = 33;
-  const int kPauseDurationMs = 10000;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i <= kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-
-    statistics_proxy_->OnStreamInactive();
-    fake_clock_.AdvanceTimeMilliseconds(kPauseDurationMs);
-
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type_);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  // No freezes should be detected, as all long inter-frame delays were pauses.
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(-1, metrics::MinSample(
-                             "WebRTC.Video.Screenshare.MeanFreezeDurationMs"));
-  } else {
-    EXPECT_METRIC_EQ(-1,
-                     metrics::MinSample("WebRTC.Video.MeanFreezeDurationMs"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, TimeInHdReported) {
-  const int kInterFrameDelayMs = 20;
-  webrtc::VideoFrame frame_hd = CreateFrame(1280, 720);
-  webrtc::VideoFrame frame_sd = CreateFrame(640, 360);
-
-  // HD frames.
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame_hd, absl::nullopt, 0,
-                                      content_type_);
-    statistics_proxy_->OnRenderedFrame(frame_hd);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // SD frames.
-  for (int i = 0; i < 2 * kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame_sd, absl::nullopt, 0,
-                                      content_type_);
-    statistics_proxy_->OnRenderedFrame(frame_sd);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // Extra last frame.
-  statistics_proxy_->OnRenderedFrame(frame_sd);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  const int kExpectedTimeInHdPercents = 33;
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kExpectedTimeInHdPercents,
-        metrics::MinSample("WebRTC.Video.Screenshare.TimeInHdPercentage"));
-  } else {
-    EXPECT_METRIC_EQ(kExpectedTimeInHdPercents,
-                     metrics::MinSample("WebRTC.Video.TimeInHdPercentage"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, TimeInBlockyVideoReported) {
-  const int kInterFrameDelayMs = 20;
-  const int kHighQp = 80;
-  const int kLowQp = 30;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  // High quality frames.
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, kLowQp, 0, content_type_);
-    statistics_proxy_->OnRenderedFrame(frame);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // Blocky frames.
-  for (int i = 0; i < 2 * kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, kHighQp, 0, content_type_);
-    statistics_proxy_->OnRenderedFrame(frame);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  // Extra last frame.
-  statistics_proxy_->OnDecodedFrame(frame, kHighQp, 0, content_type_);
-  statistics_proxy_->OnRenderedFrame(frame);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  const int kExpectedTimeInHdPercents = 66;
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kExpectedTimeInHdPercents,
-        metrics::MinSample(
-            "WebRTC.Video.Screenshare.TimeInBlockyVideoPercentage"));
-  } else {
-    EXPECT_METRIC_EQ(
-        kExpectedTimeInHdPercents,
-        metrics::MinSample("WebRTC.Video.TimeInBlockyVideoPercentage"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, DownscalesReported) {
-  const int kInterFrameDelayMs = 2000;  // To ensure long enough call duration.
-
-  webrtc::VideoFrame frame_hd = CreateFrame(1280, 720);
-  webrtc::VideoFrame frame_sd = CreateFrame(640, 360);
-  webrtc::VideoFrame frame_ld = CreateFrame(320, 180);
-
-  // Call once to pass content type.
-  statistics_proxy_->OnDecodedFrame(frame_hd, absl::nullopt, 0, content_type_);
-
-  statistics_proxy_->OnRenderedFrame(frame_hd);
-  fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-
-  // Downscale.
-  statistics_proxy_->OnRenderedFrame(frame_sd);
-  fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-
-  // Downscale.
-  statistics_proxy_->OnRenderedFrame(frame_ld);
-  fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  const int kExpectedDownscales = 30;  // 2 per 4 seconds = 30 per minute.
-  if (videocontenttypehelpers::IsScreenshare(content_type_)) {
-    EXPECT_METRIC_EQ(
-        kExpectedDownscales,
-        metrics::MinSample(
-            "WebRTC.Video.Screenshare.NumberResolutionDownswitchesPerMinute"));
-  } else {
-    EXPECT_METRIC_EQ(kExpectedDownscales,
-                     metrics::MinSample(
-                         "WebRTC.Video.NumberResolutionDownswitchesPerMinute"));
-  }
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent, DecodeTimeReported) {
-  const int kInterFrameDelayMs = 20;
-  const int kLowQp = 30;
-  const int kDecodeMs = 7;
-
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  for (int i = 0; i < kMinRequiredSamples; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, kLowQp, kDecodeMs, content_type_);
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs);
-  }
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-  EXPECT_METRIC_EQ(
-      1, metrics::NumEvents("WebRTC.Video.DecodeTimeInMs", kDecodeMs));
-}
-
-TEST_P(ReceiveStatisticsProxyTestWithContent,
-       StatsAreSlicedOnSimulcastAndExperiment) {
-  const uint8_t experiment_id = 1;
-  webrtc::VideoContentType content_type = content_type_;
-  videocontenttypehelpers::SetExperimentId(&content_type, experiment_id);
-  const int kInterFrameDelayMs1 = 30;
-  const int kInterFrameDelayMs2 = 50;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
-
-  videocontenttypehelpers::SetSimulcastId(&content_type, 1);
-  for (int i = 0; i <= kMinRequiredSamples; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs1);
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type);
-  }
-
-  videocontenttypehelpers::SetSimulcastId(&content_type, 2);
-  for (int i = 0; i <= kMinRequiredSamples; ++i) {
-    fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs2);
-    statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, 0, content_type);
-  }
-  statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(),
-                                      nullptr);
-
-  if (videocontenttypehelpers::IsScreenshare(content_type)) {
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.Screenshare.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                            "WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
-    EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                            "WebRTC.Video.Screenshare.InterframeDelayInMs.S0"));
-    EXPECT_METRIC_EQ(1,
-                     metrics::NumSamples(
-                         "WebRTC.Video.Screenshare.InterframeDelayMaxInMs.S0"));
-    EXPECT_METRIC_EQ(1, metrics::NumSamples(
-                            "WebRTC.Video.Screenshare.InterframeDelayInMs.S1"));
-    EXPECT_METRIC_EQ(1,
-                     metrics::NumSamples(
-                         "WebRTC.Video.Screenshare.InterframeDelayMaxInMs.S1"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.Screenshare.InterframeDelayInMs"
-                               ".ExperimentGroup0"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.Screenshare.InterframeDelayMaxInMs"
-                               ".ExperimentGroup0"));
-    EXPECT_METRIC_EQ(
-        kInterFrameDelayMs1,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs.S0"));
-    EXPECT_METRIC_EQ(
-        kInterFrameDelayMs2,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs.S1"));
-    EXPECT_METRIC_EQ(
-        (kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(
-        kInterFrameDelayMs2,
-        metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
-    EXPECT_METRIC_EQ(
-        (kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2,
-        metrics::MinSample(
-            "WebRTC.Video.Screenshare.InterframeDelayInMs.ExperimentGroup0"));
-  } else {
-    EXPECT_METRIC_EQ(1,
-                     metrics::NumSamples("WebRTC.Video.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs.S0"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs.S0"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs.S1"));
-    EXPECT_METRIC_EQ(
-        1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs.S1"));
-    EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs"
-                                            ".ExperimentGroup0"));
-    EXPECT_METRIC_EQ(1,
-                     metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs"
-                                         ".ExperimentGroup0"));
-    EXPECT_METRIC_EQ(kInterFrameDelayMs1,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayInMs.S0"));
-    EXPECT_METRIC_EQ(kInterFrameDelayMs2,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayInMs.S1"));
-    EXPECT_METRIC_EQ((kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayInMs"));
-    EXPECT_METRIC_EQ(kInterFrameDelayMs2,
-                     metrics::MinSample("WebRTC.Video.InterframeDelayMaxInMs"));
-    EXPECT_METRIC_EQ((kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2,
-                     metrics::MinSample(
-                         "WebRTC.Video.InterframeDelayInMs.ExperimentGroup0"));
-  }
-}
-
-class ReceiveStatisticsProxyTestWithDecodeTimeHistograms
-    : public ::testing::WithParamInterface<
-          std::tuple<bool, int, int, int, VideoCodecType, std::string>>,
-      public ReceiveStatisticsProxyTest {
- public:
-  ReceiveStatisticsProxyTestWithDecodeTimeHistograms()
-      : ReceiveStatisticsProxyTest(
-            std::get<0>(GetParam())
-                ? "WebRTC-DecodeTimeHistogramsKillSwitch/Enabled/"
-                : "") {}
-
- protected:
-  const std::string kUmaPrefix = "WebRTC.Video.DecodeTimePerFrameInMs.";
-  const int expected_number_of_samples_ = {std::get<1>(GetParam())};
-  const int width_ = {std::get<2>(GetParam())};
-  const int height_ = {std::get<3>(GetParam())};
-  const VideoCodecType codec_type_ = {std::get<4>(GetParam())};
-  const std::string implementation_name_ = {std::get<5>(GetParam())};
-  const std::string uma_histogram_name_ =
-      kUmaPrefix + (codec_type_ == kVideoCodecVP9 ? "Vp9." : "H264.") +
-      (height_ == 2160 ? "4k." : "Hd.") +
-      (implementation_name_.compare("ExternalDecoder") == 0 ? "Hw" : "Sw");
-};
-
-TEST_P(ReceiveStatisticsProxyTestWithDecodeTimeHistograms,
-       DecodeTimeHistogramsUpdated) {
-  constexpr int kNumberOfFrames = 10;
-  constexpr int kDecodeTimeMs = 7;
-  constexpr int kFrameDurationMs = 1000 / 60;
-
-  webrtc::VideoFrame frame = CreateFrame(width_, height_);
-
-  statistics_proxy_->OnDecoderImplementationName(implementation_name_.c_str());
-  statistics_proxy_->OnPreDecode(codec_type_, /*qp=*/0);
-
-  for (int i = 0; i < kNumberOfFrames; ++i) {
-    statistics_proxy_->OnDecodedFrame(frame, /*qp=*/absl::nullopt,
-                                      kDecodeTimeMs,
-                                      VideoContentType::UNSPECIFIED);
-    fake_clock_.AdvanceTimeMilliseconds(kFrameDurationMs);
-  }
-
-  EXPECT_METRIC_EQ(expected_number_of_samples_,
-                   metrics::NumSamples(uma_histogram_name_));
-  EXPECT_METRIC_EQ(expected_number_of_samples_,
-                   metrics::NumEvents(uma_histogram_name_, kDecodeTimeMs));
-}
-
-const auto kVp94kHw = std::make_tuple(/*killswitch=*/false,
-                                      /*expected_number_of_samples=*/10,
-                                      /*width=*/3840,
-                                      /*height=*/2160,
-                                      kVideoCodecVP9,
-                                      /*implementation=*/"ExternalDecoder");
-const auto kVp94kSw = std::make_tuple(/*killswitch=*/false,
-                                      /*expected_number_of_samples=*/10,
-                                      /*width=*/3840,
-                                      /*height=*/2160,
-                                      kVideoCodecVP9,
-                                      /*implementation=*/"libvpx");
-const auto kVp9HdHw = std::make_tuple(/*killswitch=*/false,
-                                      /*expected_number_of_samples=*/10,
-                                      /*width=*/1920,
-                                      /*height=*/1080,
-                                      kVideoCodecVP9,
-                                      /*implementation=*/"ExternalDecoder");
-const auto kVp9HdSw = std::make_tuple(/*killswitch=*/false,
-                                      /*expected_number_of_samples=*/10,
-                                      /*width=*/1920,
-                                      /*height=*/1080,
-                                      kVideoCodecVP9,
-                                      /*implementation=*/"libvpx");
-const auto kH2644kHw = std::make_tuple(/*killswitch=*/false,
-                                       /*expected_number_of_samples=*/10,
-                                       /*width=*/3840,
-                                       /*height=*/2160,
-                                       kVideoCodecH264,
-                                       /*implementation=*/"ExternalDecoder");
-const auto kH2644kSw = std::make_tuple(/*killswitch=*/false,
-                                       /*expected_number_of_samples=*/10,
-                                       /*width=*/3840,
-                                       /*height=*/2160,
-                                       kVideoCodecH264,
-                                       /*implementation=*/"FFmpeg");
-const auto kH264HdHw = std::make_tuple(/*killswitch=*/false,
-                                       /*expected_number_of_samples=*/10,
-                                       /*width=*/1920,
-                                       /*height=*/1080,
-                                       kVideoCodecH264,
-                                       /*implementation=*/"ExternalDecoder");
-const auto kH264HdSw = std::make_tuple(/*killswitch=*/false,
-                                       /*expected_number_of_samples=*/10,
-                                       /*width=*/1920,
-                                       /*height=*/1080,
-                                       kVideoCodecH264,
-                                       /*implementation=*/"FFmpeg");
-
-INSTANTIATE_TEST_SUITE_P(AllHistogramsPopulated,
-                         ReceiveStatisticsProxyTestWithDecodeTimeHistograms,
-                         ::testing::Values(kVp94kHw,
-                                           kVp94kSw,
-                                           kVp9HdHw,
-                                           kVp9HdSw,
-                                           kH2644kHw,
-                                           kH2644kSw,
-                                           kH264HdHw,
-                                           kH264HdSw));
-
-const auto kKillswitchDisabled =
-    std::make_tuple(/*killswitch=*/false,
-                    /*expected_number_of_samples=*/10,
-                    /*width=*/1920,
-                    /*height=*/1080,
-                    kVideoCodecVP9,
-                    /*implementation=*/"libvpx");
-const auto kKillswitchEnabled =
-    std::make_tuple(/*killswitch=*/true,
-                    /*expected_number_of_samples=*/0,
-                    /*width=*/1920,
-                    /*height=*/1080,
-                    kVideoCodecVP9,
-                    /*implementation=*/"libvpx");
-
-INSTANTIATE_TEST_SUITE_P(KillswitchEffective,
-                         ReceiveStatisticsProxyTestWithDecodeTimeHistograms,
-                         ::testing::Values(kKillswitchDisabled,
-                                           kKillswitchEnabled));
-
-}  // namespace webrtc
diff --git a/video/video_quality_observer.cc b/video/video_quality_observer.cc
deleted file mode 100644
index be7b08c..0000000
--- a/video/video_quality_observer.cc
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "video/video_quality_observer.h"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <string>
-
-#include "rtc_base/logging.h"
-#include "rtc_base/strings/string_builder.h"
-#include "system_wrappers/include/metrics.h"
-
-namespace webrtc {
-const uint32_t VideoQualityObserver::kMinFrameSamplesToDetectFreeze = 5;
-const uint32_t VideoQualityObserver::kMinIncreaseForFreezeMs = 150;
-const uint32_t VideoQualityObserver::kAvgInterframeDelaysWindowSizeFrames = 30;
-
-namespace {
-constexpr int kMinVideoDurationMs = 3000;
-constexpr int kMinRequiredSamples = 1;
-constexpr int kPixelsInHighResolution =
-    960 * 540;  // CPU-adapted HD still counts.
-constexpr int kPixelsInMediumResolution = 640 * 360;
-constexpr int kBlockyQpThresholdVp8 = 70;
-constexpr int kBlockyQpThresholdVp9 = 180;
-constexpr int kMaxNumCachedBlockyFrames = 100;
-// TODO(ilnik): Add H264/HEVC thresholds.
-}  // namespace
-
-VideoQualityObserver::VideoQualityObserver(VideoContentType content_type)
-    : last_frame_rendered_ms_(-1),
-      num_frames_rendered_(0),
-      first_frame_rendered_ms_(-1),
-      last_frame_pixels_(0),
-      is_last_frame_blocky_(false),
-      last_unfreeze_time_ms_(0),
-      render_interframe_delays_(kAvgInterframeDelaysWindowSizeFrames),
-      sum_squared_interframe_delays_secs_(0.0),
-      time_in_resolution_ms_(3, 0),
-      current_resolution_(Resolution::Low),
-      num_resolution_downgrades_(0),
-      time_in_blocky_video_ms_(0),
-      content_type_(content_type),
-      is_paused_(false) {}
-
-void VideoQualityObserver::UpdateHistograms() {
-  // Don't report anything on an empty video stream.
-  if (num_frames_rendered_ == 0) {
-    return;
-  }
-
-  char log_stream_buf[2 * 1024];
-  rtc::SimpleStringBuilder log_stream(log_stream_buf);
-
-  if (last_frame_rendered_ms_ > last_unfreeze_time_ms_) {
-    smooth_playback_durations_.Add(last_frame_rendered_ms_ -
-                                   last_unfreeze_time_ms_);
-  }
-
-  std::string uma_prefix = videocontenttypehelpers::IsScreenshare(content_type_)
-                               ? "WebRTC.Video.Screenshare"
-                               : "WebRTC.Video";
-
-  auto mean_time_between_freezes =
-      smooth_playback_durations_.Avg(kMinRequiredSamples);
-  if (mean_time_between_freezes) {
-    RTC_HISTOGRAM_COUNTS_SPARSE_100000(uma_prefix + ".MeanTimeBetweenFreezesMs",
-                                       *mean_time_between_freezes);
-    log_stream << uma_prefix << ".MeanTimeBetweenFreezesMs "
-               << *mean_time_between_freezes << "\n";
-  }
-  auto avg_freeze_length = freezes_durations_.Avg(kMinRequiredSamples);
-  if (avg_freeze_length) {
-    RTC_HISTOGRAM_COUNTS_SPARSE_100000(uma_prefix + ".MeanFreezeDurationMs",
-                                       *avg_freeze_length);
-    log_stream << uma_prefix << ".MeanFreezeDurationMs " << *avg_freeze_length
-               << "\n";
-  }
-
-  int64_t video_duration_ms =
-      last_frame_rendered_ms_ - first_frame_rendered_ms_;
-
-  if (video_duration_ms >= kMinVideoDurationMs) {
-    int time_spent_in_hd_percentage = static_cast<int>(
-        time_in_resolution_ms_[Resolution::High] * 100 / video_duration_ms);
-    RTC_HISTOGRAM_COUNTS_SPARSE_100(uma_prefix + ".TimeInHdPercentage",
-                                    time_spent_in_hd_percentage);
-    log_stream << uma_prefix << ".TimeInHdPercentage "
-               << time_spent_in_hd_percentage << "\n";
-
-    int time_with_blocky_video_percentage =
-        static_cast<int>(time_in_blocky_video_ms_ * 100 / video_duration_ms);
-    RTC_HISTOGRAM_COUNTS_SPARSE_100(uma_prefix + ".TimeInBlockyVideoPercentage",
-                                    time_with_blocky_video_percentage);
-    log_stream << uma_prefix << ".TimeInBlockyVideoPercentage "
-               << time_with_blocky_video_percentage << "\n";
-
-    int num_resolution_downgrades_per_minute =
-        num_resolution_downgrades_ * 60000 / video_duration_ms;
-    RTC_HISTOGRAM_COUNTS_SPARSE_100(
-        uma_prefix + ".NumberResolutionDownswitchesPerMinute",
-        num_resolution_downgrades_per_minute);
-    log_stream << uma_prefix << ".NumberResolutionDownswitchesPerMinute "
-               << num_resolution_downgrades_per_minute << "\n";
-
-    int num_freezes_per_minute =
-        freezes_durations_.NumSamples() * 60000 / video_duration_ms;
-    RTC_HISTOGRAM_COUNTS_SPARSE_100(uma_prefix + ".NumberFreezesPerMinute",
-                                    num_freezes_per_minute);
-    log_stream << uma_prefix << ".NumberFreezesPerMinute "
-               << num_freezes_per_minute << "\n";
-
-    if (sum_squared_interframe_delays_secs_ > 0.0) {
-      int harmonic_framerate_fps = std::round(
-          video_duration_ms / (1000 * sum_squared_interframe_delays_secs_));
-      RTC_HISTOGRAM_COUNTS_SPARSE_100(uma_prefix + ".HarmonicFrameRate",
-                                      harmonic_framerate_fps);
-      log_stream << uma_prefix << ".HarmonicFrameRate "
-                 << harmonic_framerate_fps << "\n";
-    }
-  }
-  RTC_LOG(LS_INFO) << log_stream.str();
-}
-
-void VideoQualityObserver::OnRenderedFrame(const VideoFrame& frame,
-                                           int64_t now_ms) {
-  RTC_DCHECK_LE(last_frame_rendered_ms_, now_ms);
-  RTC_DCHECK_LE(last_unfreeze_time_ms_, now_ms);
-
-  if (num_frames_rendered_ == 0) {
-    first_frame_rendered_ms_ = last_unfreeze_time_ms_ = now_ms;
-  }
-
-  auto blocky_frame_it = blocky_frames_.find(frame.timestamp());
-
-  if (num_frames_rendered_ > 0) {
-    // Process inter-frame delay.
-    const int64_t interframe_delay_ms = now_ms - last_frame_rendered_ms_;
-    const double interframe_delays_secs = interframe_delay_ms / 1000.0;
-
-    // Sum of squared inter frame intervals is used to calculate the harmonic
-    // frame rate metric. The metric aims to reflect overall experience related
-    // to smoothness of video playback and includes both freezes and pauses.
-    sum_squared_interframe_delays_secs_ +=
-        interframe_delays_secs * interframe_delays_secs;
-
-    if (!is_paused_) {
-      render_interframe_delays_.AddSample(interframe_delay_ms);
-
-      bool was_freeze = false;
-      if (render_interframe_delays_.Size() >= kMinFrameSamplesToDetectFreeze) {
-        const absl::optional<int64_t> avg_interframe_delay =
-            render_interframe_delays_.GetAverageRoundedDown();
-        RTC_DCHECK(avg_interframe_delay);
-        was_freeze = interframe_delay_ms >=
-                     std::max(3 * *avg_interframe_delay,
-                              *avg_interframe_delay + kMinIncreaseForFreezeMs);
-      }
-
-      if (was_freeze) {
-        freezes_durations_.Add(interframe_delay_ms);
-        smooth_playback_durations_.Add(last_frame_rendered_ms_ -
-                                       last_unfreeze_time_ms_);
-        last_unfreeze_time_ms_ = now_ms;
-      } else {
-        // Count spatial metrics if there were no freeze.
-        time_in_resolution_ms_[current_resolution_] += interframe_delay_ms;
-
-        if (is_last_frame_blocky_) {
-          time_in_blocky_video_ms_ += interframe_delay_ms;
-        }
-      }
-    }
-  }
-
-  if (is_paused_) {
-    // If the stream was paused since the previous frame, do not count the
-    // pause toward smooth playback. Explicitly count the part before it and
-    // start the new smooth playback interval from this frame.
-    is_paused_ = false;
-    if (last_frame_rendered_ms_ > last_unfreeze_time_ms_) {
-      smooth_playback_durations_.Add(last_frame_rendered_ms_ -
-                                     last_unfreeze_time_ms_);
-    }
-    last_unfreeze_time_ms_ = now_ms;
-
-    if (num_frames_rendered_ > 0) {
-      pauses_durations_.Add(now_ms - last_frame_rendered_ms_);
-    }
-  }
-
-  int64_t pixels = frame.width() * frame.height();
-  if (pixels >= kPixelsInHighResolution) {
-    current_resolution_ = Resolution::High;
-  } else if (pixels >= kPixelsInMediumResolution) {
-    current_resolution_ = Resolution::Medium;
-  } else {
-    current_resolution_ = Resolution::Low;
-  }
-
-  if (pixels < last_frame_pixels_) {
-    ++num_resolution_downgrades_;
-  }
-
-  last_frame_pixels_ = pixels;
-  last_frame_rendered_ms_ = now_ms;
-
-  is_last_frame_blocky_ = blocky_frame_it != blocky_frames_.end();
-  if (is_last_frame_blocky_) {
-    blocky_frames_.erase(blocky_frames_.begin(), ++blocky_frame_it);
-  }
-
-  ++num_frames_rendered_;
-}
-
-void VideoQualityObserver::OnDecodedFrame(const VideoFrame& frame,
-                                          absl::optional<uint8_t> qp,
-                                          VideoCodecType codec) {
-  if (qp) {
-    absl::optional<int> qp_blocky_threshold;
-    // TODO(ilnik): add other codec types when we have QP for them.
-    switch (codec) {
-      case kVideoCodecVP8:
-        qp_blocky_threshold = kBlockyQpThresholdVp8;
-        break;
-      case kVideoCodecVP9:
-        qp_blocky_threshold = kBlockyQpThresholdVp9;
-        break;
-      default:
-        qp_blocky_threshold = absl::nullopt;
-    }
-
-    RTC_DCHECK(blocky_frames_.find(frame.timestamp()) == blocky_frames_.end());
-
-    if (qp_blocky_threshold && *qp > *qp_blocky_threshold) {
-      // Cache blocky frame. Its duration will be calculated in render callback.
-      if (blocky_frames_.size() > kMaxNumCachedBlockyFrames) {
-        RTC_LOG(LS_WARNING) << "Overflow of blocky frames cache.";
-        blocky_frames_.erase(
-            blocky_frames_.begin(),
-            std::next(blocky_frames_.begin(), kMaxNumCachedBlockyFrames / 2));
-      }
-
-      blocky_frames_.insert(frame.timestamp());
-    }
-  }
-}
-
-void VideoQualityObserver::OnStreamInactive() {
-  is_paused_ = true;
-}
-
-uint32_t VideoQualityObserver::NumFreezes() const {
-  return freezes_durations_.NumSamples();
-}
-
-uint32_t VideoQualityObserver::NumPauses() const {
-  return pauses_durations_.NumSamples();
-}
-
-uint32_t VideoQualityObserver::TotalFreezesDurationMs() const {
-  return freezes_durations_.Sum(kMinRequiredSamples).value_or(0);
-}
-
-uint32_t VideoQualityObserver::TotalPausesDurationMs() const {
-  return pauses_durations_.Sum(kMinRequiredSamples).value_or(0);
-}
-
-uint32_t VideoQualityObserver::TotalFramesDurationMs() const {
-  return last_frame_rendered_ms_ - first_frame_rendered_ms_;
-}
-
-double VideoQualityObserver::SumSquaredFrameDurationsSec() const {
-  return sum_squared_interframe_delays_secs_;
-}
-
-}  // namespace webrtc
diff --git a/video/video_quality_observer.h b/video/video_quality_observer.h
deleted file mode 100644
index 6494a6f..0000000
--- a/video/video_quality_observer.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef VIDEO_VIDEO_QUALITY_OBSERVER_H_
-#define VIDEO_VIDEO_QUALITY_OBSERVER_H_
-
-#include <stdint.h>
-
-#include <set>
-#include <vector>
-
-#include "absl/types/optional.h"
-#include "api/video/video_codec_type.h"
-#include "api/video/video_content_type.h"
-#include "api/video/video_frame.h"
-#include "rtc_base/numerics/moving_average.h"
-#include "rtc_base/numerics/sample_counter.h"
-
-namespace webrtc {
-
-// Calculates spatial and temporal quality metrics and reports them to UMA
-// stats.
-class VideoQualityObserver {
- public:
-  // Use either VideoQualityObserver::kBlockyQpThresholdVp8 or
-  // VideoQualityObserver::kBlockyQpThresholdVp9.
-  explicit VideoQualityObserver(VideoContentType content_type);
-  ~VideoQualityObserver() = default;
-
-  void OnDecodedFrame(const VideoFrame& frame,
-                      absl::optional<uint8_t> qp,
-                      VideoCodecType codec);
-
-  void OnRenderedFrame(const VideoFrame& frame, int64_t now_ms);
-
-  void OnStreamInactive();
-
-  uint32_t NumFreezes() const;
-  uint32_t NumPauses() const;
-  uint32_t TotalFreezesDurationMs() const;
-  uint32_t TotalPausesDurationMs() const;
-  uint32_t TotalFramesDurationMs() const;
-  double SumSquaredFrameDurationsSec() const;
-
-  void UpdateHistograms();
-
-  static const uint32_t kMinFrameSamplesToDetectFreeze;
-  static const uint32_t kMinIncreaseForFreezeMs;
-  static const uint32_t kAvgInterframeDelaysWindowSizeFrames;
-
- private:
-  enum Resolution {
-    Low = 0,
-    Medium = 1,
-    High = 2,
-  };
-
-  int64_t last_frame_rendered_ms_;
-  int64_t num_frames_rendered_;
-  int64_t first_frame_rendered_ms_;
-  int64_t last_frame_pixels_;
-  bool is_last_frame_blocky_;
-  // Decoded timestamp of the last delayed frame.
-  int64_t last_unfreeze_time_ms_;
-  rtc::MovingAverage render_interframe_delays_;
-  double sum_squared_interframe_delays_secs_;
-  // An inter-frame delay is counted as a freeze if it's significantly longer
-  // than average inter-frame delay.
-  rtc::SampleCounter freezes_durations_;
-  rtc::SampleCounter pauses_durations_;
-  // Time between freezes.
-  rtc::SampleCounter smooth_playback_durations_;
-  // Counters for time spent in different resolutions. Time between each two
-  // Consecutive frames is counted to bin corresponding to the first frame
-  // resolution.
-  std::vector<int64_t> time_in_resolution_ms_;
-  // Resolution of the last decoded frame. Resolution enum is used as an index.
-  Resolution current_resolution_;
-  int num_resolution_downgrades_;
-  // Similar to resolution, time spent in high-QP video.
-  int64_t time_in_blocky_video_ms_;
-  // Content type of the last decoded frame.
-  VideoContentType content_type_;
-  bool is_paused_;
-
-  // Set of decoded frames with high QP value.
-  std::set<int64_t> blocky_frames_;
-};
-
-}  // namespace webrtc
-
-#endif  // VIDEO_VIDEO_QUALITY_OBSERVER_H_