Fix and enable mojo:media_pipeline_integration_apptests.

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"
@@ skipping 35 matching lines @@
 #define EXPECT_VIDEO_FORMAT_EQ(a, b)
 #define EXPECT_COLOR_SPACE_EQ(a, b)
 
 // TODO(xhwang): EME support is not complete for the mojo renderer, so all
 // encrypted tests are currently disabled.
 #define DISABLE_EME_TESTS 1
 
 // TODO(xhwang,dalecurtis): Text tracks are not currently supported by the mojo
 // renderer.
 #define DISABLE_TEXT_TRACK_TESTS 1
+
+// TODO(jrummell, dalecurtis): Clockless playback does not currently work with
+// mojo, so the tests take too long to run.
+#define DISABLE_CLOCKLESS_TESTS 1
 #else
 #define EXPECT_HASH_EQ(a, b) EXPECT_EQ(a, b)
 #define EXPECT_VIDEO_FORMAT_EQ(a, b) EXPECT_EQ(a, b)
 #define EXPECT_COLOR_SPACE_EQ(a, b) EXPECT_EQ(a, b)
-#endif
+#endif  // defined(MOJO_RENDERER)
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::AtMost;
 using testing::SaveArg;
 
 namespace media {
 
 const char kSourceId[] = "SourceId";
 
 const char kWebM[] = "video/webm; codecs=\"vp8,vorbis\"";
 const char kWebMVP9[] = "video/webm; codecs=\"vp9\"";
 const char kAudioOnlyWebM[] = "video/webm; codecs=\"vorbis\"";
 const char kOpusAudioOnlyWebM[] = "video/webm; codecs=\"opus\"";
 const char kVideoOnlyWebM[] = "video/webm; codecs=\"vp8\"";
 #if defined(USE_PROPRIETARY_CODECS)
 const char kADTS[] = "audio/aac";
 const char kMP4[] = "video/mp4; codecs=\"avc1.4D4041,mp4a.40.2\"";
 const char kMP4VideoAVC3[] = "video/mp4; codecs=\"avc3.64001f\"";
-#if !defined(DISABLE_EME_TESTS)
 const char kMP4Video[] = "video/mp4; codecs=\"avc1.4D4041\"";
 const char kMP4Audio[] = "audio/mp4; codecs=\"mp4a.40.2\"";
-#endif  // !defined(DISABLE_EME_TESTS)
 const char kMP3[] = "audio/mpeg";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Key used to encrypt test files.
 const uint8_t kSecretKey[] = {
   0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
   0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c
 };
 
 // The key ID for all encrypted files.
 const uint8_t kKeyId[] = {
   0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
   0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35
 };
 
 const size_t kAppendWholeFile = std::numeric_limits<size_t>::max();
 
 // Constants for the Media Source config change tests.
 const int kAppendTimeSec = 1;
 const int kAppendTimeMs = kAppendTimeSec * 1000;
 const int k320WebMFileDurationMs = 2736;
-#if !defined(DISABLE_EME_TESTS)
 const int k320EncWebMFileDurationMs = 2737;
-#endif  // !defined(DISABLE_EME_TESTS)
 const int k640WebMFileDurationMs = 2749;
 const int kOpusEndTrimmingWebMFileDurationMs = 2741;
 const int kVP9WebMFileDurationMs = 2736;
 const int kVP8AWebMFileDurationMs = 2734;
 
 #if !defined(MOJO_RENDERER)
 #if defined(OPUS_FIXED_POINT)
 static const char kOpusEndTrimmingHash_1[] =
     "-4.57,-5.68,-6.54,-6.29,-4.35,-3.59,";
 static const char kOpusEndTrimmingHash_2[] =
     "-11.93,-11.12,-8.27,-7.10,-7.84,-10.00,";
 static const char kOpusEndTrimmingHash_3[] =
     "-13.32,-14.38,-13.70,-11.69,-10.20,-10.48,";
 #else
 // Hash for a full playthrough of "opus-trimming-test.(webm|ogg)".
 static const char kOpusEndTrimmingHash_1[] =
     "-4.56,-5.65,-6.51,-6.29,-4.36,-3.59,";
 // The above hash, plus an additional playthrough starting from T=1s.
 static const char kOpusEndTrimmingHash_2[] =
     "-11.89,-11.09,-8.25,-7.11,-7.84,-9.97,";
 // The above hash, plus an additional playthrough starting from T=6.36s.
 static const char kOpusEndTrimmingHash_3[] =
     "-13.28,-14.35,-13.67,-11.68,-10.18,-10.46,";
 #endif  // defined(OPUS_FIXED_POINT)
-#endif
+#endif  // !defined(MOJO_RENDERER)
 
 #if defined(USE_PROPRIETARY_CODECS)
-#if !defined(DISABLE_EME_TESTS)
 const int k640IsoFileDurationMs = 2737;
 const int k640IsoCencFileDurationMs = 2736;
-#endif  // !defined(DISABLE_EME_TESTS)
 const int k1280IsoFileDurationMs = 2736;
 const int k1280IsoAVC3FileDurationMs = 2736;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Return a timeline offset for bear-320x240-live.webm.
 static base::Time kLiveTimelineOffset() {
   // The file contians the following UTC timeline offset:
   // 2012-11-10 12:34:56.789123456
   // Since base::Time only has a resolution of microseconds,
   // construct a base::Time for 2012-11-10 12:34:56.789123.
@@ skipping 520 matching lines @@
     return make_scoped_ptr(new MojoRendererImpl(message_loop_.task_runner(),
                                                 std::move(mojo_renderer)));
   }
 
  private:
   interfaces::ServiceFactoryPtr media_service_factory_;
 };
 #else
 class PipelineIntegrationTestHost : public testing::Test,
                                     public PipelineIntegrationTestBase {};
