Move ChunkDemuxer handling from WMPProxy to WMPI and remove ChunkDemuxerClient

media/filters/pipeline_integration_test.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 "media/filters/pipeline_integration_test_base.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
 #include "media/base/test_data_util.h"
 #include "media/crypto/aes_decryptor.h"
-#include "media/filters/chunk_demuxer_client.h"
 
 namespace media {
 
 static const char kSourceId[] = "SourceId";
 static const char kClearKeySystem[] = "org.w3.clearkey";
 static const uint8 kInitData[] = { 0x69, 0x6e, 0x69, 0x74 };
 
 static const char kWebM[] = "video/webm; codecs=\"vp8,vorbis\"";
 static const char kAudioOnlyWebM[] = "video/webm; codecs=\"vorbis\"";
 static const char kVideoOnlyWebM[] = "video/webm; codecs=\"vp8\"";
 static const char kMP4[] = "video/mp4; codecs=\"avc1.4D4041,mp4a.40.2\"";
 
 // Key used to encrypt video track in test file "bear-320x240-encrypted.webm".
 static const uint8 kSecretKey[] = {
   0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
   0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c
 };
 
 static const int kAppendWholeFile = -1;
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
-class MockMediaSource : public ChunkDemuxerClient {
+class MockMediaSource {
  public:
   MockMediaSource(const std::string& filename, const std::string& mimetype,
                   int initial_append_size)
       : url_(GetTestDataURL(filename)),
         current_position_(0),
         initial_append_size_(initial_append_size),
         mimetype_(mimetype) {
+    chunk_demuxer_ = new ChunkDemuxer(
+        base::Bind(&MockMediaSource::DemuxerOpened, base::Unretained(this)),
+        base::Bind(&MockMediaSource::DemuxerNeedKey, base::Unretained(this)));
+
     file_data_ = ReadTestDataFile(filename);
 
     if (initial_append_size_ == kAppendWholeFile)
       initial_append_size_ = file_data_->GetDataSize();
 
     DCHECK_GT(initial_append_size_, 0);
     DCHECK_LE(initial_append_size_, file_data_->GetDataSize());
   }
 
   virtual ~MockMediaSource() {}
 
+  const scoped_refptr<ChunkDemuxer>& demuxer() const { return chunk_demuxer_; }
   void set_decryptor_client(DecryptorClient* decryptor_client) {
     decryptor_client_ = decryptor_client;
   }
 
   void Seek(int new_position, int seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek();
 
     chunk_demuxer_->Abort(kSourceId);
 
     DCHECK_GE(new_position, 0);
@@ skipping 20 matching lines @@
   }
 
   void EndOfStream() {
     chunk_demuxer_->EndOfStream(PIPELINE_OK);
   }
 
   void Abort() {
     if (!chunk_demuxer_.get())
       return;
     chunk_demuxer_->Shutdown();
+    chunk_demuxer_ = NULL;
   }
 
-  // ChunkDemuxerClient methods.
-  virtual void DemuxerOpened(ChunkDemuxer* demuxer) {
-    chunk_demuxer_ = demuxer;
+  void DemuxerOpened() {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&MockMediaSource::DemuxerOpenedTask,
+                              base::Unretained(this)));
+  }
 
+  void DemuxerOpenedTask() {
     size_t semicolon = mimetype_.find(";");
     std::string type = mimetype_.substr(0, semicolon);
     size_t quote1 = mimetype_.find("\"");
     size_t quote2 = mimetype_.find("\"", quote1 + 1);
     std::string codecStr = mimetype_.substr(quote1 + 1, quote2 - quote1 - 1);
     std::vector<std::string> codecs;
     Tokenize(codecStr, ",", &codecs);
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
     AppendData(initial_append_size_);
   }
 
-  virtual void DemuxerClosed() {
-    chunk_demuxer_ = NULL;
-  }
-
-  virtual void DemuxerNeedKey(scoped_array<uint8> init_data,
-                              int init_data_size) {
+  void DemuxerNeedKey(scoped_array<uint8> init_data, int init_data_size) {
     DCHECK(init_data.get());
     DCHECK_GT(init_data_size, 0);
     DCHECK(decryptor_client_);
     decryptor_client_->NeedKey("", "", init_data.Pass(), init_data_size);
   }
 
  private:
   std::string url_;
   scoped_refptr<DecoderBuffer> file_data_;
   int current_position_;
@@ skipping 68 matching lines @@
 };
 
 class PipelineIntegrationTest
     : public testing::Test,
       public PipelineIntegrationTestBase {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kHaveMetadata));
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kPrerollCompleted));
     pipeline_->Start(
-        CreateFilterCollection(source, NULL),
+        CreateFilterCollection(source->demuxer(), NULL),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK),
         base::Bind(&PipelineIntegrationTest::OnBufferingState,
                    base::Unretained(this)));
 
     message_loop_.Run();
   }
 
   void StartPipelineWithEncryptedMedia(
       MockMediaSource* source,
       FakeDecryptorClient* encrypted_media) {
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kHaveMetadata));
     EXPECT_CALL(*this, OnBufferingState(Pipeline::kPrerollCompleted));
     pipeline_->Start(
-        CreateFilterCollection(source, encrypted_media->decryptor()),
+        CreateFilterCollection(source->demuxer(), encrypted_media->decryptor()),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK),
         base::Bind(&PipelineIntegrationTest::OnBufferingState,
                    base::Unretained(this)));
 
     source->set_decryptor_client(encrypted_media);
 
     message_loop_.Run();
   }
@@ skipping 196 matching lines @@
 // Verify video decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", kVideoOnlyWebM,
                                  32768,
                                  base::TimeDelta::FromMilliseconds(200),
                                  base::TimeDelta::FromMilliseconds(1668),
                                  0x1C896, 65536));
 }
 
 }  // namespace media