Remove reference counting from media::VideoDecoder and friends.

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/message_loop.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"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "media/filters/video_decoder_selector.h"
 
 namespace media {
 
 base::TimeDelta VideoRendererBase::kMaxLastFrameDuration() {
   return base::TimeDelta::FromMilliseconds(250);
 }
 
 VideoRendererBase::VideoRendererBase(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    ScopedVector<VideoDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     const PaintCB& paint_cb,
     const SetOpaqueCB& set_opaque_cb,
     bool drop_frames)
     : message_loop_(message_loop),
       weak_factory_(this),
-      set_decryptor_ready_cb_(set_decryptor_ready_cb),
+      decoder_selector_(new VideoDecoderSelector(
+          message_loop, decoders.Pass(), set_decryptor_ready_cb)),
       received_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_read_(false),
       drop_frames_(drop_frames),
       playback_rate_(0),
       paint_cb_(paint_cb),
       set_opaque_cb_(set_opaque_cb),
       last_timestamp_(kNoTimestamp()) {
   DCHECK(!paint_cb_.is_null());
 }
 
 VideoRendererBase::~VideoRendererBase() {
   base::AutoLock auto_lock(lock_);
   CHECK(state_ == kStopped || state_ == kUninitialized) << state_;
   CHECK_EQ(thread_, base::kNullThreadHandle);

[Ami GONE FROM CHROMIUM, 2013/03/22 23:48:01]

should also weak_factory_.InvalidateWeakPtrs().

[scherkus (not reviewing), 2013/03/28 02:00:01]

Was this comment based on how you thought weak_ptr_ worked? (i.e., can I ignore
it?)

 }
 
 void VideoRendererBase::Play(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   state_ = kPlaying;
   callback.Run();
 }
 
@@ skipping 94 matching lines @@
   DCHECK(!cb.is_null());
   DCHECK(preroll_cb_.is_null());
 
   state_ = kPrerolling;
   preroll_cb_ = cb;
   preroll_timestamp_ = time;
   AttemptRead_Locked();
 }
 
 void VideoRendererBase::Initialize(const scoped_refptr<DemuxerStream>& stream,
-                                   const VideoDecoderList& decoders,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
                                    const TimeCB& max_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) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
-  DCHECK(!decoders.empty());
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!max_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_);
 
   weak_this_ = weak_factory_.GetWeakPtr();
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   max_time_cb_ = max_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;
   state_ = kInitializing;
 
-  scoped_ptr<VideoDecoderSelector> decoder_selector(
-      new VideoDecoderSelector(base::MessageLoopProxy::current(),
-                               decoders,
-                               set_decryptor_ready_cb_));
-
-  // To avoid calling |decoder_selector| methods and passing ownership of
-  // |decoder_selector| in the same line.
-  VideoDecoderSelector* decoder_selector_ptr = decoder_selector.get();
-
-  decoder_selector_ptr->SelectVideoDecoder(
+  decoder_selector_->SelectVideoDecoder(
       stream,
       statistics_cb,
-      base::Bind(&VideoRendererBase::OnDecoderSelected, weak_this_,
-                 base::Passed(&decoder_selector)));
+      base::Bind(&VideoRendererBase::OnDecoderSelected, weak_this_));
 }
 
 void VideoRendererBase::OnDecoderSelected(
-    scoped_ptr<VideoDecoderSelector> decoder_selector,
-    const scoped_refptr<VideoDecoder>& selected_decoder,
+    scoped_ptr<VideoDecoder> decoder,
     const scoped_refptr<DecryptingDemuxerStream>& decrypting_demuxer_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
 
   if (state_ == kStopped)
     return;
 
   DCHECK_EQ(state_, kInitializing);
 
-  if (!selected_decoder) {
+  if (!decoder) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  decoder_ = selected_decoder;
+  decoder_ = decoder.Pass();
   decrypting_demuxer_stream_ = decrypting_demuxer_stream;
 
   // We're all good!  Consider ourselves flushed. (ThreadMain() should never
   // see us in the kUninitialized state).
   // Since we had an initial Preroll(), we consider ourself flushed, because we
   // have not populated any buffers yet.
   state_ = kFlushed;
 
   set_opaque_cb_.Run(!decoder_->HasAlpha());
   set_opaque_cb_.Reset();
@@ skipping 327 matching lines @@
   // Because we might remain in the prerolled state for an undetermined amount
   // of time (e.g., we seeked while paused), we'll paint the first prerolled
   // frame.
   if (!ready_frames_.empty())
     PaintNextReadyFrame_Locked();
 
   base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media