Implement sourceAddId() & sourceRemoveId()

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 20 matching lines @@
 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at
 // index 1 and spans 8 bytes.
 static const int kVideoTrackSizeOffset = 1;
 static const int kVideoTrackSizeWidth = 8;
 static const int kVideoTrackEntryHeaderSize = kVideoTrackSizeOffset +
                                               kVideoTrackSizeWidth;
 
 static const int kVideoTrackNum = 1;
 static const int kAudioTrackNum = 2;
 
+static const char* kSourceId = "SourceId";
+static const char* kDefaultSourceType = "video/webm; codecs=\"vp8, vorbis\"";
+
+
 base::TimeDelta kDefaultDuration() {
   return base::TimeDelta::FromMilliseconds(201224);
 }
 
 // Write an integer into buffer in the form of vint that spans 8 bytes.
 // The data pointed by |buffer| should be at least 8 bytes long.
 // |number| should be in the range 0 <= number < 0x00FFFFFFFFFFFFFF.
 static void WriteInt64(uint8* buffer, int64 number) {
   DCHECK(number >= 0 && number < GG_LONGLONG(0x00FFFFFFFFFFFFFF));
   buffer[0] = 0x01;
@@ skipping 106 matching lines @@
       }
       buf += video_track_entry_size;
     }
   }
 
   bool AppendData(const uint8* data, size_t length) {
     EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
     EXPECT_CALL(host_, SetBufferedTime(_)).Times(AnyNumber());
     EXPECT_CALL(host_, SetNetworkActivity(true))
         .Times(AnyNumber());
-    return demuxer_->AppendData(data, length);
+    return demuxer_->AppendData(kSourceId, 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;
     const uint8* end = data + length;
     while (start < end) {
@@ skipping 34 matching lines @@
 
   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(
         &host_, CreateInitDoneCB(kDefaultDuration(), expected_status));
 
+    DCHECK_EQ(demuxer_->AddId(kSourceId, kDefaultSourceType),
+              ChunkDemuxer::kOk);
+
     return AppendInfoTracks(has_audio, has_video, video_content_encoded);
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       EXPECT_CALL(*client_, DemuxerClosed());
       demuxer_->Shutdown();
     }
   }
 
@@ skipping 33 matching lines @@
   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(
         &host_, CreateInitDoneCB(duration, PIPELINE_OK));
 
+    DCHECK_EQ(demuxer_->AddId(kSourceId, kDefaultSourceType),
+              ChunkDemuxer::kOk);
+
     // 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 168 matching lines @@
   ExpectRead(audio, 5007);
   ExpectRead(video, 5035);
 }
 
 // Test the case where AppendData() is called before Init().
 TEST_F(ChunkDemuxerTest, TestAppendDataBeforeInit) {
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
   CreateInfoTracks(true, true, false, &info_tracks, &info_tracks_size);
 
-  EXPECT_FALSE(demuxer_->AppendData(info_tracks.get(), info_tracks_size));
+  EXPECT_FALSE(demuxer_->AppendData(kSourceId, info_tracks.get(),
+                                    info_tracks_size));
 }
 
 // Make sure Read() callbacks are dispatched with the proper data.
 TEST_F(ChunkDemuxerTest, TestRead) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
@@ skipping 46 matching lines @@
   // Make sure that AppendData() fails because this cluster data
   // is before previous data.
   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()));
+  EXPECT_FALSE(demuxer_->AppendData(kSourceId, 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(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()));
+  EXPECT_FALSE(demuxer_->AppendData(kSourceId, 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(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()));
+  EXPECT_FALSE(demuxer_->AppendData(kSourceId, 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.
@@ skipping 28 matching lines @@
   scoped_ptr<Cluster> cluster_b(cb.Finish());
 
   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()));
+  EXPECT_FALSE(demuxer_->AppendData(kSourceId, 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(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
+  DCHECK_EQ(demuxer_->AddId(kSourceId, kDefaultSourceType), ChunkDemuxer::kOk);
+
   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) {
@@ skipping 179 matching lines @@
   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(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
+  DCHECK_EQ(demuxer_->AddId(kSourceId, kDefaultSourceType), ChunkDemuxer::kOk);
+
   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 178 matching lines @@
   EXPECT_TRUE(video_read_done);
 }
 
 
 TEST_F(ChunkDemuxerTest, TestParseErrorDuringInit) {
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
 
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+
+  DCHECK_EQ(demuxer_->AddId(kSourceId, kDefaultSourceType), ChunkDemuxer::kOk);
+
   ASSERT_TRUE(AppendInfoTracks(true, true, false));
 
   uint8 tmp = 0;
-  ASSERT_TRUE(demuxer_->AppendData(&tmp, 1));
+  ASSERT_TRUE(demuxer_->AppendData(kSourceId, &tmp, 1));
 }
 
 }  // namespace media