Fold DecoderStream::Stop() into the dtor.

media/filters/video_renderer_impl.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 "media/filters/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<VideoDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     const PaintCB& paint_cb,
     bool drop_frames)
     : task_runner_(task_runner),
-      video_frame_stream_(task_runner, decoders.Pass(), set_decryptor_ready_cb),
+      video_frame_stream_(new VideoFrameStream(task_runner,
+                                               decoders.Pass(),
+                                               set_decryptor_ready_cb)),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       paint_cb_(paint_cb),
@@ skipping 20 matching lines @@
   // This is necessary if the |video_frame_stream_| has already seen an end of
   // stream and needs to drain it before flushing it.
   ready_frames_.clear();
   if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
     buffering_state_ = BUFFERING_HAVE_NOTHING;
     buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
   }
   received_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
-  video_frame_stream_.Reset(
+  video_frame_stream_->Reset(
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamResetDone,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::Stop(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   if (state_ == kUninitialized || state_ == kStopped) {
-    callback.Run();
+    task_runner_->PostTask(FROM_HERE, callback);
     return;
   }
 
   // TODO(scherkus): Consider invalidating |weak_factory_| and replacing
   // task-running guards that check |state_| with DCHECK().
 
   state_ = kStopped;
 
   statistics_cb_.Reset();
   max_time_cb_.Reset();
   DoStopOrError_Locked();
 
   // Clean up our thread if present.
   base::PlatformThreadHandle thread_to_join = base::PlatformThreadHandle();
   if (!thread_.is_null()) {
     // Signal the thread since it's possible to get stopped with the video
     // thread waiting for a read to complete.
     frame_available_.Signal();
     std::swap(thread_, thread_to_join);
   }
 
   if (!thread_to_join.is_null()) {
     base::AutoUnlock auto_unlock(lock_);
     base::PlatformThread::Join(thread_to_join);
   }
 
-  video_frame_stream_.Stop(callback);
+  video_frame_stream_.reset();

[scherkus (not reviewing), 2014/07/16 17:49:48]

ditto

[xhwang, 2014/07/16 23:45:49]

ditto

+  task_runner_->PostTask(FROM_HERE, callback);
 }
 
 void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK(!pending_read_);
   DCHECK(ready_frames_.empty());
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
@@ skipping 30 matching lines @@
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   max_time_cb_ = max_time_cb;
   buffering_state_cb_ = buffering_state_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   get_time_cb_ = get_time_cb;
   get_duration_cb_ = get_duration_cb;
   state_ = kInitializing;
 
-  video_frame_stream_.Initialize(
+  video_frame_stream_->Initialize(
       stream,
       low_delay,
       statistics_cb,
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::OnVideoFrameStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
@@ skipping 180 matching lines @@
   // Always request more decoded video if we have capacity. This serves two
   // purposes:
   //   1) Prerolling while paused
   //   2) Keeps decoding going if video rendering thread starts falling behind
   AttemptRead_Locked();
 }
 
 bool VideoRendererImpl::HaveEnoughData_Locked() {
   DCHECK_EQ(state_, kPlaying);
   return received_end_of_stream_ ||
-      !video_frame_stream_.CanReadWithoutStalling() ||
+      !video_frame_stream_->CanReadWithoutStalling() ||
       ready_frames_.size() >= static_cast<size_t>(limits::kMaxVideoFrames) ||
       (low_delay_ && ready_frames_.size() > 0);
 }
 
 void VideoRendererImpl::TransitionToHaveEnough_Locked() {
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   if (received_end_of_stream_)
     max_time_cb_.Run(get_duration_cb_.Run());
 
@@ skipping 59 matching lines @@
   lock_.AssertAcquired();
 
   if (pending_read_ || received_end_of_stream_ ||
       ready_frames_.size() == static_cast<size_t>(limits::kMaxVideoFrames)) {
     return;
   }
 
   switch (state_) {
     case kPlaying:
       pending_read_ = true;
-      video_frame_stream_.Read(base::Bind(&VideoRendererImpl::FrameReady,
-                                          weak_factory_.GetWeakPtr()));
+      video_frame_stream_->Read(base::Bind(&VideoRendererImpl::FrameReady,
+                                           weak_factory_.GetWeakPtr()));
       return;
 
     case kUninitialized:
     case kInitializing:
     case kFlushing:
     case kFlushed:
     case kStopped:
       return;
   }
 }
@@ skipping 34 matching lines @@
     statistics_cb_.Run(statistics);
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media