Removing DataSource from Filter hierarchy

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2011 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_filter_host.h"
+#include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/chunk_demuxer_client.h"
 #include "media/webm/cluster_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
@@ skipping 88 matching lines @@
       buf += audio_track_entry_size;
     }
 
     if (has_video) {
       memcpy(buf, video_track_entry.get(), video_track_entry_size);
       buf += video_track_entry_size;
     }
   }
 
   void AppendData(const uint8* data, size_t length) {
-    EXPECT_CALL(mock_filter_host_, SetBufferedBytes(_)).Times(AnyNumber());
-    EXPECT_CALL(mock_filter_host_, SetBufferedTime(_)).Times(AnyNumber());
-    EXPECT_CALL(mock_filter_host_, SetNetworkActivity(true)).Times(AnyNumber());
+    EXPECT_CALL(mock_demuxer_host_, SetBufferedBytes(_)).Times(AnyNumber());
+    EXPECT_CALL(mock_demuxer_host_, SetBufferedTime(_)).Times(AnyNumber());
+    EXPECT_CALL(mock_demuxer_host_, SetNetworkActivity(true))
+        .Times(AnyNumber());
     EXPECT_TRUE(demuxer_->AppendData(data, length));
   }
 
   void AppendDataInPieces(const uint8* data, size_t length) {
     AppendDataInPieces(data, length, 7);
   }
 
   void AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
     const uint8* start = data;
     const uint8* end = data + length;
@@ skipping 11 matching lines @@
     CreateInfoTracks(has_audio, has_video, &info_tracks, &info_tracks_size);
     AppendData(info_tracks.get(), info_tracks_size);
   }
 
   void InitDoneCalled(const base::TimeDelta& expected_duration,
                       PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
 
     if (status == PIPELINE_OK) {
-      EXPECT_CALL(mock_filter_host_, SetDuration(expected_duration));
-      EXPECT_CALL(mock_filter_host_, SetCurrentReadPosition(_));
+      EXPECT_CALL(mock_demuxer_host_, SetDuration(expected_duration));
+      EXPECT_CALL(mock_demuxer_host_, SetCurrentReadPosition(_));
 
-      demuxer_->set_host(&mock_filter_host_);
+      demuxer_->set_host(&mock_demuxer_host_);
     }
   }
 
   PipelineStatusCB CreateInitDoneCB(int duration,
                                     PipelineStatus expected_status) {
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
                       base::TimeDelta::FromMilliseconds(duration),
                       expected_status);
   }
@@ skipping 21 matching lines @@
   }
 
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64 timecode,
                       int size) {
     scoped_array<uint8> data(new uint8[size]);
     cb->AddSimpleBlock(track_num, timecode, 0, data.get(), size);
   }
 
   MOCK_METHOD1(Checkpoint, void(int id));
 
-  MockFilterHost mock_filter_host_;
+  MockDemuxerHost mock_demuxer_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.
@@ skipping 134 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> clusterB(cb.Finish());
 
   // Make sure that AppendData() fails because this cluster data
   // is before previous data.
-  EXPECT_CALL(mock_filter_host_, SetError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendData(clusterB->data(), clusterB->size());
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(45);
   AddSimpleBlock(&cb, kAudioTrackNum, 45);
   AddSimpleBlock(&cb, kVideoTrackNum, 45);
   scoped_ptr<Cluster> clusterC(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(clusterC->data(), clusterC->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestNonMonotonicButAboveClusterTimecode) {
   InitDemuxer(true, true);
 
   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> clusterA(cb.Finish());
 
-  EXPECT_CALL(mock_filter_host_, SetError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendData(clusterA->data(), clusterA->size());
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(20);
   AddSimpleBlock(&cb, kAudioTrackNum, 20);
   AddSimpleBlock(&cb, kVideoTrackNum, 20);
   scoped_ptr<Cluster> clusterB(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(clusterB->data(), clusterB->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestBackwardsAndBeforeClusterTimecode) {
   InitDemuxer(true, true);
 
   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> clusterA(cb.Finish());
 
-  EXPECT_CALL(mock_filter_host_, SetError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendData(clusterA->data(), clusterA->size());
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(6);
   AddSimpleBlock(&cb, kAudioTrackNum, 6);
   AddSimpleBlock(&cb, kVideoTrackNum, 6);
   scoped_ptr<Cluster> clusterB(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(clusterB->data(), clusterB->size()));
 }
 
 
 TEST_F(ChunkDemuxerTest, TestPerStreamMonotonicallyIncreasingTimestamps) {
   InitDemuxer(true, true);
 
   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_filter_host_, SetError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendData(cluster->data(), cluster->size());
 }
 
 TEST_F(ChunkDemuxerTest, TestMonotonicallyIncreasingTimestampsAcrossClusters) {
   InitDemuxer(true, true);
 
   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> clusterA(cb.Finish());
 
   AppendData(clusterA->data(), clusterA->size());
 
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   scoped_ptr<Cluster> clusterB(cb.Finish());
 
-  EXPECT_CALL(mock_filter_host_, SetError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendData(clusterB->data(), clusterB->size());
 
   // Verify that AppendData() doesn't accept more data now.
   cb.SetClusterTimecode(10);
   AddSimpleBlock(&cb, kAudioTrackNum, 10);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   scoped_ptr<Cluster> clusterC(cb.Finish());
   EXPECT_FALSE(demuxer_->AppendData(clusterC->data(), clusterC->size()));
 }
 
@@ skipping 23 matching lines @@
 
   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());
   AppendData(cluster->data(), cluster->size());
 
-  EXPECT_CALL(mock_filter_host_, SetError(PIPELINE_ERROR_DECODE));
+  EXPECT_CALL(mock_demuxer_host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   demuxer_->EndOfStream(PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(ChunkDemuxerTest, TestNetworkErrorEndOfStream) {
   InitDemuxer(true, true);
 
   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());
   AppendData(cluster->data(), cluster->size());
 
-  EXPECT_CALL(mock_filter_host_, SetError(PIPELINE_ERROR_NETWORK));
+  EXPECT_CALL(mock_demuxer_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 250 matching lines @@
                            base::TimeDelta::FromMilliseconds(
                                buffer_timestamps[i].video_time),
                            &video_read_done));
 
     EXPECT_TRUE(audio_read_done);
     EXPECT_TRUE(video_read_done);
   }
 }
 
 }  // namespace media