Reland r212023 "Rename VideoDecoder::ReadCB to VideoDecoder::DecodeCB."

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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 "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 56 matching lines @@
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DVLOG(3) << "Reset()";
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == kDrainingDecoder && !factories_->IsAborted()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, weak_this_, closure));
     // NOTE: if we're deferring Reset() until a Flush() completes, return
     // queued pictures to the VDA so they can be used to finish that Flush().
-    if (pending_read_cb_.is_null())
+    if (pending_decode_cb_.is_null())
       ready_video_frames_.clear();
     return;
   }
 
   // Throw away any already-decoded, not-yet-delivered frames.
   ready_video_frames_.clear();
 
   if (!vda_) {
     gvd_loop_proxy_->PostTask(FROM_HERE, closure);
     return;
   }
 
-  if (!pending_read_cb_.is_null())
+  if (!pending_decode_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 
   DCHECK(pending_reset_cb_.is_null());
   pending_reset_cb_ = BindToCurrentLoop(closure);
 
   vda_->Reset();
 }
 
 void GpuVideoDecoder::Stop(const base::Closure& closure) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (vda_)
     DestroyVDA();
-  if (!pending_read_cb_.is_null())
+  if (!pending_decode_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
   BindToCurrentLoop(closure).Run();
 }
 
 static bool IsCodedSizeSupported(const gfx::Size& coded_size) {
   // Only non-Windows, Ivy Bridge+ platforms can support more than 1920x1080.
   // We test against 1088 to account for 16x16 macroblocks.
   if (coded_size.width() <= 1920 && coded_size.height() <= 1088)
@@ skipping 67 matching lines @@
 void GpuVideoDecoder::DestroyVDA() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (vda_)
     vda_.release()->Destroy();
 
   DestroyTextures();
 }
 
 void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
-                             const ReadCB& read_cb) {
+                             const DecodeCB& decode_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(pending_reset_cb_.is_null());
-  DCHECK(pending_read_cb_.is_null());
+  DCHECK(pending_decode_cb_.is_null());
 
-  pending_read_cb_ = BindToCurrentLoop(read_cb);
+  pending_decode_cb_ = BindToCurrentLoop(decode_cb);
 
   if (state_ == kError || !vda_) {
-    base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
+    base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   switch (state_) {
     case kDecoderDrained:
       if (!ready_video_frames_.empty()) {
         EnqueueFrameAndTriggerFrameDelivery(NULL);
         return;
       }
       state_ = kNormal;
@@ skipping 14 matching lines @@
     if (state_ == kNormal) {
       state_ = kDrainingDecoder;
       vda_->Flush();
     }
     return;
   }
 
   size_t size = buffer->data_size();
   SHMBuffer* shm_buffer = GetSHM(size);
   if (!shm_buffer) {
-    base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
+    base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   memcpy(shm_buffer->shm->memory(), buffer->data(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferData(bitstream_buffer, *buffer.get());
 
   vda_->Decode(bitstream_buffer);
 
   if (!ready_video_frames_.empty()) {
     EnqueueFrameAndTriggerFrameDelivery(NULL);
     return;
   }
 
   if (CanMoreDecodeWorkBeDone())
-    base::ResetAndReturn(&pending_read_cb_).Run(kNotEnoughData, NULL);
+    base::ResetAndReturn(&pending_decode_cb_).Run(kNotEnoughData, NULL);
 }
 
 bool GpuVideoDecoder::CanMoreDecodeWorkBeDone() {
   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
 
 void GpuVideoDecoder::RecordBufferData(const BitstreamBuffer& bitstream_buffer,
                                        const DecoderBuffer& buffer) {
   input_buffer_data_.push_front(BufferData(bitstream_buffer.id(),
                                            buffer.timestamp(),
@@ skipping 169 matching lines @@
   // During a pending vda->Reset(), we don't accumulate frames.  Drop it on the
   // floor and return.
   if (!pending_reset_cb_.is_null())
     return;
 
   if (frame.get())
     ready_video_frames_.push_back(frame);
   else
     DCHECK(!ready_video_frames_.empty());
 
-  if (pending_read_cb_.is_null())
+  if (pending_decode_cb_.is_null())
     return;
 
-  base::ResetAndReturn(&pending_read_cb_).Run(kOk, ready_video_frames_.front());
+  base::ResetAndReturn(&pending_decode_cb_)
+      .Run(kOk, ready_video_frames_.front());
   ready_video_frames_.pop_front();
 }
 
 void GpuVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id,
                                          uint32 sync_point) {
   DVLOG(3) << "ReusePictureBuffer(" << picture_buffer_id << ")";
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (!vda_)
     return;
@@ skipping 51 matching lines @@
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   PutSHM(it->second.shm_buffer);
   bitstream_buffers_in_decoder_.erase(it);
 
   if (pending_reset_cb_.is_null() && state_ != kDrainingDecoder &&
-      CanMoreDecodeWorkBeDone() && !pending_read_cb_.is_null()) {
-    base::ResetAndReturn(&pending_read_cb_).Run(kNotEnoughData, NULL);
+      CanMoreDecodeWorkBeDone() && !pending_decode_cb_.is_null()) {
+    base::ResetAndReturn(&pending_decode_cb_).Run(kNotEnoughData, NULL);
   }
 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
   DCHECK(!vda_.get());  // Stop should have been already called.
-  DCHECK(pending_read_cb_.is_null());
+  DCHECK(pending_decode_cb_.is_null());
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     available_shm_segments_[i]->shm->Close();
     delete available_shm_segments_[i];
   }
   available_shm_segments_.clear();
   for (std::map<int32, BufferPair>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     it->second.shm_buffer->shm->Close();
   }
@@ skipping 15 matching lines @@
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(ready_video_frames_.empty());
 
   // This needs to happen after the Reset() on vda_ is done to ensure pictures
   // delivered during the reset can find their time data.
   input_buffer_data_.clear();
 
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
 
-  if (!pending_read_cb_.is_null())
+  if (!pending_decode_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 }
 
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (!vda_)
     return;
 
   DLOG(ERROR) << "VDA Error: " << error;
   DestroyVDA();
 
   state_ = kError;
 
-  if (!pending_read_cb_.is_null()) {
-    base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
+  if (!pending_decode_cb_.is_null()) {
+    base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media