diff --git a/video/receive_statistics_proxy.cc b/video/receive_statistics_proxy.cc
index 42ab7e1..d8bde94 100644
--- a/video/receive_statistics_proxy.cc
+++ b/video/receive_statistics_proxy.cc
@@ -20,6 +20,7 @@
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/time_utils.h"
 #include "system_wrappers/include/clock.h"
+#include "system_wrappers/include/field_trial.h"
 #include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
@@ -85,6 +86,8 @@
     : clock_(clock),
       config_(*config),
       start_ms_(clock->TimeInMilliseconds()),
+      enable_decode_time_histograms_(
+          !field_trial::IsEnabled("WebRTC-DecodeTimeHistogramsKillSwitch")),
       last_sample_time_(clock->TimeInMilliseconds()),
       fps_threshold_(kLowFpsThreshold,
                      kHighFpsThreshold,
@@ -553,6 +556,61 @@
   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);
+      }
+    }
+  }
+}
+
 VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
   rtc::CritScope lock(&crit_);
   // Get current frame rates here, as only updating them on new frames prevents
@@ -697,6 +755,10 @@
   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_) {
diff --git a/video/receive_statistics_proxy.h b/video/receive_statistics_proxy.h
index 9c3a117..40608a8 100644
--- a/video/receive_statistics_proxy.h
+++ b/video/receive_statistics_proxy.h
@@ -128,6 +128,11 @@
   void UpdateFramerate(int64_t now_ms) const
       RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
+  void UpdateDecodeTimeHistograms(int width,
+                                  int height,
+                                  int decode_time_ms) const
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+
   Clock* const clock_;
   // Ownership of this object lies with the owner of the ReceiveStatisticsProxy
   // instance.  Lifetime is guaranteed to outlive |this|.
@@ -138,6 +143,7 @@
   // then no longer store a pointer to the object).
   const VideoReceiveStream::Config& config_;
   const int64_t start_ms_;
+  const bool enable_decode_time_histograms_;
 
   rtc::CriticalSection crit_;
   int64_t last_sample_time_ RTC_GUARDED_BY(crit_);
diff --git a/video/receive_statistics_proxy_unittest.cc b/video/receive_statistics_proxy_unittest.cc
index fffc42c..66adb83 100644
--- a/video/receive_statistics_proxy_unittest.cc
+++ b/video/receive_statistics_proxy_unittest.cc
@@ -16,12 +16,14 @@
 #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/field_trial.h"
 #include "test/gtest.h"
 
 namespace webrtc {
@@ -1548,4 +1550,142 @@
                   "WebRTC.Video.InterframeDelayInMs.ExperimentGroup0"));
   }
 }
+
+class DecodeTimeHistogramsKillswitch {
+ public:
+  explicit DecodeTimeHistogramsKillswitch(bool disable_histograms)
+      : field_trial_(disable_histograms
+                         ? "WebRTC-DecodeTimeHistogramsKillSwitch/Enabled/"
+                         : "") {}
+
+ private:
+  webrtc::test::ScopedFieldTrials field_trial_;
+};
+
+class ReceiveStatisticsProxyTestWithDecodeTimeHistograms
+    : public DecodeTimeHistogramsKillswitch,
+      public ::testing::WithParamInterface<
+          std::tuple<bool, int, int, int, VideoCodecType, std::string>>,
+      public ReceiveStatisticsProxyTest {
+ public:
+  ReceiveStatisticsProxyTestWithDecodeTimeHistograms()
+      : DecodeTimeHistogramsKillswitch(std::get<0>(GetParam())) {}
+
+ 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_EQ(expected_number_of_samples_,
+            metrics::NumSamples(uma_histogram_name_));
+  EXPECT_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