Integrate VDA with WebRTC.

content/renderer/media/rtc_video_decoder.cc

Index: content/renderer/media/rtc_video_decoder.cc
diff --git a/content/renderer/media/rtc_video_decoder.cc b/content/renderer/media/rtc_video_decoder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e4e58f47091285e25d98db0b49e8bd7a3cfc8ad2
--- /dev/null
+++ b/content/renderer/media/rtc_video_decoder.cc
@@ -0,0 +1,606 @@
+// Copyright (c) 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 "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop_proxy.h"
+#include "base/safe_numerics.h"
+#include "base/task_runner_util.h"
+#include "content/renderer/media/native_handle_impl.h"
+#include "media/base/bind_to_loop.h"
+#include "third_party/webrtc/system_wrappers/interface/ref_count.h"
+
+namespace content {
+
+// A shared memory segment and its allocated size. |shm| is unowned and the
+// users should delete it.
+struct RTCVideoDecoder::SHMBuffer {
+  SHMBuffer(base::SharedMemory* shm, size_t size);
+  ~SHMBuffer();
+  base::SharedMemory* const shm;
+  const size_t size;
+};
+
+RTCVideoDecoder::SHMBuffer::SHMBuffer(base::SharedMemory* shm, size_t size)
+    : shm(shm), size(size) {}
+
+RTCVideoDecoder::SHMBuffer::~SHMBuffer() {}
+
+// Metadata of a bitstream buffer.
+struct RTCVideoDecoder::BufferData {
+  BufferData(int32 bitstream_buffer_id,
+             uint32_t timestamp,
+             int width,
+             int height,
+             size_t sisze);
+  ~BufferData();
+  const int32 bitstream_buffer_id;
+  const uint32_t timestamp;  // in 90KHz
+  const uint32_t width;
+  const uint32_t height;
+  const size_t size;  // buffer size
+};
+
+RTCVideoDecoder::BufferData::BufferData(int32 bitstream_buffer_id,
+                                        uint32_t timestamp,
+                                        int width,
+                                        int height,
+                                        size_t size)
+    : bitstream_buffer_id(bitstream_buffer_id),
+      timestamp(timestamp),
+      width(width),
+      height(height),
+      size(size) {}
+
+RTCVideoDecoder::BufferData::~BufferData() {}
+
+RTCVideoDecoder::RTCVideoDecoder(
+    const scoped_refptr<media::GpuVideoDecoder::Factories>& factories)
+    : compositor_loop_async_waiter_(false, false),
+      state_(UNINITIALIZED),
+      decode_complete_callback_(NULL),
+      weak_factory_(this),
+      factories_(factories),
+      vda_loop_proxy_(factories_->GetMessageLoop()),
+      decoder_texture_target_(0),
+      next_picture_buffer_id_(0),
+      next_bitstream_buffer_id_(0) {
+  // Initialize directly if |vda_loop_proxy_| is the renderer thread.
+  if (vda_loop_proxy_->BelongsToCurrentThread()) {
+    Initialize();
+    compositor_loop_async_waiter_.Reset();
+    return;
+  }
+  // Post the task if |vda_loop_proxy_| is the compositor thread. Waiting here
+  // is safe because the compositor thread will not be stopped until the
+  // renderer thread shuts down.

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

This means that you don't actually need the waiter to be a class member (which
is never touched after the ctor returns).
Instead you can have a stack-local WaitableEvent and wait for it here, passing
its address to the bound Initialize call.

[wuchengli, 2013/06/19 13:01:13]

Done.

+  vda_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&RTCVideoDecoder::Initialize, base::Unretained(this)));
+  compositor_loop_async_waiter_.Wait();
+}
+
+RTCVideoDecoder::~RTCVideoDecoder() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!vda_);  // Release should have been already called.
+  DVLOG(2) << "~RTCVideoDecoder";
+  // Delete all shared memories.
+  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, SHMBuffer*>::iterator it =
+           bitstream_buffers_in_decoder_.begin();
+       it != bitstream_buffers_in_decoder_.end();
+       ++it) {
+    it->second->shm->Close();
+    delete it->second;
+  }
+  bitstream_buffers_in_decoder_.clear();
+  ClearBufferQueue(buffers_to_be_decoded_);
+  ClearBufferQueue(buffers_delayed_);
+
+  base::MessageLoop::current()->RemoveDestructionObserver(this);
+}
+
+bool RTCVideoDecoder::InitVideoDecodeAccelerator() {
+  vda_.reset(
+      factories_->CreateVideoDecodeAccelerator(media::VP8PROFILE_MAIN, this));
+
+  // vda can be NULL if the codec type is not supported.
+  if (vda_ != NULL) {
+    base::AutoLock auto_lock(lock_);
+    state_ = INITIALIZED;
+    return true;
+  }
+  return false;
+}
+
+int32_t RTCVideoDecoder::InitDecode(const webrtc::VideoCodec* codecSettings,
+                                    int32_t /*numberOfCores*/) {
+  DVLOG(2) << "InitDecode";
+  DCHECK_EQ(codecSettings->codecType, webrtc::kVideoCodecVP8);
+  if (codecSettings->codecSpecific.VP8.feedbackModeOn) {
+    LOG(ERROR) << "Feedback mode not supported";
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  }
+
+  base::AutoLock auto_lock(lock_);
+  if (state_ == UNINITIALIZED || state_ == DECODE_ERROR) {
+    LOG(ERROR) << "VDA is not initialized. state=" << state_;
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t RTCVideoDecoder::Decode(
+    const webrtc::EncodedImage& inputImage,
+    bool missingFrames,
+    const webrtc::RTPFragmentationHeader* /*fragmentation*/,
+    const webrtc::CodecSpecificInfo* /*codecSpecificInfo*/,
+    int64_t /*renderTimeMs*/) {
+  DVLOG(3) << "Decode";
+
+  {
+    base::AutoLock auto_lock(lock_);
+    if (state_ == UNINITIALIZED || decode_complete_callback_ == NULL) {
+      LOG(ERROR) << "The decoder has not initialized.";
+      return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+    }
+    if (state_ == DECODE_ERROR) {
+      LOG(ERROR) << "Decoding error occurred.";
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
+  }
+  if (missingFrames || !inputImage._completeFrame) {
+    DLOG(ERROR) << "Missing or incomplete frames.";
+    // Unlike the SW decoder in libvpx, hw decoder cannot handle broken frames.
+    // Return an error to request a key frame.
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  }
+
+  if (inputImage._frameType == webrtc::kKeyFrame)
+    frame_size_.SetSize(inputImage._encodedWidth, inputImage._encodedHeight);
+
+  // Copy WebRTC buffer to SHM buffer and create buffer metadata.
+  SHMBuffer* shm_buffer = GetSHM(inputImage._length);
+  if (!shm_buffer)
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  memcpy(shm_buffer->shm->memory(), inputImage._buffer, inputImage._length);
+  BufferData buffer_data(next_bitstream_buffer_id_,
+                         inputImage._timeStamp,
+                         frame_size_.width(),
+                         frame_size_.height(),
+                         inputImage._length);
+  // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
+  next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
+  std::pair<SHMBuffer*, BufferData> buffer_pair =
+      std::make_pair(shm_buffer, buffer_data);
+
+  // Store the buffer and the metadata to the queue.
+  base::AutoLock auto_lock(lock_);
+  if (state_ == RESETTING) {
+    // If VDA is resetting, save the buffer but do not request decode.
+    buffers_delayed_.push_back(buffer_pair);
+  } else {
+    buffers_to_be_decoded_.push_back(buffer_pair);
+    vda_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&RTCVideoDecoder::RequestBufferDecode, weak_this_));
+  }
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t RTCVideoDecoder::RegisterDecodeCompleteCallback(
+    webrtc::DecodedImageCallback* 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 the decoder will be recycled by
+  // RTCVideoDecoderFactory. Just reset VDA.
+  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;
+  } else if (state_ == RESETTING) {
+    // If VDA is already resetting, empty the pending buffer queue. No need to
+    // request the reset again.
+    while (buffers_delayed_.size() > 0) {

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

l.223-226 is:
buffers_to_be_decoded_.insert(buffers_to_be_decoded_.end(),
    buffers_delayed_.begin(), buffers_delayed_.end());
(which is a no-op of b_d_ is empty)

[wuchengli, 2013/06/19 13:01:13]

Done. I had to remove const in BufferData because STL uses assignment operator.
Otherwise the code generated compile error: "non-static const member 'const
size_t content::RTCVideoDecoder::BufferData::size', can't use default assignment
operator"

+      buffers_to_be_decoded_.push_back(buffers_delayed_.front());
+      buffers_delayed_.pop_front();
+    }
+  } else {
+    state_ = RESETTING;
+    vda_loop_proxy_->PostTask(
+        FROM_HERE, base::Bind(&RTCVideoDecoder::ResetInternal, weak_this_));
+  }
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+void RTCVideoDecoder::NotifyInitializeDone() {
+  DVLOG(2) << "NotifyInitializeDone";
+  NOTREACHED();
+}
+
+void RTCVideoDecoder::ProvidePictureBuffers(uint32 count,
+                                            const gfx::Size& size,
+                                            uint32 texture_target) {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DVLOG(3) << "ProvidePictureBuffers. texture_target=" << texture_target;
+  std::vector<uint32> texture_ids;
+  decoder_texture_target_ = texture_target;
+  if (!factories_->CreateTextures(
+          count, size, &texture_ids, decoder_texture_target_)) {
+    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+  DCHECK_EQ(count, texture_ids.size());
+
+  if (!vda_)

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

why not do this at the top of the method?

[wuchengli, 2013/06/19 13:01:13]

Done.

GpuVideoDecoder puts it in the same place. I agree RTCVideoDecoder shouldn't
need to create the textures if |vda_| is gone.

+    return;
+
+  std::vector<media::PictureBuffer> picture_buffers;
+  for (size_t i = 0; i < texture_ids.size(); ++i) {
+    picture_buffers.push_back(
+        media::PictureBuffer(next_picture_buffer_id_++, size, texture_ids[i]));
+    bool inserted = assigned_picture_buffers_.insert(std::make_pair(
+        picture_buffers.back().id(), picture_buffers.back())).second;
+    DCHECK(inserted);
+  }
+  vda_->AssignPictureBuffers(picture_buffers);
+}
+
+void RTCVideoDecoder::DismissPictureBuffer(int32 id) {
+  DVLOG(3) << "DismissPictureBuffer. id=" << id;
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+
+  std::map<int32, media::PictureBuffer>::iterator it =
+      assigned_picture_buffers_.find(id);
+  if (it == assigned_picture_buffers_.end()) {
+    NOTREACHED() << "Missing picture buffer: " << id;
+    return;
+  }
+
+  media::PictureBuffer buffer_to_dismiss = it->second;
+  assigned_picture_buffers_.erase(it);
+
+  std::set<int32>::iterator at_display_it =
+      picture_buffers_at_display_.find(id);
+
+  if (at_display_it == picture_buffers_at_display_.end()) {
+    // We can delete the texture immediately as it's not being displayed.
+    factories_->DeleteTexture(buffer_to_dismiss.texture_id());
+  } else {
+    // Texture in display. Postpone deletion until after it's returned to us.
+    bool inserted = dismissed_picture_buffers_
+        .insert(std::make_pair(id, buffer_to_dismiss)).second;

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

period goes on previous line 
(git cl format is your friend)

[wuchengli, 2013/06/19 13:01:13]

I did run git cl format. I completely follow its recommendation now. This style
was generated by git cl format.

+    DCHECK(inserted);
+  }
+}
+
+void RTCVideoDecoder::PictureReady(const media::Picture& picture) {
+  DVLOG(3) << "PictureReady";
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+
+  std::map<int32, media::PictureBuffer>::iterator it =
+      assigned_picture_buffers_.find(picture.picture_buffer_id());
+  if (it == assigned_picture_buffers_.end()) {
+    NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
+    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+  const media::PictureBuffer& pb = it->second;
+
+  // Create a media::VideoFrame.
+  uint32_t timestamp = 0;
+  uint32_t width = 0, height = 0;
+  size_t size = 0;
+  GetBufferData(
+      picture.bitstream_buffer_id(), &timestamp, &width, &height, &size);
+  gfx::Rect visible_rect(width, height);
+  gfx::Size natural_size(width, height);
+  DCHECK(decoder_texture_target_);
+  // Convert timestamp from 90KHz to ms.
+  base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
+      base::checked_numeric_cast<uint64_t>(timestamp) * 1000 / 90);
+  scoped_refptr<media::VideoFrame> frame(media::VideoFrame::WrapNativeTexture(
+      pb.texture_id(),
+      decoder_texture_target_,
+      pb.size(),
+      visible_rect,
+      natural_size,
+      timestamp_ms,
+      base::Bind(&media::GpuVideoDecoder::Factories::ReadPixels,
+                 factories_,
+                 pb.texture_id(),
+                 decoder_texture_target_,
+                 natural_size),
+      media::BindToCurrentLoop(base::Bind(&RTCVideoDecoder::ReusePictureBuffer,
+                                          weak_this_,
+                                          picture.picture_buffer_id()))));
+  bool inserted =
+      picture_buffers_at_display_.insert(picture.picture_buffer_id()).second;
+  DCHECK(inserted);
+
+  // Create a webrtc::I420VideoFrame.
+  webrtc::I420VideoFrame decoded_image;
+  // TODO(wuchengli): remove the malloc.
+  decoded_image.CreateEmptyFrame(width, height, width, height / 2, width / 2);
+  webrtc::RefCountImpl<NativeHandleImpl>* handle =
+      new webrtc::RefCountImpl<NativeHandleImpl>();
+  handle->SetHandle(frame.get());
+  decoded_image.set_native_handle(handle);
+  decoded_image.set_timestamp(timestamp);
+
+  // Send to decode callback.
+  webrtc::DecodedImageCallback* callback;
+  {
+    base::AutoLock auto_lock(lock_);
+    callback = decode_complete_callback_;
+  }
+  DCHECK(callback != NULL);
+  callback->Decoded(decoded_image);
+}
+
+void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
+  DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+
+  std::map<int32, SHMBuffer*>::iterator it =
+      bitstream_buffers_in_decoder_.find(id);
+  if (it == bitstream_buffers_in_decoder_.end()) {
+    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    NOTREACHED() << "Missing bitstream buffer: " << id;
+    return;
+  }
+
+  PutSHM(it->second);
+  bitstream_buffers_in_decoder_.erase(it);
+
+  RequestBufferDecode();
+}
+
+void RTCVideoDecoder::NotifyFlushDone() {
+  DVLOG(3) << "NotifyFlushDone";
+  NOTREACHED() << "Unexpected flush done notification.";
+}
+
+void RTCVideoDecoder::NotifyResetDone() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DVLOG(3) << "NotifyResetDone";
+
+  if (!vda_)
+    return;
+
+  input_buffer_data_.clear();
+  int num_buffers = 0;
+  {
+    base::AutoLock auto_lock(lock_);
+    // Clear and recycle the old buffers.
+    for (std::deque<std::pair<SHMBuffer*, BufferData> >::const_iterator it =
+             buffers_to_be_decoded_.begin();
+         it != buffers_to_be_decoded_.end();
+         it++) {
+      PutSHM(it->first);
+    }
+    buffers_to_be_decoded_.clear();
+
+    swap(buffers_to_be_decoded_, buffers_delayed_);

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

std::swap() to avoid debugging pain down the line.

[wuchengli, 2013/06/19 13:01:13]

Done.

+    num_buffers = buffers_to_be_decoded_.size();
+    state_ = INITIALIZED;
+  }
+  // Send the pending buffers for decoding.
+  for (int i = 0; i < num_buffers; i++)
+    RequestBufferDecode();
+}
+
+void RTCVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  if (!vda_)
+    return;
+
+  DLOG(ERROR) << "VDA Error:" << error;
+  DestroyVDA();
+
+  base::AutoLock auto_lock(lock_);
+  state_ = DECODE_ERROR;
+}
+
+void RTCVideoDecoder::WillDestroyCurrentMessageLoop() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  factories_->Abort();
+}
+
+void RTCVideoDecoder::Initialize() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  base::MessageLoop::current()->AddDestructionObserver(this);
+  weak_this_ = weak_factory_.GetWeakPtr();
+  compositor_loop_async_waiter_.Signal();
+}
+
+void RTCVideoDecoder::RequestBufferDecode() {
+  if (!CanMoreDecodeWorkBeDone())
+    return;
+
+  // Get a buffer and data from the queue.
+  std::pair<SHMBuffer*, BufferData>* buffer_pair;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (buffers_to_be_decoded_.size() == 0 || state_ == RESETTING)
+      return;
+    buffer_pair = &buffers_to_be_decoded_.front();
+    buffers_to_be_decoded_.pop_front();
+  }
+  SHMBuffer* shm_buffer = buffer_pair->first;
+  BufferData buffer_data = buffer_pair->second;
+
+  // Create a BitstreamBuffer and send to VDA to decode.
+  media::BitstreamBuffer bitstream_buffer(buffer_data.bitstream_buffer_id,
+                                          shm_buffer->shm->handle(),
+                                          buffer_data.size);
+  bool inserted = bitstream_buffers_in_decoder_
+      .insert(std::make_pair(bitstream_buffer.id(), shm_buffer)).second;
+  DCHECK(inserted);
+  RecordBufferData(buffer_data);
+  vda_->Decode(bitstream_buffer);
+}
+
+// Maximum number of concurrent VDA::Decode() operations RVD will maintain.
+// Higher values allow better pipelining in the GPU, but also require more
+// resources.
+enum {
+  kMaxInFlightDecodes = 8
+};
+
+bool RTCVideoDecoder::CanMoreDecodeWorkBeDone() {
+  return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
+}
+
+void RTCVideoDecoder::ResetInternal() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DVLOG(2) << "ResetInternal";
+  vda_->Reset();

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