-#endif
+#endif  // defined(MOJO_RENDERER)
 
 class PipelineIntegrationTest : public PipelineIntegrationTestHost {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     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());
@@ skipping 132 matching lines @@
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   EXPECT_HASH_EQ("f0be120a90a811506777c99a2cdf7cc1", GetVideoHash());
   EXPECT_HASH_EQ("-3.59,-2.06,-0.43,2.15,0.77,-0.95,", GetAudioHash());
   EXPECT_TRUE(demuxer_->GetTimelineOffset().is_null());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackOpusOggTrimmingHashed) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+#define MAYBE_BasicPlaybackOpusOggTrimmingHashed \
+  DISABLED_BasicPlaybackOpusOggTrimmingHashed
+#else
+#define MAYBE_BasicPlaybackOpusOggTrimmingHashed \
+  BasicPlaybackOpusOggTrimmingHashed
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)

[xhwang, 2016/01/20 05:33:35]

Is it possible to wrap these defines in a macro, something like:

https://code.google.com/p/chromium/codesearch#chromium/src/ui/aura/window_eve...

[jrummell, 2016/01/21 01:30:25]

Done.

+TEST_F(PipelineIntegrationTest, MAYBE_BasicPlaybackOpusOggTrimmingHashed) {
   ASSERT_EQ(PIPELINE_OK,
             Start("opus-trimming-test.webm", kHashed | kClockless));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_1, GetAudioHash());
 
   // Seek within the pre-skip section, this should not cause a beep.
   ASSERT_TRUE(Seek(base::TimeDelta::FromSeconds(1)));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_2, GetAudioHash());
 
   // Seek somewhere outside of the pre-skip / end-trim section, demxuer should
   // correctly preroll enough to accurately decode this segment.
   ASSERT_TRUE(Seek(base::TimeDelta::FromMilliseconds(6360)));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_3, GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackOpusWebmTrimmingHashed) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+#define MAYBE_BasicPlaybackOpusWebmTrimmingHashed \
