Implemented passing media track info from ffmpeg into blink

media/test/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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_keys.h"
 #include "media/base/media_switches.h"
+#include "media/base/media_tracks.h"
 #include "media/base/test_data_util.h"
 #include "media/base/timestamp_constants.h"
 #include "media/cdm/aes_decryptor.h"
 #include "media/cdm/json_web_key.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/renderers/renderer_impl.h"
 #include "media/test/pipeline_integration_test_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 
@@ skipping 493 matching lines @@
     chunk_demuxer_->StartWaitingForSeek(seek_time);
   }
 
   void AppendData(size_t size) {
     DCHECK(chunk_demuxer_);
     DCHECK_LT(current_position_, file_data_->data_size());
     DCHECK_LE(current_position_ + size, file_data_->data_size());
 
     chunk_demuxer_->AppendData(
         kSourceId, file_data_->data() + current_position_, size,
-        base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_,
-        base::Bind(&MockMediaSource::InitSegmentReceived,
-                   base::Unretained(this)));
+        base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_);
     current_position_ += size;
   }
 
   void AppendAtTime(base::TimeDelta timestamp_offset,
                     const uint8_t* pData,
                     int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
     chunk_demuxer_->AppendData(kSourceId, pData, size, base::TimeDelta(),
-                               kInfiniteDuration(), &timestamp_offset,
-                               base::Bind(&MockMediaSource::InitSegmentReceived,
-                                          base::Unretained(this)));
+                               kInfiniteDuration(), &timestamp_offset);
     last_timestamp_offset_ = timestamp_offset;
   }
 
   void AppendAtTimeWithWindow(base::TimeDelta timestamp_offset,
                               base::TimeDelta append_window_start,
                               base::TimeDelta append_window_end,
                               const uint8_t* pData,
                               int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
     chunk_demuxer_->AppendData(kSourceId, pData, size, append_window_start,
-                               append_window_end, &timestamp_offset,
-                               base::Bind(&MockMediaSource::InitSegmentReceived,
-                                          base::Unretained(this)));
+                               append_window_end, &timestamp_offset);
     last_timestamp_offset_ = timestamp_offset;
   }
 
   void SetMemoryLimits(size_t limit_bytes) {
     chunk_demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, limit_bytes);
     chunk_demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, limit_bytes);
   }
 
   void EvictCodedFrames(base::TimeDelta currentMediaTime, size_t newDataSize) {
     chunk_demuxer_->EvictCodedFrames(kSourceId, currentMediaTime, newDataSize);
@@ skipping 40 matching lines @@
 
       CHECK_NE(codecs_param_end, std::string::npos);
 
       std::string codecs_param = mimetype_.substr(
           codecs_param_start, codecs_param_end - codecs_param_start);
       codecs = base::SplitString(codecs_param, ",", base::KEEP_WHITESPACE,
                                  base::SPLIT_WANT_NONEMPTY);
     }
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
+    chunk_demuxer_->SetTracksWatcher(
+        kSourceId, base::Bind(&MockMediaSource::InitSegmentReceivedWrapper,
+                              base::Unretained(this)));
 
     AppendData(initial_append_size_);
   }
 
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data) {
     DCHECK(!init_data.empty());
     CHECK(!encrypted_media_init_data_cb_.is_null());
     encrypted_media_init_data_cb_.Run(init_data_type, init_data);
   }
 
   base::TimeDelta last_timestamp_offset() const {
     return last_timestamp_offset_;
   }
 
-  MOCK_METHOD0(InitSegmentReceived, void(void));
+  // A workaround for gtest mocks not allowing moving scoped_ptrs.
+  void InitSegmentReceivedWrapper(scoped_ptr<MediaTracks> tracks) {
+    InitSegmentReceived(tracks);
+  }
+
+  MOCK_METHOD1(InitSegmentReceived, void(scoped_ptr<MediaTracks>&));
 
  private:
   scoped_refptr<DecoderBuffer> file_data_;
   size_t current_position_;
   size_t initial_append_size_;
   std::string mimetype_;
   ChunkDemuxer* chunk_demuxer_;
   scoped_ptr<Demuxer> owned_chunk_demuxer_;
   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
   base::TimeDelta last_timestamp_offset_;
@@ skipping 25 matching lines @@
   interfaces::ServiceFactoryPtr media_service_factory_;
 };
 #else
 class PipelineIntegrationTestHost : public testing::Test,
                                     public PipelineIntegrationTestBase {};
 #endif  // defined(MOJO_RENDERER)
 
 class PipelineIntegrationTest : public PipelineIntegrationTestHost {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
-    EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
+    EXPECT_CALL(*source, InitSegmentReceived(_)).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
 
     // Encrypted content not used, so this is never called.
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
@@ skipping 23 matching lines @@
   }
 
   void StartHashedClocklessPipelineWithMediaSource(MockMediaSource* source) {
     hashing_enabled_ = true;
     clockless_playback_ = true;
     StartPipelineWithMediaSource(source);
   }
 
   void StartPipelineWithEncryptedMedia(MockMediaSource* source,
                                        FakeEncryptedMedia* encrypted_media) {
-    EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
+    EXPECT_CALL(*source, InitSegmentReceived(_)).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
     EXPECT_CALL(*this, DecryptorAttached(true));
 
     // Encrypted content used but keys provided in advance, so this is
@@ skipping 1280 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media