Consider non-keyframes for RTCVideoEncoder error counter

content/renderer/media/rtc_video_decoder.cc

 // 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.
 
 #include "content/renderer/media/rtc_video_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 218 matching lines @@
     gfx::Size prev_frame_size = frame_size_;
     frame_size_ = new_frame_size;
     if (!kVDACanHandleMidstreamResize && !prev_frame_size.IsEmpty() &&
         prev_frame_size != frame_size_) {
       need_to_reset_for_midstream_resize = true;
     }
   } else if (IsFirstBufferAfterReset(next_bitstream_buffer_id_,
                                      reset_bitstream_buffer_id_)) {
     // TODO(wuchengli): VDA should handle it. Remove this when
     // http://crosbug.com/p/21913 is fixed.
     DVLOG(1) << "The first frame should be a key frame. Drop this.";

[mcasas, 2016/06/30 18:07:25]

This DVLOG() goes with l.243 now.

[emircan, 2016/06/30 20:39:17]

Done.

+    if (vda_error_counter_)
+      ++vda_error_counter_;

[mcasas, 2016/06/30 18:07:25]

I'd write this instead:

// If we're are in an error condition, increase the counter
vda_error_counter_ += vda_error_counter_ ? 1 : 0;

WDYT?

[emircan, 2016/06/30 20:39:17]

Done.

+
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   // Create buffer metadata.
   BufferData buffer_data(next_bitstream_buffer_id_,
                          inputImage._timeStamp,
                          inputImage._length,
                          gfx::Rect(frame_size_));
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & ID_LAST;
@@ skipping 12 matching lines @@
       // Better to drop any pending buffers and start afresh to catch up faster.
       DVLOG(1) << "Exceeded maximum pending buffer count, dropping";
       ClearPendingBuffers();
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     if (need_to_reset_for_midstream_resize) {
       base::AutoUnlock auto_unlock(lock_);
       Release();
     }
-
-    TryResetVDAErrorCounter_Locked();
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   SaveToDecodeBuffers_Locked(inputImage, std::move(shm_buffer), buffer_data);
   factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoDecoder::RequestBufferDecode,
                  weak_factory_.GetWeakPtr()));
-  TryResetVDAErrorCounter_Locked();
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoder::RegisterDecodeCompleteCallback(
     webrtc::DecodedImageCallback* callback) {
   DVLOG(2) << "RegisterDecodeCompleteCallback";
   DCHECK(callback);
   base::AutoLock auto_lock(lock_);
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
@@ skipping 144 matching lines @@
 
   // Invoke decode callback. WebRTC expects no callback after Release.
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(decode_complete_callback_);
     if (IsBufferAfterReset(picture.bitstream_buffer_id(),
                            reset_bitstream_buffer_id_)) {
       decode_complete_callback_->Decoded(decoded_image);
     }
   }
+  TryResetVDAErrorCounter();
 }
 
 scoped_refptr<media::VideoFrame> RTCVideoDecoder::CreateVideoFrame(
     const media::Picture& picture,
     const media::PictureBuffer& pb,
     uint32_t timestamp,
     const gfx::Rect& visible_rect,
     media::VideoPixelFormat pixel_format) {
   DCHECK(decoder_texture_target_);
   // Convert timestamp from 90KHz to ms.
@@ skipping 425 matching lines @@
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
-void RTCVideoDecoder::TryResetVDAErrorCounter_Locked() {
-  lock_.AssertAcquired();
+void RTCVideoDecoder::TryResetVDAErrorCounter() {
+  base::AutoLock auto_lock(lock_);
 
   if (vda_error_counter_ == 0)
     return;
   vda_error_counter_ = 0;
 }
 
 }  // namespace content