Move Demuxer::set_host() to Initialize().

media/filters/chunk_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 "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
@@ skipping 72 matching lines @@
  protected:
   enum CodecsIndex {
     AUDIO,
     VIDEO,
     MAX_CODECS_INDEX
   };
 
   ChunkDemuxerTest()
       : client_(new MockChunkDemuxerClient()),
         demuxer_(new ChunkDemuxer(client_.get())) {
-    demuxer_->set_host(&mock_demuxer_host_);
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInfoTracks(bool has_audio, bool has_video,
                         bool video_content_encoded, scoped_array<uint8>* buffer,
                         int* size) {
     scoped_array<uint8> info;
@@ skipping 50 matching lines @@
                video_content_encodings_size);
         video_track_entry_size += video_content_encodings_size;
         WriteInt64(buf + kVideoTrackSizeOffset,
                    video_track_entry_size - kVideoTrackEntryHeaderSize);
       }
       buf += video_track_entry_size;
     }
   }
 
   bool AppendData(const uint8* data, size_t length) {
-    EXPECT_CALL(mock_demuxer_host_, SetBufferedBytes(_)).Times(AnyNumber());
-    EXPECT_CALL(mock_demuxer_host_, SetBufferedTime(_)).Times(AnyNumber());
-    EXPECT_CALL(mock_demuxer_host_, SetNetworkActivity(true))
+    EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
+    EXPECT_CALL(host_, SetBufferedTime(_)).Times(AnyNumber());
+    EXPECT_CALL(host_, SetNetworkActivity(true))
         .Times(AnyNumber());
     return demuxer_->AppendData(data, length);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length) {
     return AppendDataInPieces(data, length, 7);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
     const uint8* start = data;
@@ skipping 18 matching lines @@
   }
 
   void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
   }
 
   PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
                                     PipelineStatus expected_status) {
     if (expected_status == PIPELINE_OK) {
-      EXPECT_CALL(mock_demuxer_host_, SetDuration(expected_duration));
-      EXPECT_CALL(mock_demuxer_host_, SetCurrentReadPosition(_));
+      EXPECT_CALL(host_, SetDuration(expected_duration));
+      EXPECT_CALL(host_, SetCurrentReadPosition(_));
     }
 
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
                       expected_status);
   }
 
   bool InitDemuxer(bool has_audio, bool has_video,
                    bool video_content_encoded) {
     PipelineStatus expected_status =
         (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN;
 
     EXPECT_CALL(*client_, DemuxerOpened(_));
-    demuxer_->Initialize(CreateInitDoneCB(
-        kDefaultDuration(), expected_status));
+    demuxer_->Initialize(
+        &host_, CreateInitDoneCB(kDefaultDuration(), expected_status));
 
     return AppendInfoTracks(has_audio, has_video, video_content_encoded);
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       EXPECT_CALL(*client_, DemuxerClosed());
       demuxer_->Shutdown();
     }
   }
@@ skipping 31 matching lines @@
   //    a timestamp of kSkip indicates that a Read() call for that stream
   //    shouldn't be made on that iteration of the loop. If both streams have
   //    a kSkip then the loop will terminate.
   bool ParseWebMFile(const std::string& filename,
                      const BufferTimestamps* timestamps,
                      const base::TimeDelta& duration) {
     scoped_array<uint8> buffer;
     int buffer_size = 0;
 
     EXPECT_CALL(*client_, DemuxerOpened(_));
-    demuxer_->Initialize(CreateInitDoneCB(duration, PIPELINE_OK));
+    demuxer_->Initialize(
+        &host_, CreateInitDoneCB(duration, PIPELINE_OK));
 
     // Read a WebM file into memory and send the data to the demuxer.
     ReadTestDataFile(filename, &buffer, &buffer_size);
     if (!AppendDataInPieces(buffer.get(), buffer_size, 512))
       return false;
 
     scoped_refptr<DemuxerStream> audio =
         demuxer_->GetStream(DemuxerStream::AUDIO);
     scoped_refptr<DemuxerStream> video =
         demuxer_->GetStream(DemuxerStream::VIDEO);
@@ skipping 23 matching lines @@
                                    timestamps[i].video_time_ms),
                                &video_read_done));
 
         EXPECT_TRUE(video_read_done);
       }
     }
 
     return true;
   }
 