if (!vda_)
  return;
first

[wuchengli, 2013/06/19 13:01:13]

Done. I also added the check in RequestBufferDecode.

+}
+
+void RTCVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DVLOG(3) << "ReusePictureBuffer. id=" << picture_buffer_id;
+
+  if (!vda_)
+    return;
+
+  CHECK(!picture_buffers_at_display_.empty());
+
+  size_t num_erased = picture_buffers_at_display_.erase(picture_buffer_id);
+  DCHECK(num_erased);
+
+  std::map<int32, media::PictureBuffer>::iterator it =
+      assigned_picture_buffers_.find(picture_buffer_id);
+
+  if (it == assigned_picture_buffers_.end()) {
+    // This picture was dismissed while in display, so we postponed deletion.
+    it = dismissed_picture_buffers_.find(picture_buffer_id);
+    DCHECK(it != dismissed_picture_buffers_.end());
+    factories_->DeleteTexture(it->second.texture_id());
+    dismissed_picture_buffers_.erase(it);
+    return;
+  }
+
+  vda_->ReusePictureBuffer(picture_buffer_id);
+}
+
+void RTCVideoDecoder::DestroyTextures() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  std::map<int32, media::PictureBuffer>::iterator it;
+
+  for (it = assigned_picture_buffers_.begin();
+       it != assigned_picture_buffers_.end();
+       ++it) {
+    factories_->DeleteTexture(it->second.texture_id());
+  }
+  assigned_picture_buffers_.clear();
+
+  for (it = dismissed_picture_buffers_.begin();
+       it != dismissed_picture_buffers_.end();
+       ++it) {
+    factories_->DeleteTexture(it->second.texture_id());
+  }
+  dismissed_picture_buffers_.clear();
+}
+
+void RTCVideoDecoder::DestroyVDA() {
+  DVLOG(2) << "DestroyVDA";
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  if (vda_)
+    vda_.release()->Destroy();
+  DestroyTextures();
+}
+
+void RTCVideoDecoder::ClearBufferQueue(
+    std::deque<std::pair<SHMBuffer*, BufferData> >& queue) {

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

pass by pointer
(never non-const ref in chromium style)

[wuchengli, 2013/06/19 13:01:13]

Done.

+  base::AutoLock auto_lock(lock_);

[Ami GONE FROM CHROMIUM, 2013/06/18 21:54:29]

It is a code-smell to take a member lock in a method that doesn't otherwise
touch any class state.  Here the class state comes through the argument, which
the caller is responsible for, so the usual prescription would be to move the
lock to the caller.  However in this case the only caller is the dtor, and
locking in a dtor is pointless, so I think you can just drop this autolock.

[wuchengli, 2013/06/19 13:01:13]

You are right. Done.

+  for (std::deque<std::pair<SHMBuffer*, BufferData> >::iterator it =
+           queue.begin();
+       it != queue.end();
+       ++it) {
+    it->first->shm->Close();
+    delete it->first;
+  }
+  queue.clear();
+}
+
+// Size of shared-memory segments we allocate.  Since we reuse them we let them
+// be on the beefy side.
+static const size_t kSharedMemorySegmentBytes = 100 << 10;
+
+RTCVideoDecoder::SHMBuffer* RTCVideoDecoder::GetSHM(size_t min_size) {
+  {
+    // Reuse a SHM if possible.
+    base::AutoLock auto_lock(lock_);
+    if (!available_shm_segments_.empty() &&
+        available_shm_segments_.back()->size >= min_size) {
+      SHMBuffer* ret = available_shm_segments_.back();
+      available_shm_segments_.pop_back();
+      return ret;
+    }
+  }
+  // Create a new shared memory. This is done in main thread.
+  size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
+  base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
+  if (!shm)
+    return NULL;
+  return new SHMBuffer(shm, size_to_allocate);
+}
+
+void RTCVideoDecoder::PutSHM(SHMBuffer* shm_buffer) {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  base::AutoLock auto_lock(lock_);
+  available_shm_segments_.push_back(shm_buffer);
+}
+
+void RTCVideoDecoder::RecordBufferData(const BufferData& buffer_data) {
+  input_buffer_data_.push_front(buffer_data);
+  // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
+  // that's too small for some pathological B-frame test videos.  The cost of
+  // using too-high a value is low (192 bits per extra slot).
+  static const size_t kMaxInputBufferDataSize = 128;
+  // Pop from the back of the list, because that's the oldest and least likely
+  // to be useful in the future data.
+  if (input_buffer_data_.size() > kMaxInputBufferDataSize)
+    input_buffer_data_.pop_back();
+}
+
+void RTCVideoDecoder::GetBufferData(int32 bitstream_buffer_id,
+                                    uint32_t* timestamp,
+                                    uint32_t* width,
+                                    uint32_t* height,
+                                    size_t* size) {
+  for (std::list<BufferData>::iterator it = input_buffer_data_.begin();
+       it != input_buffer_data_.end();
+       ++it) {
+    if (it->bitstream_buffer_id != bitstream_buffer_id)
+      continue;
+    *timestamp = it->timestamp;
+    *width = it->width;
+    *height = it->height;
+    return;
+  }
+  NOTREACHED() << "Missing bitstream buffer id: " << bitstream_buffer_id;
+}
+
+}  // namespace content