Move VideoRenderer out of Filter heirarchy.

media/filters/video_renderer_base.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/video_renderer_base.h"
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
-#include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
-#include "media/filters/video_renderer_base.h"
 
 namespace media {
 
 VideoRendererBase::VideoRendererBase(const base::Closure& paint_cb,
                                      const SetOpaqueCB& set_opaque_cb,
                                      bool drop_frames)
-    : host_(NULL),
-      frame_available_(&lock_),
+    : frame_available_(&lock_),
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_read_(false),
       pending_paint_(false),
       pending_paint_with_last_available_(false),
       drop_frames_(drop_frames),
       playback_rate_(0),
       paint_cb_(paint_cb),
       set_opaque_cb_(set_opaque_cb) {
   DCHECK(!paint_cb_.is_null());
 }
 
-void VideoRendererBase::SetHost(FilterHost* host) {
-  DCHECK(host);
-  DCHECK(!host_);
-  host_ = host;
-}
-
 void VideoRendererBase::Play(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   state_ = kPlaying;
   callback.Run();
 }
 
 void VideoRendererBase::Pause(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
@@ skipping 56 matching lines @@
   DCHECK(!cb.is_null());
   DCHECK(seek_cb_.is_null());
 
   state_ = kSeeking;
   seek_cb_ = cb;
   seek_timestamp_ = time;
   AttemptRead_Locked();
 }
 
 void VideoRendererBase::Initialize(const scoped_refptr<VideoDecoder>& decoder,
-                                   const PipelineStatusCB& status_cb,
+                                   const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
-                                   const TimeCB& time_cb) {
+                                   const TimeCB& time_cb,
+                                   const NaturalSizeChangedCB& size_changed_cb,
+                                   const base::Closure& ended_cb,
+                                   const PipelineStatusCB& error_cb,
+                                   const TimeDeltaCB& get_time_cb,
+                                   const TimeDeltaCB& get_duration_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK(decoder);
-  DCHECK(!status_cb.is_null());
+  DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!time_cb.is_null());
+  DCHECK(!size_changed_cb.is_null());
+  DCHECK(!ended_cb.is_null());
+  DCHECK(!get_time_cb.is_null());
+  DCHECK(!get_duration_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
 
   statistics_cb_ = statistics_cb;
   time_cb_ = time_cb;
+  size_changed_cb_ = size_changed_cb;
+  ended_cb_ = ended_cb;
+  error_cb_ = error_cb;
+  get_time_cb_ = get_time_cb;
+  get_duration_cb_ = get_duration_cb;
 
   // Notify the pipeline of the video dimensions.
-  host_->SetNaturalVideoSize(decoder_->natural_size());
+  size_changed_cb_.Run(decoder_->natural_size());
 
   // We're all good!  Consider ourselves flushed. (ThreadMain() should never
   // see us in the kUninitialized state).
   // Since we had an initial Seek, we consider ourself flushed, because we
   // have not populated any buffers yet.
   state_ = kFlushed;
 
   set_opaque_cb_.Run(!decoder->HasAlpha());
   set_opaque_cb_.Reset();
 
   // Create our video thread.
   if (!base::PlatformThread::Create(0, this, &thread_)) {
     NOTREACHED() << "Video thread creation failed";
     state_ = kError;
-    status_cb.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    init_cb.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
   ::SetThreadPriority(thread_, THREAD_PRIORITY_ABOVE_NORMAL);
 #endif  // defined(OS_WIN)
-  status_cb.Run(PIPELINE_OK);
+  init_cb.Run(PIPELINE_OK);
 }
 
 bool VideoRendererBase::HasEnded() {
   base::AutoLock auto_lock(lock_);
   return state_ == kEnded;
 }
 
 // PlatformThread::Delegate implementation.
 void VideoRendererBase::ThreadMain() {
   base::PlatformThread::SetName("CrVideoRenderer");
@@ skipping 34 matching lines @@
     if (ready_frames_.empty()) {
       frame_available_.TimedWait(kIdleTimeDelta);
       continue;
     }
 
     // Remain idle until we've initialized |current_frame_| via prerolling.
     if (!current_frame_) {
       // This can happen if our preroll only contains end of stream frames.
       if (ready_frames_.front()->IsEndOfStream()) {
         state_ = kEnded;
-        host_->NotifyEnded();
+        ended_cb_.Run();
         ready_frames_.clear();
 
         // No need to sleep here as we idle when |state_ != kPlaying|.
         continue;
       }
 
       frame_available_.TimedWait(kIdleTimeDelta);
       continue;
     }
 
@@ skipping 18 matching lines @@
     // of time and also have the next frame that ready for rendering.
 
 
     // If the next frame is end of stream then we are truly at the end of the
     // video stream.
     //
     // TODO(scherkus): deduplicate this end of stream check after we get rid of
     // |current_frame_|.
     if (ready_frames_.front()->IsEndOfStream()) {
       state_ = kEnded;
-      host_->NotifyEnded();
+      ended_cb_.Run();
       ready_frames_.clear();
 
       // No need to sleep here as we idle when |state_ != kPlaying|.
       continue;
     }
 
     // We cannot update |current_frame_| until we've completed the pending
     // paint. Furthermore, the pending paint might be really slow: check to
     // see if we have any ready frames that we can drop if they've already
     // expired.
     if (pending_paint_) {
       while (!ready_frames_.empty()) {
         // Can't drop anything if we're at the end.
         if (ready_frames_.front()->IsEndOfStream())
           break;
 
         base::TimeDelta remaining_time =
-            ready_frames_.front()->GetTimestamp() - host_->GetTime();
+            ready_frames_.front()->GetTimestamp() - get_time_cb_.Run();
 
         // Still a chance we can render the frame!
         if (remaining_time.InMicroseconds() > 0)
           break;
 
         if (!drop_frames_)
           break;
 
         // Frame dropped: read again.
         ++frames_dropped;
@@ skipping 98 matching lines @@
     DCHECK(!frame);
     PipelineStatus error = PIPELINE_ERROR_DECODE;
     if (status == VideoDecoder::kDecryptError)
       error = PIPELINE_ERROR_DECRYPT;
 
     if (!seek_cb_.is_null()) {
       base::ResetAndReturn(&seek_cb_).Run(error);
       return;
     }
 
-    host_->SetError(error);
+    error_cb_.Run(error);
     return;
   }
 
   // Already-queued Decoder ReadCB's can fire after various state transitions
   // have happened; in that case just drop those frames immediately.
   if (state_ == kStopped || state_ == kError || state_ == kFlushed ||
       state_ == kFlushingDecoder)
     return;
 
   if (state_ == kFlushing) {
@@ skipping 19 matching lines @@
     AttemptRead_Locked();
     return;
   }
 
   // Adjust the incoming frame if its rendering stop time is past the duration
   // of the video itself. This is typically the last frame of the video and
   // occurs if the container specifies a duration that isn't a multiple of the
   // frame rate.  Another way for this to happen is for the container to state a
   // smaller duration than the largest packet timestamp.
   if (!frame->IsEndOfStream()) {
-    if (frame->GetTimestamp() > host_->GetDuration())
-      frame->SetTimestamp(host_->GetDuration());
-    if ((frame->GetTimestamp() + frame->GetDuration()) > host_->GetDuration())
-      frame->SetDuration(host_->GetDuration() - frame->GetTimestamp());
+    base::TimeDelta duration = get_duration_cb_.Run();
+    if (frame->GetTimestamp() > duration)
+      frame->SetTimestamp(duration);
+    if ((frame->GetTimestamp() + frame->GetDuration()) > duration)
+      frame->SetDuration(duration - frame->GetTimestamp());
   }
 
   // This one's a keeper! Place it in the ready queue.
   ready_frames_.push_back(frame);
   DCHECK_LE(NumFrames_Locked(), limits::kMaxVideoFrames);
   if (!frame->IsEndOfStream())
     time_cb_.Run(frame->GetTimestamp() + frame->GetDuration());
   frame_available_.Signal();
 
   PipelineStatistics statistics;
@@ skipping 68 matching lines @@
     state_ = kFlushed;
     current_frame_ = NULL;
     base::ResetAndReturn(&flush_cb_).Run();
   }
 }
 
 base::TimeDelta VideoRendererBase::CalculateSleepDuration(
     const scoped_refptr<VideoFrame>& next_frame,
     float playback_rate) {
   // Determine the current and next presentation timestamps.
-  base::TimeDelta now = host_->GetTime();
+  base::TimeDelta now = get_time_cb_.Run();
   base::TimeDelta this_pts = current_frame_->GetTimestamp();
   base::TimeDelta next_pts;
   if (!next_frame->IsEndOfStream()) {
     next_pts = next_frame->GetTimestamp();
   } else {
     next_pts = this_pts + current_frame_->GetDuration();
   }
 
   // Scale our sleep based on the playback rate.
   base::TimeDelta sleep = next_pts - now;
@@ skipping 12 matching lines @@
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media