Send the h264 SPS and PPS configuration parameters to AVDA

media/base/android/sdk_media_codec_bridge_unittest.cc

 // Copyright 2015 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/base/android/sdk_media_codec_bridge.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 135 matching lines @@
     input_pts += base::TimeDelta::FromMicroseconds(33000);
     timestamp = new_timestamp;
   }
 }
 
 TEST(SdkMediaCodecBridgeTest, Initialize) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   std::unique_ptr<media::MediaCodecBridge> media_codec;
   media_codec.reset(VideoCodecBridge::CreateDecoder(
-      kCodecH264, false, gfx::Size(640, 480), nullptr, nullptr));
+      kCodecH264, false, gfx::Size(640, 480), nullptr, nullptr,
+      std::vector<uint8_t>(), std::vector<uint8_t>()));
 }
 
 TEST(SdkMediaCodecBridgeTest, DoNormal) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   std::unique_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecMP3));
 
   ASSERT_TRUE(media_codec->ConfigureAndStart(kCodecMP3, 44100, 2, nullptr, 0, 0,
                                              0, nullptr));
@@ skipping 100 matching lines @@
   // Seek Preroll is < 0.
   EXPECT_FALSE(
       media_codec->ConfigureAndStart(kCodecOpus, 48000, 2, dummy_extra_data,
                                      sizeof(dummy_extra_data), 0, -1, nullptr));
 }
 
 TEST(SdkMediaCodecBridgeTest, PresentationTimestampsDoNotDecrease) {
   SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   std::unique_ptr<VideoCodecBridge> media_codec(VideoCodecBridge::CreateDecoder(
-      kCodecVP8, false, gfx::Size(320, 240), nullptr, nullptr));
+      kCodecVP8, false, gfx::Size(320, 240), nullptr, nullptr,
+      std::vector<uint8_t>(), std::vector<uint8_t>()));
   EXPECT_TRUE(media_codec.get());
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vp8-I-frame-320x240");
   DecodeMediaFrame(media_codec.get(), buffer->data(), buffer->data_size(),
                    base::TimeDelta(), base::TimeDelta());
 
   // Simulate a seek to 10 seconds, and each chunk has 2 I-frames.
   std::vector<uint8_t> chunk(buffer->data(),
                              buffer->data() + buffer->data_size());
   chunk.insert(chunk.end(), buffer->data(),
                buffer->data() + buffer->data_size());
   media_codec->Flush();
   DecodeMediaFrame(media_codec.get(), &chunk[0], chunk.size(),
                    base::TimeDelta::FromMicroseconds(10000000),
                    base::TimeDelta::FromMicroseconds(9900000));
 
   // Simulate a seek to 5 seconds.
   media_codec->Flush();
   DecodeMediaFrame(media_codec.get(), &chunk[0], chunk.size(),
                    base::TimeDelta::FromMicroseconds(5000000),
                    base::TimeDelta::FromMicroseconds(4900000));
 }
 
 TEST(SdkMediaCodecBridgeTest, CreateUnsupportedCodec) {
   EXPECT_EQ(nullptr, AudioCodecBridge::Create(kUnknownAudioCodec));
-  EXPECT_EQ(nullptr, VideoCodecBridge::CreateDecoder(kUnknownVideoCodec, false,
-                                                     gfx::Size(320, 240),
-                                                     nullptr, nullptr));
+  EXPECT_EQ(nullptr,
+            VideoCodecBridge::CreateDecoder(
+                kUnknownVideoCodec, false, gfx::Size(320, 240), nullptr,
+                nullptr, std::vector<uint8_t>(), std::vector<uint8_t>()));
 }
 
 }  // namespace media