Report video and network stats averaged over 1s, and create corresponding UMA metrics.

remoting/client/software_video_renderer.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/client/software_video_renderer.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/base/util.h"
 #include "remoting/client/frame_consumer.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
 #include "remoting/protocol/session_config.h"
 #include "third_party/libyuv/include/libyuv/convert_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
@@ skipping 331 matching lines @@
   if (!packet->has_data() || packet->data().size() == 0) {
     done.Run();
     return;
   }
 
   // Add one frame to the counter.
   stats_.video_frame_rate()->Record(1);
 
   // Record other statistics received from host.
   stats_.video_bandwidth()->Record(packet->data().size());
-  if (packet->has_capture_time_ms())
+  if (packet->has_capture_time_ms()) {
     stats_.video_capture_ms()->Record(packet->capture_time_ms());
-  if (packet->has_encode_time_ms())
+    const base::TimeDelta capture_time =
+        base::TimeDelta::FromInternalValue(packet->capture_time_ms());
+    UMA_HISTOGRAM_TIMES("Chromoting.Video.CaptureLatency", capture_time);
+  }
+  if (packet->has_encode_time_ms()) {
     stats_.video_encode_ms()->Record(packet->encode_time_ms());
+    const base::TimeDelta encode_time =
+        base::TimeDelta::FromInternalValue(packet->encode_time_ms());
+    UMA_HISTOGRAM_TIMES("Chromoting.Video.EncodeLatency", encode_time);
+  }
   if (packet->has_latest_event_timestamp() &&
       packet->latest_event_timestamp() > latest_event_timestamp_) {
     latest_event_timestamp_ = packet->latest_event_timestamp();
     base::TimeDelta round_trip_latency =
         base::Time::Now() -
         base::Time::FromInternalValue(packet->latest_event_timestamp());
     stats_.round_trip_ms()->Record(round_trip_latency.InMilliseconds());
+    UMA_HISTOGRAM_TIMES("Chromoting.Video.RoundTripLatency",
+      round_trip_latency);
   }
 
   // Measure the latency between the last packet being received and presented.
   base::Time decode_start = base::Time::Now();
 
   base::Closure decode_done = base::Bind(&SoftwareVideoRenderer::OnPacketDone,
                                          weak_factory_.GetWeakPtr(),
                                          decode_start, done);
 
   decode_task_runner_->PostTask(FROM_HERE, base::Bind(
@@ skipping 35 matching lines @@
   DCHECK(CalledOnValidThread());
 
   // Record the latency between the packet being received and presented.
   stats_.video_decode_ms()->Record(
       (base::Time::Now() - decode_start).InMilliseconds());
 
   done.Run();
 }
 
 }  // namespace remoting