-  MockDemuxerHost mock_demuxer_host_;
+  MockDemuxerHost host_;
 
   scoped_ptr<MockChunkDemuxerClient> client_;
   scoped_refptr<ChunkDemuxer> demuxer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
   // Test no streams, audio-only, video-only, and audio & video scenarios,
   // with video content encoded or not.
   for (int i = 0; i < 8; i++) {
     bool has_audio = (i & 0x1) != 0;
     bool has_video = (i & 0x2) != 0;
     bool video_content_encoded = (i & 0x4) != 0;
 
     // No test on invalid combination.
     if (!has_video && video_content_encoded)
       continue;
 
     client_.reset(new MockChunkDemuxerClient());
     demuxer_ = new ChunkDemuxer(client_.get());
-    demuxer_->set_host(&mock_demuxer_host_);
     ASSERT_TRUE(InitDemuxer(has_audio, has_video, video_content_encoded));
 
     scoped_refptr<DemuxerStream> audio_stream =
         demuxer_->GetStream(DemuxerStream::AUDIO);
     if (has_audio) {
       ASSERT_TRUE(audio_stream);
 
       const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
       EXPECT_EQ(kCodecVorbis, config.codec());
       EXPECT_EQ(16, config.bits_per_channel());
@@ skipping 162 matching lines @@
   // that overlaps.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   AddSimpleBlock(&cb, kAudioTrackNum, 28);
   AddSimpleBlock(&cb, kVideoTrackNum, 40);
   scoped_ptr<Cluster> cluster_b(cb.Finish());
 
   // Make sure that AppendData() fails because this cluster data
   // is before previous data.
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(45);
   AddSimpleBlock(&cb, kAudioTrackNum, 45);
   AddSimpleBlock(&cb, kVideoTrackNum, 45);
   scoped_ptr<Cluster> cluster_c(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(cluster_c->data(), cluster_c->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestNonMonotonicButAboveClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
   // Test the case where block timecodes are not monotonically
   // increasing but stay above the cluster timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   AddSimpleBlock(&cb, kAudioTrackNum, 7);
   AddSimpleBlock(&cb, kVideoTrackNum, 15);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(20);
   AddSimpleBlock(&cb, kAudioTrackNum, 20);
   AddSimpleBlock(&cb, kVideoTrackNum, 20);
   scoped_ptr<Cluster> cluster_b(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(cluster_b->data(), cluster_b->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestBackwardsAndBeforeClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
   // Test timecodes going backwards and including values less than the cluster
   // timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 3);
   AddSimpleBlock(&cb, kVideoTrackNum, 3);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(6);
   AddSimpleBlock(&cb, kAudioTrackNum, 6);
   AddSimpleBlock(&cb, kVideoTrackNum, 6);
   scoped_ptr<Cluster> cluster_b(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(cluster_b->data(), cluster_b->size()));
 }
 
 
 TEST_F(ChunkDemuxerTest, TestPerStreamMonotonicallyIncreasingTimestamps) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
   // Test strict monotonic increasing timestamps on a per stream
   // basis.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   scoped_ptr<Cluster> cluster(cb.Finish());
 
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestMonotonicallyIncreasingTimestampsAcrossClusters) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
   // Test strict monotonic increasing timestamps on a per stream
   // basis across clusters.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   scoped_ptr<Cluster> cluster_b(cb.Finish());
 
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(10);
   AddSimpleBlock(&cb, kAudioTrackNum, 10);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   scoped_ptr<Cluster> cluster_c(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(cluster_c->data(), cluster_c->size()));
 }
 
 // Test the case where a cluster is passed to AppendData() before
 // INFO & TRACKS data.
 TEST_F(ChunkDemuxerTest, TestClusterBeforeInfoTracks) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Initialize(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+  demuxer_->Initialize(
+      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kVideoTrackNum, 0);
   scoped_ptr<Cluster> cluster(cb.Finish());
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
 // Test cases where we get an EndOfStream() call during initialization.
 TEST_F(ChunkDemuxerTest, TestEOSDuringInit) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Initialize(NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+  demuxer_->Initialize(
+      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 TEST_F(ChunkDemuxerTest, TestDecodeErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kAudioTrackNum, 0);
   AddSimpleBlock(&cb, kVideoTrackNum, 0);
   AddSimpleBlock(&cb, kAudioTrackNum, 23);
   AddSimpleBlock(&cb, kVideoTrackNum, 33);
   scoped_ptr<Cluster> cluster(cb.Finish());
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   demuxer_->EndOfStream(PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(ChunkDemuxerTest, TestNetworkErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kAudioTrackNum, 0);
   AddSimpleBlock(&cb, kVideoTrackNum, 0);
   AddSimpleBlock(&cb, kAudioTrackNum, 23);
   AddSimpleBlock(&cb, kVideoTrackNum, 33);
   scoped_ptr<Cluster> cluster(cb.Finish());
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_NETWORK));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_NETWORK));
   demuxer_->EndOfStream(PIPELINE_ERROR_NETWORK);
 }
 
 // Helper class to reduce duplicate code when testing end of stream
 // Read() behavior.
 class EndOfStreamHelper {
  public:
   EndOfStreamHelper(const scoped_refptr<Demuxer> demuxer)
       : demuxer_(demuxer),
         audio_read_done_(false),
@@ skipping 131 matching lines @@
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 
   end_of_stream_helper_3.RequestReads();
   end_of_stream_helper_3.CheckIfReadDonesWereCalled(true);
 }
 
 // Make sure AppendData() will accept elements that span multiple calls.
 TEST_F(ChunkDemuxerTest, TestAppendingInPieces) {
 
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Initialize(CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+  demuxer_->Initialize(
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
   CreateInfoTracks(true, true, false, &info_tracks, &info_tracks_size);
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   AddSimpleBlock(&cb, kAudioTrackNum, 32, 512);
   AddSimpleBlock(&cb, kVideoTrackNum, 123, 1024);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
@@ skipping 174 matching lines @@
 
   // Append the remaining data.
   ASSERT_TRUE(AppendData(cluster->data() + i, cluster->size() - i));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 
 TEST_F(ChunkDemuxerTest, TestParseErrorDuringInit) {
-  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
 
   EXPECT_CALL(*client_, DemuxerOpened(_));
-  demuxer_->Initialize(CreateInitDoneCB(
-      kDefaultDuration(), PIPELINE_OK));
+  demuxer_->Initialize(
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
   ASSERT_TRUE(AppendInfoTracks(true, true, false));
 
   uint8 tmp = 0;
   ASSERT_TRUE(demuxer_->AppendData(&tmp, 1));
 }
 
 }  // namespace media