refactoring decoder interface

media/filters/video_renderer_base.cc

 // Copyright (c) 2010 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 "base/callback.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/base/video_frame.h"
 #include "media/filters/video_renderer_base.h"
 
@@ skipping 128 matching lines @@
 
 void VideoRendererBase::Initialize(VideoDecoder* decoder,
                                    FilterCallback* callback) {
   AutoLock auto_lock(lock_);
   DCHECK(decoder);
   DCHECK(callback);
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
   scoped_ptr<FilterCallback> c(callback);
 
+  decoder_->set_fill_buffer_done_callback(
+      NewCallback(this, &VideoRendererBase::OnFillBufferDone));
   // Notify the pipeline of the video dimensions.
   if (!ParseMediaFormat(decoder->media_format(), &width_, &height_,
                         &uses_egl_image_)) {
     host()->SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
     callback->Run();
     return;
   }
   host()->SetVideoSize(width_, height_);
 
   // Initialize the subclass.
@@ skipping 146 matching lines @@
 
 void VideoRendererBase::GetCurrentFrame(scoped_refptr<VideoFrame>* frame_out) {
   AutoLock auto_lock(lock_);
   // We should have initialized and have the current frame.
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
          state_ == kEnded);
   DCHECK(current_frame_);
   *frame_out = current_frame_;
 }
 
-void VideoRendererBase::OnReadComplete(VideoFrame* frame) {
+void VideoRendererBase::OnFillBufferDone(scoped_refptr<VideoFrame> frame) {
   AutoLock auto_lock(lock_);
 
   // TODO(ajwong): Work around cause we don't synchronize on stop. Correct
   // fix is to resolve http://crbug.com/16059.
   if (state_ == kStopped) {
     return;
   }
 
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
          state_ == kEnded);
@@ skipping 34 matching lines @@
       pause_callback_.reset();
     }
   }
 }
 
 void VideoRendererBase::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   DCHECK_NE(kEnded, state_);
   DCHECK_LT(pending_reads_, kMaxFrames);
   ++pending_reads_;
-  decoder_->Read(NewCallback(this, &VideoRendererBase::OnReadComplete));
+  // TODO(jiesun): We use dummy buffer to feed decoder to let decoder to
+  // provide buffer pools. In the future, we may want to implement real
+  // buffer pool to recycle buffers.
+  scoped_refptr<VideoFrame> video_frame;
+  decoder_->FillThisBuffer(video_frame);
 }
 
 base::TimeDelta VideoRendererBase::CalculateSleepDuration(
     VideoFrame* next_frame, float playback_rate) {
   // Determine the current and next presentation timestamps.
   base::TimeDelta now = host()->GetTime();
   base::TimeDelta this_pts = current_frame_->GetTimestamp();
   base::TimeDelta next_pts;
   if (next_frame) {
     next_pts = next_frame->GetTimestamp();
@@ skipping 12 matching lines @@
     previous_time_ = now;
   }
 
   // Scale our sleep based on the playback rate.
   // TODO(scherkus): floating point badness and degrade gracefully.
   return base::TimeDelta::FromMicroseconds(
       static_cast<int64>(sleep.InMicroseconds() / playback_rate));
 }
 
 }  // namespace media