+  DISABLED_BasicPlaybackOpusWebmTrimmingHashed
+#else
+#define MAYBE_BasicPlaybackOpusWebmTrimmingHashed \
+  BasicPlaybackOpusWebmTrimmingHashed
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_BasicPlaybackOpusWebmTrimmingHashed) {
   ASSERT_EQ(PIPELINE_OK,
             Start("opus-trimming-test.webm", kHashed | kClockless));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_1, GetAudioHash());
 
   // Seek within the pre-skip section, this should not cause a beep.
   ASSERT_TRUE(Seek(base::TimeDelta::FromSeconds(1)));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_2, GetAudioHash());
 
   // Seek somewhere outside of the pre-skip / end-trim section, demxuer should
   // correctly preroll enough to accurately decode this segment.
   ASSERT_TRUE(Seek(base::TimeDelta::FromMilliseconds(6360)));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_3, GetAudioHash());
 }
 
+#if defined(DISABLE_CLOCKLESS_TESTS)
+#define MAYBE_BasicPlaybackOpusWebmTrimmingHashed_MediaSource \
+  DISABLED_BasicPlaybackOpusWebmTrimmingHashed_MediaSource
+#else
+#define MAYBE_BasicPlaybackOpusWebmTrimmingHashed_MediaSource \
+  BasicPlaybackOpusWebmTrimmingHashed_MediaSource
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
 TEST_F(PipelineIntegrationTest,
-       BasicPlaybackOpusWebmTrimmingHashed_MediaSource) {
+       MAYBE_BasicPlaybackOpusWebmTrimmingHashed_MediaSource) {
   MockMediaSource source("opus-trimming-test.webm", kOpusAudioOnlyWebM,
                          kAppendWholeFile);
   StartHashedClocklessPipelineWithMediaSource(&source);
   source.EndOfStream();
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_1, GetAudioHash());
 
@@ skipping 44 matching lines @@
 }
 
 TEST_F(PipelineIntegrationTest, F32PlaybackHashed) {
   ASSERT_EQ(PIPELINE_OK, Start("sfx_f32le.wav", kHashed));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(std::string(kNullVideoHash), GetVideoHash());
   EXPECT_HASH_EQ("3.03,2.86,2.99,3.31,3.57,4.06,", GetAudioHash());
 }
 
-#if !defined(DISABLE_EME_TESTS)
-TEST_F(PipelineIntegrationTest, BasicPlaybackEncrypted) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_BasicPlaybackEncrypted DISABLED_BasicPlaybackEncrypted
+#else
+#define MAYBE_BasicPlaybackEncrypted BasicPlaybackEncrypted
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_BasicPlaybackEncrypted) {
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   set_encrypted_media_init_data_cb(
       base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
                  base::Unretained(&encrypted_media)));
 
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-av_enc-av.webm",
                                encrypted_media.GetCdmContext()));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   Stop();
 }
-#endif  // !defined(DISABLE_EME_TESTS)
 
 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource) {
   MockMediaSource source("bear-320x240.webm", kWebM, 219229);
   StartPipelineWithMediaSource(&source);
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(k320WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
@@ skipping 178 matching lines @@
     source.AppendAtTime(media_time, file->data(), file->data_size());
     buffered_ranges = pipeline_->GetBufferedTimeRanges();
   } while (buffered_ranges.size() == 1 &&
            buffered_ranges.start(0) == base::TimeDelta::FromSeconds(0));
 
   EXPECT_EQ(1u, buffered_ranges.size());
   source.Shutdown();
   Stop();
 }
 
