Remove reference counting from media::Demuxer and friends.

media/filters/ffmpeg_demuxer_unittest.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 <algorithm>
 #include <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 51 matching lines @@
 // FFmpeg, pipeline and filter host mocks.
 class FFmpegDemuxerTest : public testing::Test {
  protected:
   FFmpegDemuxerTest() {}
 
   virtual ~FFmpegDemuxerTest() {
     if (demuxer_) {
       demuxer_->Stop(MessageLoop::QuitWhenIdleClosure());
       message_loop_.Run();
     }
-
-    demuxer_ = NULL;
   }
 
   void CreateDemuxer(const std::string& name) {
     CHECK(!demuxer_);
 
     EXPECT_CALL(host_, SetTotalBytes(_)).Times(AnyNumber());
     EXPECT_CALL(host_, AddBufferedByteRange(_, _)).Times(AnyNumber());
     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
 
     CreateDataSource(name);
 
     media::FFmpegNeedKeyCB need_key_cb =
         base::Bind(&FFmpegDemuxerTest::NeedKeyCB, base::Unretained(this));
-    demuxer_ = new FFmpegDemuxer(message_loop_.message_loop_proxy(),
-                                 data_source_,
-                                 need_key_cb);
+    demuxer_.reset(new FFmpegDemuxer(
+        message_loop_.message_loop_proxy(), data_source_, need_key_cb));
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxer() {
     EXPECT_CALL(host_, SetDuration(_));
     WaitableMessageLoopEvent event;
     demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
@@ skipping 41 matching lines @@
   }
 
   // Accessor to demuxer internals.
   void set_duration_known(bool duration_known) {
     demuxer_->duration_known_ = duration_known;
   }
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
-    return static_cast<FFmpegDemuxerStream*>(stream)->stopped_;
+    return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
   }
 
   // Fixture members.
   scoped_refptr<FileDataSource> data_source_;
-  scoped_refptr<FFmpegDemuxer> demuxer_;
+  scoped_ptr<FFmpegDemuxer> demuxer_;
   StrictMock<MockDemuxerHost> host_;
   MessageLoop message_loop_;
 
   AVFormatContext* format_context() {
     return demuxer_->glue_->format_context();
   }
 
   void ReadUntilEndOfStream() {
     // We should expect an end of stream buffer.
     scoped_refptr<DemuxerStream> audio =
@@ skipping 334 matching lines @@
   // Create our mocked callback. The Callback created by base::Bind() will take
   // ownership of this pointer.
   StrictMock<MockReadCB>* callback = new StrictMock<MockReadCB>();
 
   // The callback should be immediately deleted.  We'll use a checkpoint to
   // verify that it has indeed been deleted.
   EXPECT_CALL(*callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
   EXPECT_CALL(*callback, OnDelete());
   EXPECT_CALL(*this, CheckPoint(1));
 
-  // Release the reference to the demuxer. This should also destroy it.
-  demuxer_ = NULL;
-  // |audio| now has a demuxer_ pointer to invalid memory.
+  // Destroy the demuxer. |audio| now has a demuxer_ pointer to invalid memory.
+  demuxer_.reset();
 
   // Attempt the read...
   audio->Read(base::Bind(&MockReadCB::Run, callback));
 
   message_loop_.RunUntilIdle();
 
   // ...and verify that |callback| was deleted.
   CheckPoint(1);
 }
 
@@ skipping 127 matching lines @@
 TEST_F(FFmpegDemuxerTest, MP4_ZeroStszEntry) {
 #if !defined(USE_PROPRIETARY_CODECS)
   return;
 #endif
   CreateDemuxer("bear-1280x720-zero-stsz-entry.mp4");
   InitializeDemuxer();
   ReadUntilEndOfStream();
 }
 
 }  // namespace media