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

remoting/client/plugin/pepper_video_renderer_3d.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/plugin/pepper_video_renderer_3d.h"
 
 #include <math.h>
 
 #include "base/callback_helpers.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "ppapi/c/pp_codecs.h"
 #include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
 #include "ppapi/lib/gl/include/GLES2/gl2ext.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/session_config.h"
 
 namespace remoting {
@@ skipping 164 matching lines @@
 protocol::VideoStub* PepperVideoRenderer3D::GetVideoStub() {
   return this;
 }
 
 void PepperVideoRenderer3D::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
                                                const base::Closure& done) {
   base::ScopedClosureRunner done_runner(done);
 
   // Don't need to do anything if the packet is empty. Host sends empty video
   // packets when the screen is not changing.
   if (!packet->data().size())

[Sergey Ulanov, 2015/06/19 23:08:42]

When a frame is empty it's currently not counted for FPS (host still tries to
send 30 FPS, while some of the frames are empty). This makes sense for the
values we want to show in the UI, but for protocol comparison it's useful to
account for empty frames as well. Essentially we want to know how often FPS
drops below 30 FPS. So I think we need another FPS counter that's incremented
above this line. And then ideally we should report both values with and without
empty frames.

[anandc, 2015/06/20 01:31:32]

Done.

     return;
 
-  // Update statistics.
+  // Update statistics and UMA histograms.
   stats_.video_frame_rate()->Record(1);
   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_input_event_timestamp_) {
     latest_input_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);
   }
 
   bool resolution_changed = false;
 
   if (packet->format().has_screen_width() &&
       packet->format().has_screen_height()) {
     webrtc::DesktopSize frame_size(packet->format().screen_width(),
                                    packet->format().screen_height());
     if (!frame_size_.equals(frame_size)) {
       frame_size_ = frame_size;
@@ skipping 309 matching lines @@
   gles2_if_->AttachShader(graphics_.pp_resource(), shader_program_, shader);
   gles2_if_->DeleteShader(graphics_.pp_resource(), shader);
 }
 
 void PepperVideoRenderer3D::CheckGLError() {
   GLenum error = gles2_if_->GetError(graphics_.pp_resource());
   CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR)) << "GL error: " << error;
 }
 
 }  // namespace remoting