-#if !defined(DISABLE_EME_TESTS)
-TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_Encrypted_WebM) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_MediaSource_ConfigChange_Encrypted_WebM \
+  DISABLED_MediaSource_ConfigChange_Encrypted_WebM
+#else
+#define MAYBE_MediaSource_ConfigChange_Encrypted_WebM \
+  MediaSource_ConfigChange_Encrypted_WebM
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_MediaSource_ConfigChange_Encrypted_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
 // Config changes from encrypted to clear are not currently supported.
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_MediaSource_ConfigChange_ClearThenEncrypted_WebM \
+  DISABLED_MediaSource_ConfigChange_ClearThenEncrypted_WebM
+#else
+#define MAYBE_MediaSource_ConfigChange_ClearThenEncrypted_WebM \
+  MediaSource_ConfigChange_ClearThenEncrypted_WebM
+#endif  // defined(DISABLE_EME_TESTS)
 TEST_F(PipelineIntegrationTest,
-       MediaSource_ConfigChange_ClearThenEncrypted_WebM) {
+       MAYBE_MediaSource_ConfigChange_ClearThenEncrypted_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
   message_loop_.Run();
   EXPECT_EQ(PIPELINE_ERROR_DECODE, pipeline_status_);
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   // The second video was not added, so its time has not been added.
   EXPECT_EQ(k320WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
   source.Shutdown();
 }
 
 // Config changes from clear to encrypted are not currently supported.
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_MediaSource_ConfigChange_EncryptedThenClear_WebM \
+  DISABLED_MediaSource_ConfigChange_EncryptedThenClear_WebM
+#else
+#define MAYBE_MediaSource_ConfigChange_EncryptedThenClear_WebM \
+  MediaSource_ConfigChange_EncryptedThenClear_WebM
+#endif  // defined(DISABLE_EME_TESTS)
 TEST_F(PipelineIntegrationTest,
-       MediaSource_ConfigChange_EncryptedThenClear_WebM) {
+       MAYBE_MediaSource_ConfigChange_EncryptedThenClear_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   // The second video was not added, so its time has not been added.
   EXPECT_EQ(k320EncWebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
   source.Shutdown();
 }
-#endif  // !defined(DISABLE_EME_TESTS)
 
 #if defined(USE_PROPRIETARY_CODECS)
 TEST_F(PipelineIntegrationTest, MediaSource_ADTS) {
   MockMediaSource source("sfx.adts", kADTS, kAppendWholeFile);
   StartPipelineWithMediaSource(&source);
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(325, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
@@ skipping 40 matching lines @@
   ASSERT_EQ(PIPELINE_OK, Start("sfx.mp3", kHashed));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   // Verify codec delay and preroll are stripped.
   EXPECT_HASH_EQ("1.30,2.72,4.56,5.08,3.74,2.03,", GetAudioHash());
 }
 
+#if !defined(DISABLE_CLOCKLESS_TESTS)
 class Mp3FastSeekParams {
  public:
   Mp3FastSeekParams(const char* filename, const char* hash)
       : filename(filename), hash(hash) {}
   const char* filename;
   const char* hash;
 };
 
 class Mp3FastSeekIntegrationTest
     : public PipelineIntegrationTest,
@@ skipping 38 matching lines @@
                                         "0.95,0.56,1.34,0.47,1.77,0.84,")));
 
 // VBR seeks can be fast *OR* accurate, but not both. We chose fast.
 INSTANTIATE_TEST_CASE_P(
     VBRSeeks,
     Mp3FastSeekIntegrationTest,
     ::testing::Values(Mp3FastSeekParams("bear-audio-10s-VBR-has-TOC.mp3",
                                         "-0.15,-0.83,0.54,1.00,1.94,0.93,"),
                       Mp3FastSeekParams("bear-audio-10s-VBR-no-TOC.mp3",
                                         "-0.22,0.80,1.19,0.73,-0.31,-1.12,")));
