Fix some MSE tests on devices that don't support VP9

media/base/android/media_source_player_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 267 matching lines @@
     EXPECT_EQ(audio_codec, kCodecAAC);
 
     configs.audio_sampling_rate = 48000;
     uint8 aac_extra_data[] = { 0x13, 0x10 };
     configs.audio_extra_data = std::vector<uint8>(
         aac_extra_data,
         aac_extra_data + 2);
     return configs;
   }
 
-  DemuxerConfigs CreateVideoDemuxerConfigs(VideoCodec video_codec) {
+  DemuxerConfigs CreateVideoDemuxerConfigs(bool use_larger_size) {
     DemuxerConfigs configs;
-    configs.video_codec = video_codec;
-    configs.video_size = gfx::Size(320, 240);
+    configs.video_codec = kCodecVP8;
+    configs.video_size =
+        use_larger_size ? gfx::Size(640, 480) : gfx::Size(320, 240);
     configs.is_video_encrypted = false;
     configs.duration = kDefaultDuration;
     return configs;
   }
 
   DemuxerConfigs CreateAudioVideoDemuxerConfigs() {
     DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, false);
     configs.video_codec = kCodecVP8;
     configs.video_size = gfx::Size(320, 240);
     configs.is_video_encrypted = false;
     return configs;
   }
 
   DemuxerConfigs CreateDemuxerConfigs(bool have_audio, bool have_video) {
     DCHECK(have_audio || have_video);
 
     if (have_audio && !have_video)
       return CreateAudioDemuxerConfigs(kCodecVorbis, false);
 
     if (have_video && !have_audio)
-      return CreateVideoDemuxerConfigs(kCodecVP8);
+      return CreateVideoDemuxerConfigs(false);
 
     return CreateAudioVideoDemuxerConfigs();
   }
 
   // Starts an audio decoder job.
   void StartAudioDecoderJob() {
     Start(CreateAudioDemuxerConfigs(kCodecVorbis, false));
   }
 
   // Starts a video decoder job.
   void StartVideoDecoderJob() {
-    Start(CreateVideoDemuxerConfigs(kCodecVP8));
+    Start(CreateVideoDemuxerConfigs(false));
   }
 
   // Starts decoding the data.
   void Start(const DemuxerConfigs& configs) {
     EXPECT_EQ(demuxer_->num_data_requests(), 0);
     player_.OnDemuxerConfigsAvailable(configs);
     player_.Start();
 
     EXPECT_TRUE(player_.IsPlaying());
     int expected_num_requests = (player_.HasAudio() ? 1 : 0) +
@@ skipping 302 matching lines @@
 
       WaitForDecodeDone(is_audio, !is_audio);
 
       // We should have completed the prefetch phase at this point.
       expected_num_data_requests++;
       EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
     }
 
     DemuxerConfigs configs = is_audio ?
         CreateAudioDemuxerConfigs(kCodecAAC, false) :
-        CreateVideoDemuxerConfigs(kCodecVP9);
+        CreateVideoDemuxerConfigs(true);
     // Feed and decode access units with data for any units prior to
     // |config_unit_index|, and a |kConfigChanged| unit at that index.
     // Player should prepare to reconfigure the decoder job, and should request
     // new demuxer configs.
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
         is_audio, config_unit_index, configs));
 
     expected_num_data_requests++;
     EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
     if (is_audio)
@@ skipping 251 matching lines @@
   // Test decoder job will resend a ReadFromDemuxer request after seek.
   StartAudioDecoderJob();
   SeekPlayerWithAbort(true, base::TimeDelta());
 }
 
 TEST_F(MediaSourcePlayerTest, SetSurfaceWhileSeeking) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test SetVideoSurface() will not cause an extra seek while the player is
   // waiting for demuxer to indicate seek is done.
-  player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs(kCodecVP8));
+  player_.OnDemuxerConfigsAvailable(
+      CreateVideoDemuxerConfigs(false));
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   CreateNextTextureAndSetVideoSurface();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   player_.Start();
 
@@ skipping 136 matching lines @@
   // Decoder is created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_TRUE(GetMediaCodecBridge(true));
 }
 
 TEST_F(MediaSourcePlayerTest, VideoOnlyStartAfterSeekFinish) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test video decoder job will not start until pending seek event is handled.
   CreateNextTextureAndSetVideoSurface();
-  DemuxerConfigs configs = CreateVideoDemuxerConfigs(kCodecVP8);
+  DemuxerConfigs configs = CreateVideoDemuxerConfigs(false);
   player_.OnDemuxerConfigsAvailable(configs);
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   player_.Start();
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
@@ skipping 148 matching lines @@
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that if one stream (audio) has completed decode of EOS and the other
   // stream (video) processes config change, that subsequent video EOS completes
   // A/V playback.
   // Also tests that seeking+Start() after completing playback resumes playback.
   CreateNextTextureAndSetVideoSurface();
   Start(CreateAudioVideoDemuxerConfigs());
 
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
-  DemuxerConfigs configs = CreateVideoDemuxerConfigs(kCodecVP9);
+  DemuxerConfigs configs = CreateVideoDemuxerConfigs(true);
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
       false, 0, configs));  // Video |kConfigChanged| as first unit.
 
   WaitForAudioVideoDecodeDone();
 
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // At no time after completing audio EOS decode, above, should the
   // audio decoder job resume decoding. Send and decode video EOS.
   VerifyPlaybackCompletesOnEOSDecode(true, false);
@@ skipping 404 matching lines @@
   WaitForAudioVideoDecodeDone();
 
   // Simulate audio |kConfigChanged| prefetched as standalone access unit.
   DemuxerConfigs audio_configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(true, 0, audio_configs));
 
   // Simulate video |kConfigChanged| prefetched as standalone access unit.
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(
-          false, 0, CreateVideoDemuxerConfigs(kCodecVP9)));
+          false, 0, CreateVideoDemuxerConfigs(true)));
   EXPECT_EQ(6, demuxer_->num_data_requests());
   EXPECT_TRUE(IsDrainingDecoder(true));
   EXPECT_TRUE(IsDrainingDecoder(false));
 
   // Waiting for decoder to finish draining.
   while (IsDrainingDecoder(true) || IsDrainingDecoder(false))
     message_loop_.RunUntilIdle();
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInPrefetchUnit0) {
@@ skipping 403 matching lines @@
 // also verify that the job is successfully created if SetDrmBridge(), Start()
 // and eventually OnMediaCrypto() occur. This would increase test coverage of
 // http://crbug.com/313470 and allow us to remove inspection of internal player
 // pending event state. See http://crbug.com/313860.
 TEST_F(MediaSourcePlayerTest, SurfaceChangeClearedEvenIfMediaCryptoAbsent) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that |SURFACE_CHANGE_EVENT_PENDING| is not pending after
   // SetVideoSurface() for a player configured for encrypted video, when the
   // player has not yet received media crypto.
-  DemuxerConfigs configs = CreateVideoDemuxerConfigs(kCodecVP8);
+  DemuxerConfigs configs = CreateVideoDemuxerConfigs(false);
   configs.is_video_encrypted = true;
 
   player_.OnDemuxerConfigsAvailable(configs);
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(GetMediaCodecBridge(false));
 }
 
 TEST_F(MediaSourcePlayerTest, CurrentTimeUpdatedWhileDecoderStarved) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
@@ skipping 22 matching lines @@
 
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, configs);
   player_.OnDemuxerDataAvailable(data);
   WaitForAudioDecodeDone();
   DecodeAudioDataUntilOutputBecomesAvailable();
 }
 
 }  // namespace media