Remove reference counting from media::DemuxerStream 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 30 matching lines @@
                         media::PipelineStatus status) {
   CHECK_EQ(status, media::PIPELINE_OK);
   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 static void NeedKey(const std::string& type, scoped_ptr<uint8[]> init_data,
              int init_data_size) {
   LOG(INFO) << "File is encrypted.";
 }
 
-typedef std::vector<scoped_refptr<media::DemuxerStream> > Streams;
+typedef std::vector<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(media::Demuxer* demuxer);
   ~StreamReader();
 
   // Performs a single step read.
   void Read();
@@ skipping 15 matching lines @@
 
   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(media::Demuxer* demuxer) {
-  scoped_refptr<media::DemuxerStream> stream;
-  stream = demuxer->GetStream(media::DemuxerStream::AUDIO);
+  media::DemuxerStream* 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);
   if (stream) {
     streams_.push_back(stream);
     end_of_stream_.push_back(false);
     last_read_timestamp_.push_back(media::kNoTimestamp());
     counts_.push_back(0);
   }
 }
 
 StreamReader::~StreamReader() {}
 
 void StreamReader::Read() {
   int index = GetNextStreamIndexToRead();
   bool end_of_stream = false;
   base::TimeDelta timestamp;
 
   streams_[index]->Read(base::Bind(
       &StreamReader::OnReadDone, base::Unretained(this),
       base::MessageLoop::current(), &end_of_stream, &timestamp));
   base::MessageLoop::current()->Run();
 
-  CHECK(timestamp != media::kNoTimestamp());
+  CHECK(end_of_stream || timestamp != media::kNoTimestamp());
   end_of_stream_[index] = end_of_stream;
   last_read_timestamp_[index] = timestamp;
   counts_[index]++;
 }
 
 bool StreamReader::IsDone() {
   for (size_t i = 0; i < end_of_stream_.size(); ++i) {
     if (!end_of_stream_[i])
       return false;
   }
   return true;
 }
 
 void StreamReader::OnReadDone(
     base::MessageLoop* message_loop,
     bool* end_of_stream,
     base::TimeDelta* timestamp,
     media::DemuxerStream::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   CHECK_EQ(status, media::DemuxerStream::kOk);
   CHECK(buffer);
   *end_of_stream = buffer->IsEndOfStream();
-  *timestamp = buffer->GetTimestamp();
+  *timestamp = *end_of_stream ? media::kNoTimestamp() : buffer->GetTimestamp();
   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 int StreamReader::GetNextStreamIndexToRead() {
   int index = -1;
   for (int i = 0; i < number_of_streams(); ++i) {
     // Ignore streams at EOS.
     if (end_of_stream_[i])
       continue;
 
@@ skipping 44 matching lines @@
   // 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";
   for (int i = 0; i < stream_reader.number_of_streams(); ++i) {
-    scoped_refptr<media::DemuxerStream> stream = stream_reader.streams()[i];
+    media::DemuxerStream* stream = stream_reader.streams()[i];
     std::cout << "Stream #" << i << ": ";
 
     if (stream->type() == media::DemuxerStream::AUDIO) {
       std::cout << "audio";
     } else if (stream->type() == media::DemuxerStream::VIDEO) {
       std::cout << "video";
     } else {
       std::cout << "unknown";
     }
 
     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;
 }