Move ChunkDemuxer handling from WMPProxy to WMPI and remove ChunkDemuxerClient

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 "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.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"
-#include "media/filters/chunk_demuxer_client.h"
 #include "media/webm/cluster_builder.h"
 #include "media/webm/webm_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
@@ skipping 71 matching lines @@
 }
 
 static void OnReadDone_EOSExpected(bool* called,
                                    DemuxerStream::Status status,
                                    const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(status, DemuxerStream::kOk);
   EXPECT_TRUE(buffer->IsEndOfStream());
   *called = true;
 }
 
-class MockChunkDemuxerClient : public ChunkDemuxerClient {
- public:
-  MockChunkDemuxerClient() {}
-  virtual ~MockChunkDemuxerClient() {}
-
-  MOCK_METHOD1(DemuxerOpened, void(ChunkDemuxer* demuxer));
-  MOCK_METHOD0(DemuxerClosed, void());
-  // TODO(xhwang): This is a workaround of the issue that move-only parameters
-  // are not supported in mocked methods. Remove this when the issue is fixed
-  // (http://code.google.com/p/googletest/issues/detail?id=395) or when we use
-  // std::string instead of scoped_array<uint8> (http://crbug.com/130689).
-  MOCK_METHOD2(NeedKeyMock, void(const uint8* init_data, int init_data_size));
-  void DemuxerNeedKey(scoped_array<uint8> init_data, int init_data_size) {
-    NeedKeyMock(init_data.get(), init_data_size);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockChunkDemuxerClient);
-};
-
 class ChunkDemuxerTest : public testing::Test {
  protected:
   enum CodecsIndex {
     AUDIO,
     VIDEO,
     MAX_CODECS_INDEX
   };
 
   // Default cluster to append first for simple tests.
   scoped_ptr<Cluster> kDefaultFirstCluster() {
     return GenerateCluster(0, 4);
   }
 
   // Default cluster to append after kDefaultFirstCluster()
   // has been appended. This cluster starts with blocks that
   // have timestamps consistent with the end times of the blocks
   // in kDefaultFirstCluster() so that these two clusters represent
   // a continuous region.
   scoped_ptr<Cluster> kDefaultSecondCluster() {
     return GenerateCluster(46, 66, 5);
   }
 
-  ChunkDemuxerTest()
-      : client_(new MockChunkDemuxerClient()),
-        demuxer_(new ChunkDemuxer(client_.get())) {
+  ChunkDemuxerTest() {
+    CreateNewDemuxer();
+  }
+
+  void CreateNewDemuxer() {
+    base::Closure open_cb =
+        base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
+    ChunkDemuxer::NeedKeyCB need_key_cb =
+        base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this));
+    demuxer_ = new ChunkDemuxer(open_cb, need_key_cb);
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(bool has_audio, bool has_video,
                          bool video_content_encoded,
                          scoped_array<uint8>* buffer,
                          int* size) {
@@ skipping 166 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;
 
     base::TimeDelta expected_duration = kNoTimestamp();
     if (expected_status == PIPELINE_OK)
       expected_duration = kDefaultDuration();
 
-    EXPECT_CALL(*client_, DemuxerOpened(_));
+    EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(expected_duration, expected_status));
 
     if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     return AppendInitSegment(has_audio, has_video, video_content_encoded);
   }
 
   bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
                                        const std::string& video_id) {
-    EXPECT_CALL(*client_, DemuxerOpened(_));
+    EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
     if (AddId(audio_id, true, false) != ChunkDemuxer::kOk)
       return false;
     if (AddId(video_id, false, true) != ChunkDemuxer::kOk)
       return false;
 
     bool success = AppendInitSegment(audio_id, true, false, false);
     success &= AppendInitSegment(video_id, false, true, false);
@@ skipping 14 matching lines @@
   // bear-320x240.webm AudioDecoderConfig returns 3863 for its extra_data_size()
   // bear-640x360.webm AudioDecoderConfig returns 3935 for its extra_data_size()
   // The resulting audio stream returns data from each file for the following
   // time ranges.
   // bear-320x240.webm : [0-524)       [779-2737)
   // bear-640x360.webm :       [527-759)
   bool InitDemuxerWithConfigChangeData() {
     scoped_refptr<DecoderBuffer> bear1 = ReadTestDataFile("bear-320x240.webm");
     scoped_refptr<DecoderBuffer> bear2 = ReadTestDataFile("bear-640x360.webm");
 
-    EXPECT_CALL(*client_, DemuxerOpened(_));
+    EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744),
                                  PIPELINE_OK));
 
     if (AddId(kSourceId, true, true) != ChunkDemuxer::kOk)
       return false;
 
     // Append the whole bear1 file.
     if (!AppendData(bear1->GetData(), bear1->GetDataSize()))
       return false;
