Remove reference counting from media::Demuxer and friends.

media/tools/demuxer_bench/demuxer_bench.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.
 //
 // demuxer_bench is a standalone benchmarking tool for FFmpegDemuxer. It
 // simulates the reading requirements for playback by reading from the stream
 // that has the earliest timestamp.
 
 #include <iostream>
 
@@ skipping 36 matching lines @@
              int init_data_size) {
   LOG(INFO) << "File is encrypted.";
 }
 
 typedef std::vector<scoped_refptr<media::DemuxerStream> > Streams;
 
 // Simulates playback reading requirements by reading from each stream
 // present in |demuxer| in as-close-to-monotonically-increasing timestamp order.
 class StreamReader {
  public:
-  explicit StreamReader(const scoped_refptr<media::Demuxer>& demuxer);
+  explicit StreamReader(media::Demuxer* demuxer);
   ~StreamReader();
 
   // Performs a single step read.
   void Read();
 
   // Returns true when all streams have reached end of stream.
   bool IsDone();
 
   int number_of_streams() { return streams_.size(); }
   const Streams& streams() { return streams_; }
   const std::vector<int>& counts() { return counts_; }
 
  private:
   void OnReadDone(MessageLoop* message_loop,
                   bool* end_of_stream,
                   base::TimeDelta* timestamp,
                   media::DemuxerStream::Status status,
                   const scoped_refptr<media::DecoderBuffer>& buffer);
   int GetNextStreamIndexToRead();
 
   Streams streams_;
   std::vector<bool> end_of_stream_;
   std::vector<base::TimeDelta> last_read_timestamp_;
   std::vector<int> counts_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamReader);
 };
 
-StreamReader::StreamReader(const scoped_refptr<media::Demuxer> &demuxer) {
+StreamReader::StreamReader(media::Demuxer* demuxer) {
   scoped_refptr<media::DemuxerStream> stream;
   stream = demuxer->GetStream(media::DemuxerStream::AUDIO);
   if (stream) {
     streams_.push_back(stream);
     end_of_stream_.push_back(false);
     last_read_timestamp_.push_back(media::kNoTimestamp());
     counts_.push_back(0);
   }
 
   stream = demuxer->GetStream(media::DemuxerStream::VIDEO);
@@ skipping 79 matching lines @@
   MessageLoop message_loop;
   DemuxerHostImpl demuxer_host;
   base::FilePath file_path(cmd_line->GetArgs()[0]);
 
   // Setup.
   scoped_refptr<media::FileDataSource> data_source =
       new media::FileDataSource();
   CHECK(data_source->Initialize(file_path));
 
   media::FFmpegNeedKeyCB need_key_cb = base::Bind(&NeedKey);
-  scoped_refptr<media::FFmpegDemuxer> demuxer =
-      new media::FFmpegDemuxer(message_loop.message_loop_proxy(), data_source,
-                               need_key_cb);
+  scoped_ptr<media::FFmpegDemuxer> demuxer(new media::FFmpegDemuxer(
+      message_loop.message_loop_proxy(), data_source, need_key_cb));
 
   demuxer->Initialize(&demuxer_host, base::Bind(
       &QuitLoopWithStatus, &message_loop));
   message_loop.Run();
 
-  StreamReader stream_reader(demuxer);
+  StreamReader stream_reader(demuxer.get());
 
   // Benchmark.
   base::TimeTicks start = base::TimeTicks::HighResNow();
   while (!stream_reader.IsDone()) {
     stream_reader.Read();
   }
   base::TimeTicks end = base::TimeTicks::HighResNow();
 
   // Results.
   std::cout << "Time: " << (end - start).InMillisecondsF() << " ms\n";
@@ skipping 12 matching lines @@
     std::cout << ", " << stream_reader.counts()[i] << " packets" << std::endl;
   }
 
   // Teardown.
   demuxer->Stop(base::Bind(
       &QuitLoopWithStatus, &message_loop, media::PIPELINE_OK));
   message_loop.Run();
 
   return 0;
 }