Remove reference counting from media::Demuxer and friends.

media/filters/pipeline_integration_test.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/pipeline_integration_test_base.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/crypto/aes_decryptor.h"
+#include "media/filters/chunk_demuxer.h"
 
 using testing::AtMost;
 
 namespace media {
 
 static const char kSourceId[] = "SourceId";
 static const char kClearKeySystem[] = "org.w3.clearkey";
 static const uint8 kInitData[] = { 0x69, 0x6e, 0x69, 0x74 };
 
 static const char kWebM[] = "video/webm; codecs=\"vp8,vorbis\"";
@@ skipping 199 matching lines @@
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
 class MockMediaSource {
  public:
   MockMediaSource(const std::string& filename, const std::string& mimetype,
                   int initial_append_size)
       : file_path_(GetTestDataFilePath(filename)),
         current_position_(0),
         initial_append_size_(initial_append_size),
-        mimetype_(mimetype) {
-    chunk_demuxer_ = new ChunkDemuxer(
-        base::Bind(&MockMediaSource::DemuxerOpened, base::Unretained(this)),
-        base::Bind(&MockMediaSource::DemuxerNeedKey, base::Unretained(this)),
-        LogCB());
+        mimetype_(mimetype),
+        chunk_demuxer_(new ChunkDemuxer(
+            base::Bind(&MockMediaSource::DemuxerOpened,
+                       base::Unretained(this)),
+            base::Bind(&MockMediaSource::DemuxerNeedKey,
+                       base::Unretained(this)),
+            LogCB())),
+        owned_chunk_demuxer_(chunk_demuxer_) {
 
     file_data_ = ReadTestDataFile(filename);
 
     if (initial_append_size_ == kAppendWholeFile)
       initial_append_size_ = file_data_->GetDataSize();
 
     DCHECK_GT(initial_append_size_, 0);
     DCHECK_LE(initial_append_size_, file_data_->GetDataSize());
   }
 
   virtual ~MockMediaSource() {}
 
-  const scoped_refptr<ChunkDemuxer>& demuxer() const { return chunk_demuxer_; }
+  scoped_ptr<Demuxer> GetDemuxer() { return owned_chunk_demuxer_.Pass(); }
 
   void set_need_key_cb(const NeedKeyCB& need_key_cb) {
     need_key_cb_ = need_key_cb;
   }
 
   void Seek(int new_position, int seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek();
 
     chunk_demuxer_->Abort(kSourceId);
 
     DCHECK_GE(new_position, 0);
     DCHECK_LT(new_position, file_data_->GetDataSize());
     current_position_ = new_position;
 
     AppendData(seek_append_size);
   }
 
   void AppendData(int size) {
-    DCHECK(chunk_demuxer_.get());
+    DCHECK(chunk_demuxer_);
     DCHECK_LT(current_position_, file_data_->GetDataSize());
     DCHECK_LE(current_position_ + size, file_data_->GetDataSize());
     chunk_demuxer_->AppendData(
         kSourceId, file_data_->GetData() + current_position_, size);
     current_position_ += size;
   }
 
   void AppendAtTime(const base::TimeDelta& timestampOffset,
                     const uint8* pData, int size) {
     CHECK(chunk_demuxer_->SetTimestampOffset(kSourceId, timestampOffset));
     chunk_demuxer_->AppendData(kSourceId, pData, size);
     CHECK(chunk_demuxer_->SetTimestampOffset(kSourceId, base::TimeDelta()));
   }
 
   void EndOfStream() {
     chunk_demuxer_->EndOfStream(PIPELINE_OK);
   }
 
   void Abort() {
-    if (!chunk_demuxer_.get())
+    if (!chunk_demuxer_)
       return;
     chunk_demuxer_->Shutdown();
     chunk_demuxer_ = NULL;
   }
 
   void DemuxerOpened() {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&MockMediaSource::DemuxerOpenedTask,
                               base::Unretained(this)));
   }
@@ skipping 19 matching lines @@
     need_key_cb_.Run(
         std::string(), std::string(), type, init_data.Pass(), init_data_size);
   }
 
  private:
   base::FilePath file_path_;
   scoped_refptr<DecoderBuffer> file_data_;
   int current_position_;
   int initial_append_size_;
   std::string mimetype_;
-  scoped_refptr<ChunkDemuxer> chunk_demuxer_;
+  ChunkDemuxer* chunk_demuxer_;
+  scoped_ptr<Demuxer> owned_chunk_demuxer_;
   NeedKeyCB need_key_cb_;
 };
 
 class PipelineIntegrationTest
     : public testing::Test,
       public PipelineIntegrationTestBase {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kHaveMetadata))
         .Times(AtMost(1));
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kPrerollCompleted))
         .Times(AtMost(1));
     pipeline_->Start(
-        CreateFilterCollection(source->demuxer(), NULL),
+        CreateFilterCollection(source->GetDemuxer(), NULL),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK),
         base::Bind(&PipelineIntegrationTest::OnBufferingState,
                    base::Unretained(this)),
         base::Closure());
 
     message_loop_.Run();
   }
 
   void StartPipelineWithEncryptedMedia(
       MockMediaSource* source,
       FakeEncryptedMedia* encrypted_media) {
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kHaveMetadata))
         .Times(AtMost(1));
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kPrerollCompleted))
         .Times(AtMost(1));
     pipeline_->Start(
-        CreateFilterCollection(source->demuxer(), encrypted_media->decryptor()),
+        CreateFilterCollection(source->GetDemuxer(),
+                               encrypted_media->decryptor()),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK),
         base::Bind(&PipelineIntegrationTest::OnBufferingState,
                    base::Unretained(this)),
         base::Closure());
 
     source->set_need_key_cb(base::Bind(&FakeEncryptedMedia::NeedKey,
                                        base::Unretained(encrypted_media)));
 
@@ skipping 544 matching lines @@
 // back.
 // Disabled since it might crash or corrupt heap, see http://crbug.com/173333
 TEST_F(PipelineIntegrationTest, DISABLED_BasicPlayback_VP9_Opus_WebM) {
   ASSERT_TRUE(Start(GetTestDataFilePath("bear-vp9-opus.webm"),
                     PIPELINE_OK));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 }  // namespace media