WIP fixing/extending acolwell's init-segment-received patch

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 121 matching lines @@
 }
 
 static void OnSeekDone_OKExpected(bool* called, PipelineStatus status) {
   EXPECT_EQ(status, PIPELINE_OK);
   *called = true;
 }
 
 static void LogFunc(const std::string& str) { DVLOG(1) << str; }
 
 class ChunkDemuxerTest : public ::testing::Test {
+ public:
+  MOCK_METHOD1(OnNewInitSegment, void(const InitSegment&));
+
  protected:
   enum CodecsIndex {
     AUDIO,
     VIDEO,
     MAX_CODECS_INDEX
   };
 
   // Default cluster to append first for simple tests.
   scoped_ptr<Cluster> kDefaultFirstCluster() {
     return GenerateCluster(0, 4);
@@ skipping 188 matching lines @@
 
     if (has_video) {
       codecs.push_back("vp8");
       type = "video/webm";
     }
 
     if (!has_audio && !has_video) {
       return AddId(kSourceId, HAS_AUDIO | HAS_VIDEO);
     }
 
-    return demuxer_->AddId(source_id, type, codecs);
+    return demuxer_->AddId(source_id, type, codecs,
+                           base::Bind(&ChunkDemuxerTest::OnNewInitSegment,
+                                      base::Unretained(this)));
   }
 
   ChunkDemuxer::Status AddIdForMp2tSource(const std::string& source_id) {
     std::vector<std::string> codecs;
     std::string type = "video/mp2t";
     codecs.push_back("mp4a.40.2");
     codecs.push_back("avc1.640028");
-    return demuxer_->AddId(source_id, type, codecs);
+    return demuxer_->AddId(source_id, type, codecs,
+                           base::Bind(&ChunkDemuxerTest::OnNewInitSegment,
+                                      base::Unretained(this)));
   }
 
   void AppendData(const uint8* data, size_t length) {
     AppendData(kSourceId, data, length);
   }
 
   void AppendCluster(const std::string& source_id,
                      scoped_ptr<Cluster> cluster) {
     AppendData(source_id, cluster->data(), cluster->size());
   }
@@ skipping 1582 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithAudioOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
                                DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vorbis";
-  ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs),
-            ChunkDemuxer::kOk);
+  ASSERT_EQ(ChunkDemuxer::kOk,
+            demuxer_->AddId(kSourceId, "audio/webm", codecs,
+                            base::Bind(&ChunkDemuxerTest::OnNewInitSegment,
+                                       base::Unretained(this))));
 
   AppendInitSegment(HAS_AUDIO | HAS_VIDEO);
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithVideoOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
                                DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
-  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
-            ChunkDemuxer::kOk);
+  ASSERT_EQ(ChunkDemuxer::kOk,
+            demuxer_->AddId(kSourceId, "video/webm", codecs,
+                            base::Bind(&ChunkDemuxerTest::OnNewInitSegment,
+                                       base::Unretained(this))));
 
   AppendInitSegment(HAS_AUDIO | HAS_VIDEO);
 }
 
 TEST_F(ChunkDemuxerTest, MultipleHeaders) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(kDefaultFirstCluster());
 
   // Append another identical initialization segment.
@@ skipping 534 matching lines @@
 TEST_F(ChunkDemuxerTest, CodecPrefixMatching) {
   ChunkDemuxer::Status expected = ChunkDemuxer::kNotSupported;
 
 #if defined(USE_PROPRIETARY_CODECS)
   expected = ChunkDemuxer::kOk;
 #endif
 
   std::vector<std::string> codecs;
   codecs.push_back("avc1.4D4041");
 
-  EXPECT_EQ(demuxer_->AddId("source_id", "video/mp4", codecs), expected);
+  EXPECT_EQ(expected,
+            demuxer_->AddId("source_id", "video/mp4", codecs,
+                            base::Bind(&ChunkDemuxerTest::OnNewInitSegment,
+                                       base::Unretained(this))));
 }
 
 // Test codec ID's that are not compliant with RFC6381, but have been
 // seen in the wild.
 TEST_F(ChunkDemuxerTest, CodecIDsThatAreNotRFC6381Compliant) {
   ChunkDemuxer::Status expected = ChunkDemuxer::kNotSupported;
 
 #if defined(USE_PROPRIETARY_CODECS)
   expected = ChunkDemuxer::kOk;
 #endif
   const char* codec_ids[] = {
     // GPAC places leading zeros on the audio object type.
     "mp4a.40.02",
     "mp4a.40.05"
   };
 
   for (size_t i = 0; i < arraysize(codec_ids); ++i) {
     std::vector<std::string> codecs;
     codecs.push_back(codec_ids[i]);
 
     ChunkDemuxer::Status result =
-        demuxer_->AddId("source_id", "audio/mp4", codecs);
+        demuxer_->AddId("source_id", "audio/mp4", codecs,
+                        base::Bind(&ChunkDemuxerTest::OnNewInitSegment,
+                                   base::Unretained(this)));
 
     EXPECT_EQ(result, expected)
         << "Fail to add codec_id '" << codec_ids[i] << "'";
 
     if (result == ChunkDemuxer::kOk)
       demuxer_->RemoveId("source_id");
   }
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamStillSetAfterSeek) {
@@ skipping 911 matching lines @@
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4));
   AppendData(kCuesHeader, sizeof(kCuesHeader));
   AppendCluster(GenerateCluster(46, 66, 5));
   CheckExpectedRanges(kSourceId, "{ [0,115) }");
 }
 
 }  // namespace media