Media Remoting: UMAs to track session events and measurements.

media/remoting/remote_renderer_impl.h

 // Copyright 2016 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.
 
 #ifndef MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_
 #define MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "base/synchronization/lock.h"
+#include "base/timer/timer.h"
 #include "media/base/buffering_state.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/mojo/interfaces/remoting.mojom.h"
+#include "media/remoting/metrics.h"
 #include "media/remoting/remoting_interstitial_ui.h"
 #include "media/remoting/rpc/rpc_broker.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 
 namespace media {
 
 class RemotingRendererController;
 class Renderer;
 
 namespace remoting {
@@ skipping 104 matching lines @@
                           const gfx::Size& canvas_size,
                           RemotingInterstitialType interstitial_type);
 
   // Called when |current_media_time_| is updated.
   void OnMediaTimeUpdated();
 
   // Called to update the |video_stats_queue_|.
   void UpdateVideoStatsQueue(int video_frames_decoded,
                              int video_frames_dropped);
 
-  // Called to clear |media_time_queue_| and |video_stats_queue_|.
-  void ResetQueues();
+  // Called to clear all recent measurements history and schedule resuming after
+  // a stabilization period elapses.
+  void ResetMeasurements();
 
-  // Called when irregular playback is detected.
-  void OnIrregularPlaybackDetected();
+  // Called when a fatal runtime error occurs. |stop_trigger| is the error code
+  // handed to the RemotingRendererController.
+  void OnFatalError(remoting::StopTrigger stop_trigger);
 
-  // Shut down remoting session.
-  void OnFatalError(PipelineStatus status);
+  // Called periodically to measure the data flows from the
+  // DemuxerStreamAdapters and record this information in the metrics.
+  void MeasureAndRecordDataRates();
 
   State state_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // Current renderer playback time information.
   base::TimeDelta current_media_time_;
   base::TimeDelta current_max_time_;
   // Both |current_media_time_| and |current_max_time_| should be protected by
   // lock because it can be accessed from both media and render main thread.
@@ skipping 44 matching lines @@
 
   // Stores all updates on the number of video frames decoded/dropped, and the
   // local time when updated in the moving time window. This is used to check
   // whether too many video frames were dropped.
   std::deque<std::tuple<base::TimeTicks, int, int>> video_stats_queue_;
 
   // The total number of frames decoded/dropped in the time window.
   int sum_video_frames_decoded_ = 0;
   int sum_video_frames_dropped_ = 0;
 
+  // Records events and measurements of interest.
+  remoting::RendererMetricsRecorder metrics_recorder_;
+
+  // A timer that polls the RemoteDemuxerStreamAdapters periodically to measure
+  // the data flow rates for metrics.
+  base::RepeatingTimer data_flow_poll_timer_;
+
   base::WeakPtrFactory<RemoteRendererImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteRendererImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_