Remove RTCVideoDecoder Reset method.

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 217 matching lines @@
       // Since we are returning ERROR, WebRTC will not be interested in the
       // remaining buffers, and will provide us with a new keyframe instead.
       // 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_);
-      Reset();
+      Release();
     }
 
     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()));
   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;
 }
 
 int32_t RTCVideoDecoder::Release() {
   DVLOG(2) << "Release";
   // Do not destroy VDA because WebRTC can call InitDecode and start decoding
   // again.
-  return Reset();
-}
-
-int32_t RTCVideoDecoder::Reset() {
-  DVLOG(2) << "Reset";
   base::AutoLock auto_lock(lock_);
   if (state_ == UNINITIALIZED) {
     LOG(ERROR) << "Decoder not initialized.";
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (next_bitstream_buffer_id_ != 0)
     reset_bitstream_buffer_id_ = next_bitstream_buffer_id_ - 1;
   else
     reset_bitstream_buffer_id_ = ID_LAST;
   // If VDA is already resetting, no need to request the reset again.
@@ skipping 100 matching lines @@
       picture_buffers_at_display_.insert(std::make_pair(
                                              picture.picture_buffer_id(),
                                              pb.texture_id())).second;
   DCHECK(inserted);
 
   // Create a WebRTC video frame.
   webrtc::VideoFrame decoded_image(
       new rtc::RefCountedObject<WebRtcVideoFrameAdapter>(frame), timestamp, 0,
       webrtc::kVideoRotation_0);
 
-  // Invoke decode callback. WebRTC expects no callback after Reset or Release.
+  // 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);
     }
   }
 }
 
@@ skipping 94 matching lines @@
     scoped_ptr<base::SharedMemory> shm_buffer;
     BufferData buffer_data;
     {
       base::AutoLock auto_lock(lock_);
       // Do not request decode if VDA is resetting.
       if (decode_buffers_.empty() || state_ == RESETTING)
         return;
       shm_buffer.reset(decode_buffers_.front().first);
       buffer_data = decode_buffers_.front().second;
       decode_buffers_.pop_front();
-      // Drop the buffers before Reset or Release is called.
+      // Drop the buffers before Release is called.
       if (!IsBufferAfterReset(buffer_data.bitstream_buffer_id,
                               reset_bitstream_buffer_id_)) {
         PutSHM_Locked(std::move(shm_buffer));
         continue;
       }
     }
 
     // Create a BitstreamBuffer and send to VDA to decode.
     media::BitstreamBuffer bitstream_buffer(
         buffer_data.bitstream_buffer_id, shm_buffer->handle(), buffer_data.size,
@@ skipping 68 matching lines @@
   return true;
 }
 
 void RTCVideoDecoder::MovePendingBuffersToDecodeBuffers() {
   base::AutoLock auto_lock(lock_);
   while (pending_buffers_.size() > 0) {
     // Get a pending buffer from the queue.
     const webrtc::EncodedImage& input_image = pending_buffers_.front().first;
     const BufferData& buffer_data = pending_buffers_.front().second;
 
-    // Drop the frame if it comes before Reset or Release.
+    // Drop the frame if it comes before Release.
     if (!IsBufferAfterReset(buffer_data.bitstream_buffer_id,
                             reset_bitstream_buffer_id_)) {
       delete[] input_image._buffer;
       pending_buffers_.pop_front();
       continue;
     }
     // Get shared memory and save it to decode buffers.
     scoped_ptr<base::SharedMemory> shm_buffer =
         GetSHM_Locked(input_image._length);
     if (!shm_buffer)
@@ skipping 207 matching lines @@
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
 }  // namespace content