Added UMA metrics for MediaSourcePlayer and MediaCodecPlayer

media/base/android/media_codec_decoder.h

 // Copyright 2015 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_BASE_ANDROID_MEDIA_CODEC_DECODER_H_
 #define MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_
 
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "media/base/android/access_unit_queue.h"
 #include "media/base/android/demuxer_stream_player_params.h"
 
 namespace media {
 
+struct FrameStatistics;
 class MediaCodecBridge;
 
 // The decoder for MediaCodecPlayer.
 // This class accepts the incoming data into AccessUnitQueue and works with
 // MediaCodecBridge for decoding and rendering the frames. The MediaCodecPlayer
 // has two decoder objects: audio and video.
 //
 // The decoder works on two threads. The data from demuxer comes on Media
 // thread. The commands from MediaCodecPlayer, such as Prefetch, Start,
 // RequestToStop also come on the Media thread. The operations with MediaCodec
@@ skipping 98 matching lines @@
   // has zero width.
   // The third parameter means "postpone", it is set to true if the actual
   // rendering will start in a later point in time. This only happens with
   // audio after preroll. The MediaCodecPlayer might decide to update the
   // current time but not pass it to the upper layer.
   typedef base::Callback<void(base::TimeDelta, base::TimeDelta, bool)>
       SetTimeCallback;
 
   // MediaCodecDecoder constructor.
   // Parameters:
+  //   decoder_thread_name:
+  //     The thread name to be passed to decoder thread constructor.
   //   media_task_runner:
   //     A task runner for the controlling thread. All public methods should be
   //     called on this thread, and callbacks are delivered on this thread.
   //     The MediaCodecPlayer uses a dedicated (Media) thread for this.
+  //   frame_statistics:
+  //     A pointer to FrameStatistics object which gathers playback quality
+  //     related data.
   //   external_request_data_cb:
   //     Called periodically as the amount of internally stored data decreases.
   //     The receiver should call OnDemuxerDataAvailable() with more data.
   //   starvation_cb:
   //     Called when starvation is detected. The decoder state does not change.
   //     The player is supposed to stop and then prefetch the decoder.
   //   decoder_drained_cb:
   //     Called when decoder is drained for reconfiguration.
   //   stop_done_cb:
   //     Called when async stop request is completed.
   //   waiting_for_decryption_key_cb:
   //     Will be executed whenever the key needed to decrypt the stream is not
   //     available.
   //   error_cb:
   //     Called when a MediaCodec error occurred. If this happens, a player has
   //     to either call ReleaseDecoderResources() or destroy the decoder object.
-  //   decoder_thread_name:
-  //     The thread name to be passed to decoder thread constructor.
   MediaCodecDecoder(
+      const char* decoder_thread_name,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+      FrameStatistics* frame_statistics,
       const base::Closure& external_request_data_cb,
       const base::Closure& starvation_cb,
       const base::Closure& decoder_drained_cb,
       const base::Closure& stop_done_cb,
       const base::Closure& waiting_for_decryption_key_cb,
-      const base::Closure& error_cb,
-      const char* decoder_thread_name);
+      const base::Closure& error_cb);
+
   virtual ~MediaCodecDecoder();
 
   virtual const char* class_name() const;
 
   // MediaCodecDecoder exists through the whole lifetime of the player
   // to support dynamic addition and removal of the streams.
   // This method returns true if the current stream (audio or video)
   // is currently active.
   virtual bool HasStream() const = 0;
 
@@ skipping 122 matching lines @@
   // Returns true if we are in the process of sync stop.
   bool InEmergencyStop() const { return GetState() == kInEmergencyStop; }
 
   // Notifies the decoder if the frame is the last one.
   void CheckLastFrame(bool eos_encountered, bool has_delayed_tasks);
 
   const char* AsString(RenderMode render_mode);
 
   // Protected data.
 
+  // We call MediaCodecBridge on this thread for both input and output buffers.
+  base::Thread decoder_thread_;
+
   // Object for posting tasks on Media thread.
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
+  // Statistics for UMA.
+  FrameStatistics* frame_statistics_;
+
   // Controls Android MediaCodec
   scoped_ptr<MediaCodecBridge> media_codec_bridge_;
 
-  // We call MediaCodecBridge on this thread for both
-  // input and output buffers.
-  base::Thread decoder_thread_;
-
   // The queue of access units.
   AccessUnitQueue au_queue_;
 
   // Flag forces reconfiguration even if |media_codec_bridge_| exists. Currently
   // is set by video decoder when the video surface changes.
   bool needs_reconfigure_;
 
   // Flag forces to drain decoder in the process of dynamic reconfiguration.
   bool drain_decoder_;
 
@@ skipping 112 matching lines @@
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaCodecDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecDecoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_