@@ skipping 18 matching lines @@
     if (!AppendData(bear1->GetData(), 4370) ||
         !AppendData(bear1->GetData() + 72737, 28183)) {
       return false;
     }
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     return demuxer_->EndOfStream(PIPELINE_OK);
   }
 
   void ShutdownDemuxer() {
-    if (demuxer_) {
-      EXPECT_CALL(*client_, DemuxerClosed());
+    if (demuxer_)
       demuxer_->Shutdown();
-    }
   }
 
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64 timecode) {
     uint8 data[] = { 0x00 };
     cb->AddSimpleBlock(track_num, timecode, 0, data, sizeof(data));
   }
 
   scoped_ptr<Cluster> GenerateCluster(int timecode, int block_count) {
     return GenerateCluster(timecode, timecode, block_count);
   }
@@ skipping 186 matching lines @@
   bool ParseWebMFile(const std::string& filename,
                      const BufferTimestamps* timestamps,
                      const base::TimeDelta& duration) {
     return ParseWebMFile(filename, timestamps, duration, true, true);
   }
 
   bool ParseWebMFile(const std::string& filename,
                      const BufferTimestamps* timestamps,
                      const base::TimeDelta& duration,
                      bool has_audio, bool has_video) {
-    EXPECT_CALL(*client_, DemuxerOpened(_));
+    EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(duration, PIPELINE_OK));
 
     if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     // Read a WebM file into memory and send the data to the demuxer.
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     if (!AppendDataInPieces(buffer->GetData(), buffer->GetDataSize(), 512))
       return false;
@@ skipping 28 matching lines @@
                                    timestamps[i].video_time_ms),
                                &video_read_done));
 
         EXPECT_TRUE(video_read_done);
       }
     }
 
     return true;
   }
 
+  MOCK_METHOD0(DemuxerOpened, void());
+  // TODO(xhwang): This is a workaround of the issue that move-only parameters
+  // are not supported in mocked methods. Remove this when the issue is fixed
+  // (http://code.google.com/p/googletest/issues/detail?id=395) or when we use
+  // std::string instead of scoped_array<uint8> (http://crbug.com/130689).
+  MOCK_METHOD2(NeedKeyMock, void(const uint8* init_data, int init_data_size));
+  void DemuxerNeedKey(scoped_array<uint8> init_data, int init_data_size) {
+    NeedKeyMock(init_data.get(), init_data_size);
+  }
+
   MessageLoop message_loop_;
   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());
+    CreateNewDemuxer();
     if (has_video && video_content_encoded)
-      EXPECT_CALL(*client_, NeedKeyMock(NotNull(), 16));
+      EXPECT_CALL(*this, NeedKeyMock(NotNull(), 16));
 
     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());
@@ skipping 15 matching lines @@
     }
 
     ShutdownDemuxer();
     demuxer_ = NULL;
   }
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, TestShutdownBeforeAllInitSegmentsAppended) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
 
   EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
 
   EXPECT_TRUE(AppendInitSegment("audio", true, false, false));
 }
 