+#endif  // !defined(DISABLE_CLOCKLESS_TESTS)
 
 TEST_F(PipelineIntegrationTest, MediaSource_MP3) {
   MockMediaSource source("sfx.mp3", kMP3, kAppendWholeFile);
   StartHashedPipelineWithMediaSource(&source);
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(313, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
@@ skipping 62 matching lines @@
   EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-#if !defined(DISABLE_EME_TESTS)
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly \
+  DISABLED_MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly
+#else
+#define MAYBE_MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly \
+  MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly
+#endif  // defined(DISABLE_EME_TESTS)
 TEST_F(PipelineIntegrationTest,
-       MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly) {
+       MAYBE_MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly) {
   MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest,
-       MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly \
+  DISABLED_MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly
+#else
+#define MAYBE_MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly \
+  MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(
+    PipelineIntegrationTest,
+    MAYBE_MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly) {
   MockMediaSource source("bear-640x360-v_frag-cenc-key_rotation.mp4", kMP4Video,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-1280x720-v_frag-cenc-key_rotation.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
@@ skipping 38 matching lines @@
   EXPECT_EQ(k640IsoFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
   source.Shutdown();
 }
 
 // Config changes from encrypted to clear are not currently supported.
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC \
+  DISABLED_MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC
+#else
+#define MAYBE_MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC \
+  MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC
+#endif  // defined(DISABLE_EME_TESTS)
 TEST_F(PipelineIntegrationTest,
-       MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC) {
+       MAYBE_MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC) {
   MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   // The second video was not added, so its time has not been added.
   EXPECT_EQ(k640IsoCencFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
   source.Shutdown();
 }
-#endif  // !defined(DISABLE_EME_TESTS)
 
 // Verify files which change configuration midstream fail gracefully.
 TEST_F(PipelineIntegrationTest, MidStreamConfigChangesFail) {
   ASSERT_EQ(PIPELINE_OK, Start("midstream_config_change.mp3"));
   Play();
   ASSERT_EQ(WaitUntilEndedOrError(), PIPELINE_ERROR_DECODE);
 }
-
-#endif
+#endif  // defined(USE_PROPRIETARY_CODECS)
 
 TEST_F(PipelineIntegrationTest, BasicPlayback_16x9AspectRatio) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-16x9-aspect.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-#if !defined(DISABLE_EME_TESTS)
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_WebM) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_WebM DISABLED_EncryptedPlayback_WebM
+#else
+#define MAYBE_EncryptedPlayback_WebM EncryptedPlayback_WebM
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_EncryptedPlayback_WebM) {
   MockMediaSource source("bear-320x240-av_enc-av.webm", kWebM, 219816);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_ClearStart_WebM) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_ClearStart_WebM \
+  DISABLED_EncryptedPlayback_ClearStart_WebM
+#else
+#define MAYBE_EncryptedPlayback_ClearStart_WebM \
+  EncryptedPlayback_ClearStart_WebM
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_EncryptedPlayback_ClearStart_WebM) {
   MockMediaSource source("bear-320x240-av_enc-av_clear-1s.webm", kWebM,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_NoEncryptedFrames_WebM) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_NoEncryptedFrames_WebM \
+  DISABLED_EncryptedPlayback_NoEncryptedFrames_WebM
+#else
+#define MAYBE_EncryptedPlayback_NoEncryptedFrames_WebM \
+  EncryptedPlayback_NoEncryptedFrames_WebM
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EncryptedPlayback_NoEncryptedFrames_WebM) {
   MockMediaSource source("bear-320x240-av_enc-av_clear-all.webm", kWebM,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new NoResponseApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
-#endif  // !defined(DISABLE_EME_TESTS)
 
 #if defined(USE_PROPRIETARY_CODECS)
-#if !defined(DISABLE_EME_TESTS)
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_VideoOnly) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_MP4_CENC_VideoOnly \
+  DISABLED_EncryptedPlayback_MP4_CENC_VideoOnly
+#else
+#define MAYBE_EncryptedPlayback_MP4_CENC_VideoOnly \
+  EncryptedPlayback_MP4_CENC_VideoOnly
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_EncryptedPlayback_MP4_CENC_VideoOnly) {
   MockMediaSource source("bear-1280x720-v_frag-cenc.mp4", kMP4Video,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_AudioOnly) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_MP4_CENC_AudioOnly \
+  DISABLED_EncryptedPlayback_MP4_CENC_AudioOnly
+#else
+#define MAYBE_EncryptedPlayback_MP4_CENC_AudioOnly \
+  EncryptedPlayback_MP4_CENC_AudioOnly
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest, MAYBE_EncryptedPlayback_MP4_CENC_AudioOnly) {
   MockMediaSource source("bear-1280x720-a_frag-cenc.mp4", kMP4Audio,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly \
+  DISABLED_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly
+#else
+#define MAYBE_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly \
+  EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly
+#endif  // defined(DISABLE_EME_TESTS)
 TEST_F(PipelineIntegrationTest,
-       EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly) {
+       MAYBE_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly) {
   MockMediaSource source("bear-1280x720-v_frag-cenc_clear-all.mp4", kMP4Video,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new NoResponseApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly \
+  DISABLED_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly
+#else
+#define MAYBE_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly \
+  EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly
+#endif  // defined(DISABLE_EME_TESTS)
 TEST_F(PipelineIntegrationTest,
-       EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly) {
+       MAYBE_EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly) {
   MockMediaSource source("bear-1280x720-a_frag-cenc_clear-all.mp4", kMP4Audio,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new NoResponseApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_KeyRotation_Video) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_MP4_CENC_KeyRotation_Video \
+  DISABLED_EncryptedPlayback_MP4_CENC_KeyRotation_Video
+#else
+#define MAYBE_EncryptedPlayback_MP4_CENC_KeyRotation_Video \
+  EncryptedPlayback_MP4_CENC_KeyRotation_Video
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EncryptedPlayback_MP4_CENC_KeyRotation_Video) {
   MockMediaSource source("bear-1280x720-v_frag-cenc-key_rotation.mp4",
                          kMP4Video, kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_KeyRotation_Audio) {
+#if defined(DISABLE_EME_TESTS)
+#define MAYBE_EncryptedPlayback_MP4_CENC_KeyRotation_Audio \
+  DISABLED_EncryptedPlayback_MP4_CENC_KeyRotation_Audio
+#else
+#define MAYBE_EncryptedPlayback_MP4_CENC_KeyRotation_Audio \
+  EncryptedPlayback_MP4_CENC_KeyRotation_Audio
+#endif  // defined(DISABLE_EME_TESTS)
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EncryptedPlayback_MP4_CENC_KeyRotation_Audio) {
   MockMediaSource source("bear-1280x720-a_frag-cenc-key_rotation.mp4",
                          kMP4Audio, kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
-#endif  // !defined(DISABLE_EME_TESTS)
 
 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_AVC3) {
   MockMediaSource source("bear-1280x720-v_frag-avc3.mp4", kMP4VideoAVC3,
                          kAppendWholeFile);
   StartPipelineWithMediaSource(&source);
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(k1280IsoAVC3FileDurationMs,
@@ skipping 94 matching lines @@
 
 TEST_F(PipelineIntegrationTest, Rotated_Metadata_180) {
   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_180.mp4"));
   ASSERT_EQ(VIDEO_ROTATION_180, metadata_.video_rotation);
 }
 
 TEST_F(PipelineIntegrationTest, Rotated_Metadata_270) {
   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_270.mp4"));
   ASSERT_EQ(VIDEO_ROTATION_270, metadata_.video_rotation);
 }
-#endif
+#endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Verify audio decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-audio-only.webm", kAudioOnlyWebM,
                                  16384,
                                  base::TimeDelta::FromMilliseconds(464),
                                  base::TimeDelta::FromMilliseconds(617),
                                  0x10CA, 19730));
 }
 
@@ skipping 154 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