Dynamic error tracking in RTCVideoDecoder

content/renderer/media/rtc_video_decoder.h

 // Copyright 2013 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 CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
 #define CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 91 matching lines @@
     BufferData();
     ~BufferData();
     int32_t bitstream_buffer_id;
     uint32_t timestamp;  // in 90KHz
     size_t size;  // buffer size
     gfx::Rect visible_rect;
   };
 
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, IsBufferAfterReset);
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, IsFirstBufferAfterReset);
+  FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, GetVDAErrorCounterForTesting);
 
   RTCVideoDecoder(webrtc::VideoCodecType type,
                   media::GpuVideoAcceleratorFactories* factories);
 
   // Requests a buffer to be decoded by VDA.
   void RequestBufferDecode();
 
   bool CanMoreDecodeWorkBeDone();
 
   // Returns true if bitstream buffer id |id_buffer| comes after |id_reset|.
   // This handles the wraparound.
   bool IsBufferAfterReset(int32_t id_buffer, int32_t id_reset);
 
   // Returns true if bitstream buffer |id_buffer| is the first buffer after
   // |id_reset|.
   bool IsFirstBufferAfterReset(int32_t id_buffer, int32_t id_reset);
 
+  int GetVDAErrorCounterForTesting() { return vda_error_counter_; }
+
   // Saves a WebRTC buffer in |decode_buffers_| for decode.
   void SaveToDecodeBuffers_Locked(const webrtc::EncodedImage& input_image,
                                   scoped_ptr<base::SharedMemory> shm_buffer,
                                   const BufferData& buffer_data);
 
   // Saves a WebRTC buffer in |pending_buffers_| waiting for SHM available.
   // Returns true on success.
   bool SaveToPendingBuffers_Locked(const webrtc::EncodedImage& input_image,
                                    const BufferData& buffer_data);
 
@@ skipping 11 matching lines @@
 
   // Static method is to allow it to run even after RVD is deleted.
   static void ReleaseMailbox(base::WeakPtr<RTCVideoDecoder> decoder,
                              media::GpuVideoAcceleratorFactories* factories,
                              int64_t picture_buffer_id,
                              uint32_t texture_id,
                              const gpu::SyncToken& release_sync_token);
   // Tells VDA that a picture buffer can be recycled.
   void ReusePictureBuffer(int64_t picture_buffer_id);
 
-  // Create |vda_| on |vda_loop_proxy_|.
+  // Creates |vda_| on |vda_loop_proxy_|.
   void CreateVDA(media::VideoCodecProfile profile, base::WaitableEvent* waiter);
 
   void DestroyTextures();
   void DestroyVDA();
 
   // Gets a shared-memory segment of at least |min_size| bytes from
   // |available_shm_segments_|. Returns NULL if there is no buffer or the
   // buffer is not big enough.
   scoped_ptr<base::SharedMemory> GetSHM_Locked(size_t min_size);
 
   // Returns a shared-memory segment to the available pool.
   void PutSHM_Locked(scoped_ptr<base::SharedMemory> shm_buffer);
 
   // Allocates |count| shared memory buffers of |size| bytes.
   void CreateSHM(size_t count, size_t size);
 
   // Stores the buffer metadata to |input_buffer_data_|.
   void RecordBufferData(const BufferData& buffer_data);
   // Gets the buffer metadata from |input_buffer_data_|.
   void GetBufferData(int32_t bitstream_buffer_id,
                      uint32_t* timestamp,
                      gfx::Rect* visible_rect);
 
   // Records the result of InitDecode to UMA and returns |status|.
   int32_t RecordInitDecodeUMA(int32_t status);
 
-  // Assert the contract that this class is operated on the right thread.
+  // Asserts the contract that this class is operated on the right thread.
   void DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent() const;
 
-  // Query factories_ whether |profile| is supported and return true is so,
+  // Queries factories_ whether |profile| is supported and return true is so,
   // false otherwise. If true, also set resolution limits for |profile|
   // in min/max_resolution_.
   bool IsProfileSupported(media::VideoCodecProfile profile);
 
-  // Clear the pending_buffers_ queue, freeing memory.
+  // Clears the pending_buffers_ queue, freeing memory.
   void ClearPendingBuffers();
 
+  // Resets |vda_error_counter_| after a successfull run of decode.
+  void TryResetVDAErrorCounter_Locked();
+
   enum State {
     UNINITIALIZED,  // The decoder has not initialized.
     INITIALIZED,    // The decoder has initialized.
     RESETTING,      // The decoder is being reset.
     DECODE_ERROR,   // Decoding error happened.
   };
 
   static const int32_t ID_LAST;     // maximum bitstream buffer id
   static const int32_t ID_HALF;     // half of the maximum bitstream buffer id
   static const int32_t ID_INVALID;  // indicates Reset or Release never occurred
 
   // The hardware video decoder.
   scoped_ptr<media::VideoDecodeAccelerator> vda_;
 
   media::VideoCodecProfile vda_codec_profile_;
 
   // Number of times that |vda_| notified of an error.
-  uint32_t num_vda_errors_;
+  uint32_t vda_error_counter_;
 
   // The video codec type, as reported by WebRTC.
   const webrtc::VideoCodecType video_codec_type_;
 
   // The size of the incoming video frames.
   gfx::Size frame_size_;
 
   media::GpuVideoAcceleratorFactories* const factories_;
 
   // The texture target used for decoded pictures.
@@ skipping 14 matching lines @@
   // to us via ReusePictureBuffer.
   typedef std::map<int32_t /* picture_buffer_id */, uint32_t /* texture_id */>
       PictureBufferTextureMap;
   PictureBufferTextureMap picture_buffers_at_display_;
 
   // The id that will be given to the next picture buffer.
   int32_t next_picture_buffer_id_;
 
   // Protects |state_|, |decode_complete_callback_| , |num_shm_buffers_|,
   // |available_shm_segments_|, |pending_buffers_|, |decode_buffers_|,
-  // |next_bitstream_buffer_id_| and |reset_bitstream_buffer_id_|.
+  // |next_bitstream_buffer_id_|, |reset_bitstream_buffer_id_| and
+  // |vda_error_counter_|.
   base::Lock lock_;
 
   // The state of RTCVideoDecoder. Guarded by |lock_|.
   State state_;
 
   // Guarded by |lock_|.
   webrtc::DecodedImageCallback* decode_complete_callback_;
 
   // Total number of allocated SHM buffers. Guarded by |lock_|.
   size_t num_shm_buffers_;
@@ skipping 26 matching lines @@
   // Must be destroyed, or invalidated, on |vda_loop_proxy_|
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_