@@ skipping 200 matching lines @@
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   scoped_ptr<Cluster> cluster(cb.Finish());
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
 // Test the case where a cluster is passed to AppendData() before
 // INFO & TRACKS data.
 TEST_F(ChunkDemuxerTest, TestClusterBeforeInitSegment) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 1));
 
   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(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithNoAppend) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   CheckExpectedRanges("{ }");
   demuxer_->EndOfStream(PIPELINE_OK);
   ShutdownDemuxer();
   CheckExpectedRanges("{ }");
   demuxer_->RemoveId(kSourceId);
@@ skipping 168 matching lines @@
   end_of_stream_helper_2.RequestReads();
   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(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
   CreateInitSegment(true, true, false, &info_tracks, &info_tracks_size);
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
@@ skipping 156 matching lines @@
 
   // Append the remaining data.
   ASSERT_LT(i, cluster->size());
   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(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kNoTimestamp(), DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   uint8 tmp = 0;
   ASSERT_TRUE(demuxer_->AppendData(kSourceId, &tmp, 1));
 }
 
 TEST_F(ChunkDemuxerTest, TestAVHeadersWithAudioOnlyType) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
                                DEMUXER_ERROR_COULD_NOT_OPEN));
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vorbis";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs),
             ChunkDemuxer::kOk);
 
   ASSERT_TRUE(AppendInitSegment(true, true, false));
 }
 
 TEST_F(ChunkDemuxerTest, TestAVHeadersWithVideoOnlyType) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
                                DEMUXER_ERROR_COULD_NOT_OPEN));
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
 
   ASSERT_TRUE(AppendInitSegment(true, true, false));
@@ skipping 36 matching lines @@
       GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
 
   // Append audio and video data into separate source ids.
   ASSERT_TRUE(AppendData(audio_id, cluster_a->data(), cluster_a->size()));
   GenerateSingleStreamExpectedReads(0, 4, audio, kAudioBlockDuration);
   ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size()));
   GenerateSingleStreamExpectedReads(0, 4, video, kVideoBlockDuration);
 }
 
 TEST_F(ChunkDemuxerTest, TestAddIdFailures) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   std::string audio_id = "audio1";
   std::string video_id = "video1";
 
   ASSERT_EQ(AddId(audio_id, true, false), ChunkDemuxer::kOk);
 
   // Adding an id with audio/video should fail because we already added audio.
   ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit);
@@ skipping 174 matching lines @@
   ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size()));
   ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size()));
 
   // Read() should return buffers at 3.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 // Test ranges in an audio-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(kSourceId, true, false), ChunkDemuxer::kOk);
   ASSERT_TRUE(AppendInitSegment(true, false, false));
 
   // Test a simple cluster.
   scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 92,
                                 kAudioTrackNum, kAudioBlockDuration));
   ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size()));
 
   CheckExpectedRanges("{ [0,92) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(150, 219,
                                 kAudioTrackNum, kAudioBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size()));
 
   CheckExpectedRanges("{ [0,92) [150,219) }");
 }
 
 // Test ranges in a video-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(kSourceId, false, true), ChunkDemuxer::kOk);
   ASSERT_TRUE(AppendInitSegment(false, true, false));
 
   // Test a simple cluster.
   scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 132,
                                 kVideoTrackNum, kVideoBlockDuration));
 
@@ skipping 283 matching lines @@
   // Append the missing range and verify that EndOfStream() succeeds now.
   ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size()));
 
   CheckExpectedRanges(audio_id, "{ [0,35) }");
   CheckExpectedRanges(video_id, "{ [0,50) }");
 
   ASSERT_TRUE(demuxer_->EndOfStream(PIPELINE_OK));
 }
 
 TEST_F(ChunkDemuxerTest, TestGetBufferedRangesBeforeInitSegment) {
-  EXPECT_CALL(*client_, DemuxerOpened(_));
+  EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(&host_, CreateInitDoneCB(PIPELINE_OK));
   ASSERT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
   ASSERT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
 
   CheckExpectedRanges("audio", "{ }");
   CheckExpectedRanges("video", "{ }");
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
@@ skipping 352 matching lines @@
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp)));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 }  // namespace media