Media Remoting: End to end integration tests.

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 <memory>
 #include <utility>
 
@@ skipping 45 matching lines @@
 #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
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING)

[miu, 2017/03/29 01:39:15]

Why is this dependent on !defined(MOJO_RENDERER)? Can we #include the file
regardless?

[xjz, 2017/03/30 23:21:31]

Done. It should be ok to remove !defined(MOJO_RENDERER). I added this condition
since I thought we don't test remoting when MOJO_RENDERER is enabled, and all
mojo tests are actually disabled. 

+#include "media/remoting/end2end_test_renderer.h"  // nogncheck
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING)
 #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  // defined(MOJO_RENDERER)
 
 #if defined(DISABLE_EME_TESTS)
 #define MAYBE_EME(test) DISABLED_##test
 #else
 #define MAYBE_EME(test) test
 #endif
 
 #if defined(DISABLE_TEXT_TRACK_TESTS)
 #define MAYBE_TEXT(test) DISABLED_##test
 #else
 #define MAYBE_TEXT(test) test
 #endif
 
-#if defined(DISABLE_CLOCKLESS_TESTS)
-#define MAYBE_CLOCKLESS(test) DISABLED_##test
-#else
-#define MAYBE_CLOCKLESS(test) test
-#endif
-
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::AtMost;
 using testing::SaveArg;
 
 namespace media {
 
+namespace {
+
 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 BUILDFLAG(USE_PROPRIETARY_CODECS)
 const char kADTS[] = "audio/aac";
 const char kMP4[] = "video/mp4; codecs=\"avc1.4D4041,mp4a.40.2\"";
@@ skipping 552 matching lines @@
   }
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
               const DecodeCB& decode_cb) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(decode_cb, DecodeStatus::DECODE_ERROR));
   }
   void Reset(const base::Closure& closure) override { closure.Run(); }
   bool NeedsBitstreamConversion() const override { return true; }
 };
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)

[miu, 2017/03/29 01:39:15]

Along the lines of my earlier comment, can we just do this everywhere instead:

  #if BUILDFLAG(ENABLE_MEDIA_REMOTING)

[xjz, 2017/03/30 23:21:31]

Done. Now removed this class to base.

+class RemotingTestRendererFactory final : public PipelineTestRendererFactory {
+ public:
+  explicit RemotingTestRendererFactory(
+      std::unique_ptr<PipelineTestRendererFactory> renderer_factory)
+      : default_renderer_factory_(std::move(renderer_factory)) {}
+  ~RemotingTestRendererFactory() override {}
+
+  // PipelineTestRendererFactory implementation.
+  std::unique_ptr<Renderer> CreateRenderer(
+      ScopedVector<VideoDecoder> prepend_video_decoders =
+          ScopedVector<VideoDecoder>(),
+      ScopedVector<AudioDecoder> prepend_audio_decoders =
+          ScopedVector<AudioDecoder>()) override {
+    std::unique_ptr<Renderer> renderer_impl =
+        default_renderer_factory_->CreateRenderer(
+            std::move(prepend_video_decoders),
+            std::move(prepend_audio_decoders));
+    return base::MakeUnique<remoting::End2EndTestRenderer>(
+        std::move(renderer_impl));
+  }
+
+ private:
+  std::unique_ptr<PipelineTestRendererFactory> default_renderer_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemotingTestRendererFactory);
+};
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+
+}  // namespace
+
 // TODO(xhwang): These tests have been disabled for some time as apptests and no
 //               longer pass. They need to be reconstituted as shell tests.
 //               Currently there are compile issues which must be resolved,
 //               preferably by eliminating multiple inheritance here which is
 //               banned by Google C++ style.
 #if defined(MOJO_RENDERER) && defined(ENABLE_MOJO_PIPELINE_INTEGRATION_TEST)
 class PipelineIntegrationTestHost : public service_manager::test::ServiceTest,
                                     public PipelineIntegrationTestBase {
  public:
   PipelineIntegrationTestHost()
@@ skipping 71 matching lines @@
       // never called.
       EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
       pipeline_->SetCdm(encrypted_media->GetCdmContext(),
                         base::Bind(&PipelineIntegrationTest::DecryptorAttached,
                                    base::Unretained(this)));
     } else {
       // Encrypted content not used, so this is never called.
       EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     }
 
-    pipeline_->Start(demuxer_.get(), CreateRenderer(), this,
+    pipeline_->Start(demuxer_.get(), renderer_factory_->CreateRenderer(), this,
                      base::Bind(&PipelineIntegrationTest::OnStatusCallback,
                                 base::Unretained(this)));
 
     if (encrypted_media) {
       source->set_encrypted_media_init_data_cb(
           base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
                      base::Unretained(encrypted_media)));
     }
     base::RunLoop().Run();
     return pipeline_status_;
@@ skipping 23 matching lines @@
       return false;
 
     source.EndOfStream();
 
     source.Shutdown();
     Stop();
     return true;
   }
 };
 
+enum PipelineType {
+  Media,          // Test the general media pipeline.
+  MediaRemoting,  // Test Media Remoting pipeline.
+};
+
 struct PlaybackTestData {
+  const PipelineType type;
   const std::string filename;
   const uint32_t start_time_ms;
   const uint32_t duration_ms;
 };
 
 struct MSEPlaybackTestData {
+  const PipelineType type;
   const std::string filename;
   const std::string mimetype;
   const size_t append_bytes;
   const uint32_t duration_ms;
 };
 
 // Tells gtest how to print our PlaybackTestData structure.
 std::ostream& operator<<(std::ostream& os, const PlaybackTestData& data) {
   return os << data.filename;
 }
 
 std::ostream& operator<<(std::ostream& os, const MSEPlaybackTestData& data) {
   return os << data.filename;
 }
 
 class BasicPlaybackTest : public PipelineIntegrationTest,
                           public testing::WithParamInterface<PlaybackTestData> {
 };
 
 class BasicMSEPlaybackTest
     : public ::testing::WithParamInterface<MSEPlaybackTestData>,
       public PipelineIntegrationTest {};
 
 TEST_P(BasicPlaybackTest, PlayToEnd) {
   PlaybackTestData data = GetParam();
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)

[miu, 2017/03/29 01:39:14]

Instead of duplicating this code for each test fixture, could you do what you
did in CommonPipelineIntegrationTest?

In fact, maybe this should be moved into a base class, shared by both?

[xjz, 2017/03/30 23:21:31]

Done.

+  if (data.type == PipelineType::MediaRemoting) {
+    std::unique_ptr<PipelineTestRendererFactory> factory =
+        std::move(renderer_factory_);
+    renderer_factory_.reset(
+        new RemotingTestRendererFactory(std::move(factory)));
+  }
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+
   ASSERT_EQ(PIPELINE_OK,
             Start(data.filename, kClockless | kUnreliableDuration));
   EXPECT_EQ(data.start_time_ms, demuxer_->GetStartTime().InMilliseconds());
   EXPECT_EQ(data.duration_ms, pipeline_->GetMediaDuration().InMilliseconds());
 
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 TEST_P(BasicMSEPlaybackTest, PlayToEnd) {
   MSEPlaybackTestData data = GetParam();
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+  if (data.type == PipelineType::MediaRemoting) {
+    std::unique_ptr<PipelineTestRendererFactory> factory =
+        std::move(renderer_factory_);
+    renderer_factory_.reset(
+        new RemotingTestRendererFactory(std::move(factory)));
+  }
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+
   MockMediaSource source(data.filename, data.mimetype, data.append_bytes);
   // TODO -- ADD uint8_t test_type to StartWithMSE and pass clockless flags
   ASSERT_EQ(PIPELINE_OK,
             StartPipelineWithMediaSource(&source, kClockless, nullptr));
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(data.duration_ms,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   EXPECT_TRUE(demuxer_->GetTimelineOffset().is_null());
   source.Shutdown();
   Stop();
 }
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
 
 const PlaybackTestData kADTSTests[] = {
-    {"bear-audio-main-aac.aac", 0, 2724},
-    {"bear-audio-lc-aac.aac", 0, 2858},
-    {"bear-audio-implicit-he-aac-v1.aac", 0, 2812},
-    {"bear-audio-implicit-he-aac-v2.aac", 0, 3047},
+    {PipelineType::Media, "bear-audio-main-aac.aac", 0, 2724},
+    {PipelineType::Media, "bear-audio-lc-aac.aac", 0, 2858},
+    {PipelineType::Media, "bear-audio-implicit-he-aac-v1.aac", 0, 2812},
+    {PipelineType::Media, "bear-audio-implicit-he-aac-v2.aac", 0, 3047},
 };
 
 // TODO(chcunningham): Migrate other basic playback tests to TEST_P.
 INSTANTIATE_TEST_CASE_P(ProprietaryCodecs,
                         BasicPlaybackTest,
                         testing::ValuesIn(kADTSTests));
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+const PlaybackTestData kADTSRemotingTests[] = {

[miu, 2017/03/29 01:39:15]

Let's just have one definition with the remoting entries added if the build flag
is set. Basically, we want to minimize the "surface area" of the extra test code
needed for remoting. That way, it'll be far more likely future changes (by
others) to the test code will be made such that they will automatically apply to
both the local and remote pipelines without any extra effort. For example, here:

const PlaybackTestData kADTSTests[] = {
    {PipelineType::Media, "bear-audio-main-aac.aac", 0, 2724},
    {PipelineType::Media, "bear-audio-lc-aac.aac", 0, 2858},
    {PipelineType::Media, "bear-audio-implicit-he-aac-v1.aac", 0, 2812},
    {PipelineType::Media, "bear-audio-implicit-he-aac-v2.aac", 0, 3047},
#if BUILDFLAG(ENABLE_MEDIA_REMOTING)
    {PipelineType::MediaRemoting, "bear-audio-main-aac.aac", 0, 2724},
    {PipelineType::MediaRemoting, "bear-audio-lc-aac.aac", 0, 2858},
    {PipelineType::MediaRemoting, "bear-audio-implicit-he-aac-v1.aac", 0, 2812},
    {PipelineType::MediaRemoting, "bear-audio-implicit-he-aac-v2.aac", 0, 3047},
#endif
};

// TODO(chcunningham): Migrate other basic playback tests to TEST_P.
INSTANTIATE_TEST_CASE_P(ProprietaryCodecs,
                        BasicPlaybackTest,
                        testing::ValuesIn(kADTSTests));

[xjz, 2017/03/30 23:21:31]

Done.

+    {PipelineType::MediaRemoting, "bear-audio-main-aac.aac", 0, 2724},
+    {PipelineType::MediaRemoting, "bear-audio-lc-aac.aac", 0, 2858},
+    {PipelineType::MediaRemoting, "bear-audio-implicit-he-aac-v1.aac", 0, 2812},
+    {PipelineType::MediaRemoting, "bear-audio-implicit-he-aac-v2.aac", 0, 3047},
+};
+
+INSTANTIATE_TEST_CASE_P(ProprietaryCodecs_Remoting,
+                        BasicPlaybackTest,
+                        testing::ValuesIn(kADTSRemotingTests));
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+
 const MSEPlaybackTestData kMediaSourceADTSTests[] = {
-    {"bear-audio-main-aac.aac", kADTS, kAppendWholeFile, 2773},
-    {"bear-audio-lc-aac.aac", kADTS, kAppendWholeFile, 2794},
-    {"bear-audio-implicit-he-aac-v1.aac", kADTS, kAppendWholeFile, 2858},
-    {"bear-audio-implicit-he-aac-v2.aac", kADTS, kAppendWholeFile, 2901},
+    {PipelineType::Media, "bear-audio-main-aac.aac", kADTS, kAppendWholeFile,
+     2773},
+    {PipelineType::Media, "bear-audio-lc-aac.aac", kADTS, kAppendWholeFile,
+     2794},
+    {PipelineType::Media, "bear-audio-implicit-he-aac-v1.aac", kADTS,
+     kAppendWholeFile, 2858},
+    {PipelineType::Media, "bear-audio-implicit-he-aac-v2.aac", kADTS,
+     kAppendWholeFile, 2901},
 };
 
 // TODO(chcunningham): Migrate other basic MSE playback tests to TEST_P.
 INSTANTIATE_TEST_CASE_P(ProprietaryCodecs,
                         BasicMSEPlaybackTest,
                         testing::ValuesIn(kMediaSourceADTSTests));
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+const MSEPlaybackTestData kMediaSourceADTSRemotingTests[] = {

[miu, 2017/03/29 01:39:15]

ditto: Merge into one parameter array.

[xjz, 2017/03/30 23:21:31]

Done.

+    {PipelineType::MediaRemoting, "bear-audio-main-aac.aac", kADTS,
+     kAppendWholeFile, 2773},
+    {PipelineType::MediaRemoting, "bear-audio-lc-aac.aac", kADTS,
+     kAppendWholeFile, 2794},
+    {PipelineType::MediaRemoting, "bear-audio-implicit-he-aac-v1.aac", kADTS,
+     kAppendWholeFile, 2858},
+    {PipelineType::MediaRemoting, "bear-audio-implicit-he-aac-v2.aac", kADTS,
+     kAppendWholeFile, 2901},
+};
+
+INSTANTIATE_TEST_CASE_P(ProprietaryCodecs_Remoting,
+                        BasicMSEPlaybackTest,
+                        testing::ValuesIn(kMediaSourceADTSRemotingTests));
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+
 #endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 
-TEST_F(PipelineIntegrationTest, BasicPlayback) {
+struct IntegrationTestData {
+  const PipelineType type;
+};
+
+// Tells gtest how to print our PlaybackTestData structure.
+std::ostream& operator<<(std::ostream& os, const IntegrationTestData& data) {
+  return os << (data.type == PipelineType::Media ? "Media" : "MediaRemoting");
+}
+
+// These tests are used to test both media pipeline and media remoting pipeline.
+class CommonPipelineIntegrationTest
+    : public PipelineIntegrationTest,
+      public testing::WithParamInterface<IntegrationTestData> {
+ public:
+  CommonPipelineIntegrationTest() {
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+    IntegrationTestData data = GetParam();
+    if (data.type == PipelineType::MediaRemoting) {
+      std::unique_ptr<PipelineTestRendererFactory> factory =
+          std::move(renderer_factory_);
+      renderer_factory_.reset(
+          new RemotingTestRendererFactory(std::move(factory)));
+    }
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+  }
+};
+
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackOpusOgg) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackOpusOgg) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-opus.ogg"));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackHashed) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackHashed) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm", kHashed));
 
   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());
 }
 
 base::TimeDelta TimestampMs(int milliseconds) {
   return base::TimeDelta::FromMilliseconds(milliseconds);
 }
 
-TEST_F(PipelineIntegrationTest, PlaybackWithAudioTrackDisabledThenEnabled) {
+TEST_P(CommonPipelineIntegrationTest,
+       PlaybackWithAudioTrackDisabledThenEnabled) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm", kHashed));
 
   // Disable audio.
   std::vector<MediaTrack::Id> empty;
   pipeline_->OnEnabledAudioTracksChanged(empty);
   base::RunLoop().RunUntilIdle();
 
   // Seek to flush the pipeline and ensure there's no prerolled audio data.
   ASSERT_TRUE(Seek(base::TimeDelta()));
 
@@ skipping 13 matching lines @@
 
   // Restart playback from 500ms position.
   ASSERT_TRUE(Seek(k500ms));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 
   // Verify that audio has been playing after being enabled.
   EXPECT_HASH_EQ("-1.53,0.21,1.23,1.56,-0.34,-0.94,", GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest, PlaybackWithVideoTrackDisabledThenEnabled) {
+TEST_P(CommonPipelineIntegrationTest,
+       PlaybackWithVideoTrackDisabledThenEnabled) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm", kHashed));
 
   // Disable video.
   std::vector<MediaTrack::Id> empty;
   pipeline_->OnSelectedVideoTrackChanged(empty);
   base::RunLoop().RunUntilIdle();
 
   // Seek to flush the pipeline and ensure there's no prerolled video data.
   ASSERT_TRUE(Seek(base::TimeDelta()));
 
@@ skipping 22 matching lines @@
 
   // Restart playback from 500ms position.
   ASSERT_TRUE(Seek(k500ms));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 
   // Verify that video has been rendered after being enabled.
   EXPECT_HASH_EQ("fd59357dfd9c144ab4fb8181b2de32c3", GetVideoHash());
 }
 
-TEST_F(PipelineIntegrationTest, TrackStatusChangesBeforePipelineStarted) {
+TEST_P(CommonPipelineIntegrationTest, TrackStatusChangesBeforePipelineStarted) {
   std::vector<MediaTrack::Id> empty_track_ids;
   pipeline_->OnEnabledAudioTracksChanged(empty_track_ids);
   pipeline_->OnSelectedVideoTrackChanged(empty_track_ids);
 }
 
-TEST_F(PipelineIntegrationTest, TrackStatusChangesAfterPipelineEnded) {
+TEST_P(CommonPipelineIntegrationTest, TrackStatusChangesAfterPipelineEnded) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm", kHashed));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   std::vector<MediaTrack::Id> track_ids;
   // Disable audio track.
   pipeline_->OnEnabledAudioTracksChanged(track_ids);
   // Re-enable audio track.
   track_ids.push_back("2");
   pipeline_->OnEnabledAudioTracksChanged(track_ids);
   // Disable video track.
   track_ids.clear();
   pipeline_->OnSelectedVideoTrackChanged(track_ids);
   // Re-enable video track.
   track_ids.push_back("1");
   pipeline_->OnSelectedVideoTrackChanged(track_ids);
 }
 
-TEST_F(PipelineIntegrationTest, TrackStatusChangesWhileSuspended) {
+TEST_P(CommonPipelineIntegrationTest, TrackStatusChangesWhileSuspended) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm", kHashed));
   Play();
 
   ASSERT_TRUE(Suspend());
 
   // These get triggered every time playback is resumed.
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(320, 240)))
       .Times(AnyNumber());
   EXPECT_CALL(*this, OnVideoOpacityChange(true)).Times(AnyNumber());
 
@@ skipping 19 matching lines @@
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(TimestampMs(400)));
   ASSERT_TRUE(Suspend());
 
   // Re-enable video track.
   track_ids.push_back("1");
   pipeline_->OnSelectedVideoTrackChanged(track_ids);
   ASSERT_TRUE(Resume(TimestampMs(400)));
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, PipelineStoppedWhileAudioRestartPending) {
+TEST_P(CommonPipelineIntegrationTest, PipelineStoppedWhileAudioRestartPending) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
   Play();
 
   // Disable audio track first, to re-enable it later and stop the pipeline
   // (which destroys the media renderer) while audio restart is pending.
   std::vector<MediaTrack::Id> track_ids;
   pipeline_->OnEnabledAudioTracksChanged(track_ids);
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(TimestampMs(200)));
 
   track_ids.push_back("2");
   pipeline_->OnEnabledAudioTracksChanged(track_ids);
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, PipelineStoppedWhileVideoRestartPending) {
+TEST_P(CommonPipelineIntegrationTest, PipelineStoppedWhileVideoRestartPending) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
   Play();
 
   // Disable video track first, to re-enable it later and stop the pipeline
   // (which destroys the media renderer) while video restart is pending.
   std::vector<MediaTrack::Id> track_ids;
   pipeline_->OnSelectedVideoTrackChanged(track_ids);
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(TimestampMs(200)));
 
   track_ids.push_back("1");
   pipeline_->OnSelectedVideoTrackChanged(track_ids);
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest,
-       MAYBE_CLOCKLESS(BasicPlaybackOpusOggTrimmingHashed)) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackOpusOggTrimmingHashed) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+  return;
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
+
   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,
-       MAYBE_CLOCKLESS(BasicPlaybackOpusWebmTrimmingHashed)) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackOpusWebmTrimmingHashed) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+  return;
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
+
   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,
-       MAYBE_CLOCKLESS(BasicPlaybackOpusWebmTrimmingHashed_MediaSource)) {
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlaybackOpusWebmTrimmingHashed_MediaSource) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+  return;
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
+
   MockMediaSource source("opus-trimming-test.webm", kOpusAudioOnlyWebM,
                          kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(
                              &source, kClockless | kHashed, nullptr));
   source.EndOfStream();
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_1, GetAudioHash());
 
   // Seek within the pre-skip section, this should not cause a beep.
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(1);
   source.Seek(seek_time);
   ASSERT_TRUE(Seek(seek_time));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_2, GetAudioHash());
 
   // Seek somewhere outside of the pre-skip / end-trim section, demuxer should
   // correctly preroll enough to accurately decode this segment.
   seek_time = base::TimeDelta::FromMilliseconds(6360);
   source.Seek(seek_time);
   ASSERT_TRUE(Seek(seek_time));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusEndTrimmingHash_3, GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest,
-       MAYBE_CLOCKLESS(BasicPlaybackOpusPrerollExceedsCodecDelay)) {
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlaybackOpusPrerollExceedsCodecDelay) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+  return;
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
+
   ASSERT_EQ(PIPELINE_OK, Start("bear-opus.webm", kHashed | kClockless));
 
   AudioDecoderConfig config =
       demuxer_->GetStream(DemuxerStream::AUDIO)->audio_decoder_config();
 
   // Verify that this file's preroll is not eclipsed by the codec delay so we
   // can detect when preroll is not properly performed.
   base::TimeDelta codec_delay = base::TimeDelta::FromSecondsD(
       static_cast<double>(config.codec_delay()) / config.samples_per_second());
   ASSERT_GT(config.seek_preroll(), codec_delay);
 
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusSmallCodecDelayHash_1, GetAudioHash());
 
   // Seek halfway through the file to invoke seek preroll.
   ASSERT_TRUE(Seek(base::TimeDelta::FromSecondsD(1.414)));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusSmallCodecDelayHash_2, GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest,
-       MAYBE_CLOCKLESS(BasicPlaybackOpusPrerollExceedsCodecDelay_MediaSource)) {
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlaybackOpusPrerollExceedsCodecDelay_MediaSource) {
+#if defined(DISABLE_CLOCKLESS_TESTS)
+  return;
+#endif  // defined(DISABLE_CLOCKLESS_TESTS)
+
   MockMediaSource source("bear-opus.webm", kOpusAudioOnlyWebM,
                          kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(
                              &source, kClockless | kHashed, nullptr));
   source.EndOfStream();
 
   AudioDecoderConfig config =
       demuxer_->GetStream(DemuxerStream::AUDIO)->audio_decoder_config();
 
   // Verify that this file's preroll is not eclipsed by the codec delay so we
   // can detect when preroll is not properly performed.
   base::TimeDelta codec_delay = base::TimeDelta::FromSecondsD(
       static_cast<double>(config.codec_delay()) / config.samples_per_second());
   ASSERT_GT(config.seek_preroll(), codec_delay);
 
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusSmallCodecDelayHash_1, GetAudioHash());
 
   // Seek halfway through the file to invoke seek preroll.
   base::TimeDelta seek_time = base::TimeDelta::FromSecondsD(1.414);
   source.Seek(seek_time);
   ASSERT_TRUE(Seek(seek_time));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_HASH_EQ(kOpusSmallCodecDelayHash_2, GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackLive) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackLive) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-live.webm", kHashed));
 
   // Live stream does not have duration in the initialization segment.
   // It will be set after the entire file is available.
   EXPECT_CALL(*this, OnDurationChange()).Times(1);
 
   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_EQ(kLiveTimelineOffset(), demuxer_->GetTimelineOffset());
 }
 
-TEST_F(PipelineIntegrationTest, S32PlaybackHashed) {
+TEST_P(CommonPipelineIntegrationTest, S32PlaybackHashed) {
   ASSERT_EQ(PIPELINE_OK, Start("sfx_s32le.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());
 }
 
-TEST_F(PipelineIntegrationTest, F32PlaybackHashed) {
+TEST_P(CommonPipelineIntegrationTest, 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());
 }
 
-TEST_F(PipelineIntegrationTest, MAYBE_EME(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();
-}
-
-TEST_F(PipelineIntegrationTest, FlacPlaybackHashed) {
+TEST_P(CommonPipelineIntegrationTest, FlacPlaybackHashed) {
   ASSERT_EQ(PIPELINE_OK, Start("sfx.flac", 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());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_MediaSource) {
   MockMediaSource source("bear-320x240.webm", kWebM, 219229);
   EXPECT_EQ(PIPELINE_OK, 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());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   EXPECT_TRUE(demuxer_->GetTimelineOffset().is_null());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Live) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_MediaSource_Live) {
   MockMediaSource source("bear-320x240-live.webm", kWebM, 219221);
   EXPECT_EQ(PIPELINE_OK, 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());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(kLiveTimelineOffset(), demuxer_->GetTimelineOffset());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VP9_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_MediaSource_VP9_WebM) {
   MockMediaSource source("bear-vp9.webm", kWebMVP9, 67504);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kVP9WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VP9_BlockGroup_WebM) {
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlayback_MediaSource_VP9_BlockGroup_WebM) {
   MockMediaSource source("bear-vp9-blockgroup.webm", kWebMVP9, 67871);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kVP9WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VP8A_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_MediaSource_VP8A_WebM) {
   MockMediaSource source("bear-vp8a.webm", kVideoOnlyWebM, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kVP8AWebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Opus_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_MediaSource_Opus_WebM) {
   MockMediaSource source("bear-opus-end-trimming.webm", kOpusAudioOnlyWebM,
                          kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kOpusEndTrimmingWebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
 // Flaky. http://crbug.com/304776
-TEST_F(PipelineIntegrationTest, DISABLED_MediaSource_Opus_Seeking_WebM) {
+TEST_P(CommonPipelineIntegrationTest, DISABLED_MediaSource_Opus_Seeking_WebM) {
   MockMediaSource source("bear-opus-end-trimming.webm", kOpusAudioOnlyWebM,
                          kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK,
             StartPipelineWithMediaSource(&source, kHashed, nullptr));
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kOpusEndTrimmingWebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   base::TimeDelta start_seek_time = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(2000);
 
   Play();
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
   source.Seek(seek_time, 0x1D5, 34017);
   source.EndOfStream();
   ASSERT_TRUE(Seek(seek_time));
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
   EXPECT_HASH_EQ("0.76,0.20,-0.82,-0.58,-1.29,-0.29,", GetAudioHash());
 
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_WebM) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_ConfigChange_WebM) {
   MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
                          kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
 
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(640, 360))).Times(1);
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360.webm");
   ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                                   second_file->data(),
                                   second_file->data_size()));
   source.EndOfStream();
 
   Play();
   EXPECT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, MediaSource_Remove_Updates_BufferedRanges) {
+TEST_P(CommonPipelineIntegrationTest,
+       MediaSource_Remove_Updates_BufferedRanges) {
   const char* input_filename = "bear-320x240.webm";
   MockMediaSource source(input_filename, kWebM, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
 
   auto buffered_ranges = pipeline_->GetBufferedTimeRanges();
   EXPECT_EQ(1u, buffered_ranges.size());
   EXPECT_EQ(0, buffered_ranges.start(0).InMilliseconds());
   EXPECT_EQ(k320WebMFileDurationMs, buffered_ranges.end(0).InMilliseconds());
 
   source.RemoveRange(base::TimeDelta::FromMilliseconds(1000),
                      base::TimeDelta::FromMilliseconds(k320WebMFileDurationMs));
   base::RunLoop().RunUntilIdle();
 
   buffered_ranges = pipeline_->GetBufferedTimeRanges();
   EXPECT_EQ(1u, buffered_ranges.size());
   EXPECT_EQ(0, buffered_ranges.start(0).InMilliseconds());
   EXPECT_EQ(1001, buffered_ranges.end(0).InMilliseconds());
 
   source.Shutdown();
   Stop();
 }
 
 // This test case imitates media playback with advancing media_time and
 // continuously adding new data. At some point we should reach the buffering
 // limit, after that MediaSource should evict some buffered data and that
 // evicted data shold be reflected in the change of media::Pipeline buffered
 // ranges (returned by GetBufferedTimeRanges). At that point the buffered ranges
 // will no longer start at 0.
-TEST_F(PipelineIntegrationTest, MediaSource_FillUp_Buffer) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_FillUp_Buffer) {
   const char* input_filename = "bear-320x240.webm";
   MockMediaSource source(input_filename, kWebM, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.SetMemoryLimits(1048576);
 
   scoped_refptr<DecoderBuffer> file = ReadTestDataFile(input_filename);
 
   auto buffered_ranges = pipeline_->GetBufferedTimeRanges();
   EXPECT_EQ(1u, buffered_ranges.size());
   do {
     // Advance media_time to the end of the currently buffered data
     base::TimeDelta media_time = buffered_ranges.end(0);
     source.Seek(media_time);
     // Ask MediaSource to evict buffered data if buffering limit has been
     // reached (the data will be evicted from the front of the buffered range).
     source.EvictCodedFrames(media_time, file->data_size());
     ASSERT_TRUE(
         source.AppendAtTime(media_time, file->data(), file->data_size()));
     base::RunLoop().RunUntilIdle();
 
     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();
 }
 
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(MediaSource_ConfigChange_Encrypted_WebM)) {
-  MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(640, 360))).Times(1);
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-640x360-av_enc-av.webm");
-  ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                                  second_file->data(),
-                                  second_file->data_size()));
-  source.EndOfStream();
-
-  Play();
-  EXPECT_TRUE(WaitUntilOnEnded());
-
-  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
-  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
-  EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
-            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
-
-  source.Shutdown();
-  Stop();
-}
-
-// Config changes from encrypted to clear are not currently supported.
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(MediaSource_ConfigChange_ClearThenEncrypted_WebM)) {
-  MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-640x360-av_enc-av.webm");
-
-  ASSERT_FALSE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                                   second_file->data(),
-                                   second_file->data_size()));
-
-  source.EndOfStream();
-
-  base::RunLoop().Run();
-  EXPECT_EQ(CHUNK_DEMUXER_ERROR_APPEND_FAILED, 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(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
-  source.Shutdown();
-}
-
-// Config changes from clear to encrypted are not currently supported.
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(MediaSource_ConfigChange_EncryptedThenClear_WebM)) {
-  MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-640x360.webm");
-
-  ASSERT_FALSE(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(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
-  source.Shutdown();
-}
-
 #if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_ANDROID)
-TEST_F(PipelineIntegrationTest, BasicPlaybackHi10PVP9) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackHi10PVP9) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x180-hi10p-vp9.webm", kClockless));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackHi12PVP9) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackHi12PVP9) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x180-hi12p-vp9.webm", kClockless));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 #endif
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackHi10P) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackHi10P) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x180-hi10p.mp4", kClockless));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, BasicFallback) {
+TEST_P(CommonPipelineIntegrationTest, BasicFallback) {
   ScopedVector<VideoDecoder> failing_video_decoder;
   failing_video_decoder.push_back(new FailingVideoDecoder());
 
   ASSERT_EQ(PIPELINE_OK,
             Start("bear.mp4", kClockless, std::move(failing_video_decoder)));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 };
 
-TEST_F(PipelineIntegrationTest, MediaSource_ADTS) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_ADTS) {
   MockMediaSource source("sfx.adts", kADTS, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, 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());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, MediaSource_ADTS_TimestampOffset) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_ADTS_TimestampOffset) {
   MockMediaSource source("sfx.adts", kADTS, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK,
             StartPipelineWithMediaSource(&source, kHashed, nullptr));
   EXPECT_EQ(325, source.last_timestamp_offset().InMilliseconds());
 
   // Trim off multiple frames off the beginning of the segment which will cause
   // the first decoded frame to be incorrect if preroll isn't implemented.
   const base::TimeDelta adts_preroll_duration =
       base::TimeDelta::FromSecondsD(2.5 * 1024 / 44100);
   const base::TimeDelta append_time =
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(592, source.last_timestamp_offset().InMilliseconds());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(592, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   // Verify preroll is stripped.
   EXPECT_HASH_EQ("-0.25,0.67,0.04,0.14,-0.49,-0.41,", GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlaybackHashed_MP3) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackHashed_MP3) {
   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,
-      public testing::WithParamInterface<Mp3FastSeekParams> {};
-
-TEST_P(Mp3FastSeekIntegrationTest, FastSeekAccuracy_MP3) {
-  Mp3FastSeekParams config = GetParam();
-  ASSERT_EQ(PIPELINE_OK, Start(config.filename, kHashed));
-
-  // The XING TOC is inaccurate. We don't use it for CBR, we tolerate it for VBR
-  // (best option for fast seeking; see Mp3SeekFFmpegDemuxerTest). The chosen
-  // seek time exposes inaccuracy in TOC such that the hash will change if seek
-  // logic is regressed. See https://crbug.com/545914.
-  //
-  // Quick TOC design (not pretty!):
-  // - All MP3 TOCs are 100 bytes
-  // - Each byte is read as a uint8_t; value between 0 - 255.
-  // - The index into this array is the numerator in the ratio: index / 100.
-  //   This fraction represents a playback time as a percentage of duration.
-  // - The value at the given index is the numerator in the ratio: value / 256.
-  //   This fraction represents a byte offset as a percentage of the file size.
-  //
-  // For CBR files, each frame is the same size, so the offset for time of
-  // (0.98 * duration) should be around (0.98 * file size). This is 250.88 / 256
-  // but the numerator will be truncated in the TOC as 250, losing precision.
-  base::TimeDelta seek_time(0.98 * pipeline_->GetMediaDuration());
-
-  ASSERT_TRUE(Seek(seek_time));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-
-  EXPECT_HASH_EQ(config.hash, GetAudioHash());
-}
-
-// TODO(CHCUNNINGHAM): Re-enable for OSX once 1% flakiness is root caused.
-// See http://crbug.com/571898
-#if !defined(OS_MACOSX)
-// CBR seeks should always be fast and accurate.
-INSTANTIATE_TEST_CASE_P(
-    CBRSeek_HasTOC,
-    Mp3FastSeekIntegrationTest,
-    ::testing::Values(Mp3FastSeekParams("bear-audio-10s-CBR-has-TOC.mp3",
-                                        "-0.71,0.36,2.96,2.68,2.10,-1.08,")));
-#endif
-
-INSTANTIATE_TEST_CASE_P(
-    CBRSeeks_NoTOC,
-    Mp3FastSeekIntegrationTest,
-    ::testing::Values(Mp3FastSeekParams("bear-audio-10s-CBR-no-TOC.mp3",
-                                        "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_HasTOC,
-    Mp3FastSeekIntegrationTest,
-    ::testing::Values(Mp3FastSeekParams("bear-audio-10s-VBR-has-TOC.mp3",
-                                        "-0.15,-0.83,0.54,1.00,1.94,0.93,")));
-
-INSTANTIATE_TEST_CASE_P(
-    VBRSeeks_NoTOC,
-    Mp3FastSeekIntegrationTest,
-    ::testing::Values(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) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_MP3) {
   MockMediaSource source("sfx.mp3", kMP3, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK,
             StartPipelineWithMediaSource(&source, kHashed, nullptr));
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(313, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
 
   // Verify that codec delay was stripped.
   EXPECT_HASH_EQ("1.01,2.71,4.18,4.32,3.04,1.12,", GetAudioHash());
 }
 
-TEST_F(PipelineIntegrationTest, MediaSource_MP3_TimestampOffset) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_MP3_TimestampOffset) {
   MockMediaSource source("sfx.mp3", kMP3, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   EXPECT_EQ(313, source.last_timestamp_offset().InMilliseconds());
 
   // There are 576 silent frames at the start of this mp3.  The second append
   // should trim them off.
   const base::TimeDelta mp3_preroll_duration =
       base::TimeDelta::FromSecondsD(576.0 / 44100);
   const base::TimeDelta append_time =
       source.last_timestamp_offset() - mp3_preroll_duration;
 
   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.mp3");
   source.AppendAtTimeWithWindow(append_time, append_time + mp3_preroll_duration,
                                 kInfiniteDuration, second_file->data(),
                                 second_file->data_size());
   source.EndOfStream();
 
   Play();
   EXPECT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(613, source.last_timestamp_offset().InMilliseconds());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(613, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 }
 
-TEST_F(PipelineIntegrationTest, MediaSource_MP3_Icecast) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_MP3_Icecast) {
   MockMediaSource source("icy_sfx.mp3", kMP3, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_MP4) {
+TEST_P(CommonPipelineIntegrationTest, MediaSource_ConfigChange_MP4) {
   MockMediaSource source("bear-640x360-av_frag.mp4", kMP4, kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
 
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-1280x720-av_frag.mp4");
   ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                                   second_file->data(),
                                   second_file->data_size()));
   source.EndOfStream();
 
   Play();
   EXPECT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   source.Shutdown();
   Stop();
 }
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly)) {
-  MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
-  ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                                  second_file->data(),
-                                  second_file->data_size()));
-  source.EndOfStream();
-
-  Play();
-  EXPECT_TRUE(WaitUntilOnEnded());
-
-  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
-  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
-  EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
-            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
-
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(
-           MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly)) {
-  MockMediaSource source("bear-640x360-v_frag-cenc-key_rotation.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-1280x720-v_frag-cenc-key_rotation.mp4");
-  ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                                  second_file->data(),
-                                  second_file->data_size()));
-  source.EndOfStream();
-
-  Play();
-  EXPECT_TRUE(WaitUntilOnEnded());
-
-  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
-  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
-  EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
-            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
-
-  source.Shutdown();
-  Stop();
-}
-
-// Config changes from clear to encrypted are not currently supported.
-// TODO(ddorwin): Figure out why this CHECKs in AppendAtTime().
-TEST_F(PipelineIntegrationTest,
-       DISABLED_MediaSource_ConfigChange_ClearThenEncrypted_MP4_CENC) {
-  MockMediaSource source("bear-640x360-av_frag.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
-  ASSERT_FALSE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
-                                   second_file->data(),
-                                   second_file->data_size()));
-
-  source.EndOfStream();
-
-  base::RunLoop().Run();
-  EXPECT_EQ(CHUNK_DEMUXER_ERROR_APPEND_FAILED, 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(k640IsoFileDurationMs,
-            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
-
-  Play();
-
-  EXPECT_EQ(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
-  source.Shutdown();
-}
-
-// Config changes from encrypted to clear are not currently supported.
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC)) {
-  MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  scoped_refptr<DecoderBuffer> second_file =
-      ReadTestDataFile("bear-1280x720-av_frag.mp4");
-
-  ASSERT_FALSE(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(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
-  source.Shutdown();
-}
-
-// 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  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_16x9AspectRatio) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_16x9AspectRatio) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-16x9-aspect.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, MAYBE_EME(EncryptedPlayback_WebM)) {
-  MockMediaSource source("bear-320x240-av_enc-av.webm", kWebM, 219816);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest, MAYBE_EME(EncryptedPlayback_ClearStart_WebM)) {
-  MockMediaSource source("bear-320x240-av_enc-av_clear-1s.webm", kWebM,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_WebM)) {
-  MockMediaSource source("bear-320x240-av_enc-av_clear-all.webm", kWebM,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new NoResponseApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_CENC_VideoOnly)) {
-  MockMediaSource source("bear-1280x720-v_frag-cenc.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_CENC_AudioOnly)) {
-  MockMediaSource source("bear-1280x720-a_frag-cenc.mp4", kMP4Audio,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly)) {
-  MockMediaSource source("bear-1280x720-v_frag-cenc_clear-all.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new NoResponseApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest, Mp2ts_AAC_HE_SBR_Audio) {
+TEST_P(CommonPipelineIntegrationTest, Mp2ts_AAC_HE_SBR_Audio) {
   MockMediaSource source("bear-1280x720-aac_he.ts", kMP2AudioSBR,
                          kAppendWholeFile);
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   // Check that SBR is taken into account correctly by mpeg2ts parser. When an
   // SBR stream is parsed as non-SBR stream, then audio frame durations are
   // calculated incorrectly and that leads to gaps in buffered ranges (so this
   // check will fail) and eventually leads to stalled playback.
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 #else
   EXPECT_EQ(
       DEMUXER_ERROR_COULD_NOT_OPEN,
       StartPipelineWithMediaSource(&source, kExpectDemuxerFailure, nullptr));
 #endif
 }
 
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly)) {
-  MockMediaSource source("bear-1280x720-a_frag-cenc_clear-all.mp4", kMP4Audio,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new NoResponseApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_CENC_SENC_Video)) {
-  MockMediaSource source("bear-640x360-v_frag-cenc-senc.mp4", kMP4Video,
-                         kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-// 'SAIZ' and 'SAIO' boxes contain redundant information which is already
-// available in 'SENC' box. Although 'SAIZ' and 'SAIO' boxes are required per
-// CENC spec for backward compatibility reasons, but we do not use the two
-// boxes if 'SENC' box is present, so the code should work even if the two
-// boxes are not present.
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_CENC_SENC_NO_SAIZ_SAIO_Video)) {
-  MockMediaSource source("bear-640x360-v_frag-cenc-senc-no-saiz-saio.mp4",
-                         kMP4Video, kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_CENC_KeyRotation_Video)) {
-  MockMediaSource source("bear-1280x720-v_frag-cenc-key_rotation.mp4",
-                         kMP4Video, kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_CENC_KeyRotation_Audio)) {
-  MockMediaSource source("bear-1280x720-a_frag-cenc-key_rotation.mp4",
-                         kMP4Audio, kAppendWholeFile);
-  FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest,
-       MAYBE_EME(EncryptedPlayback_MP4_VP9_CENC_VideoOnly)) {
-  MockMediaSource source("bear-320x240-v_frag-vp9-cenc.mp4", kMP4VideoVP9,
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlayback_MediaSource_VideoOnly_MP4_AVC3) {
+  MockMediaSource source("bear-1280x720-v_frag-avc3.mp4", kMP4VideoAVC3,
+                         kAppendWholeFile);
+  EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
+  source.EndOfStream();
+
+  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
+  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
+  EXPECT_EQ(k1280IsoAVC3FileDurationMs,
+            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlayback_MediaSource_VideoOnly_MP4_VP9) {
+  MockMediaSource source("bear-320x240-v_frag-vp9.mp4", kMP4VideoVP9,
                          kAppendWholeFile);
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableVp9InMp4)) {
     ASSERT_EQ(ChunkDemuxer::kNotSupported, source.AddId());
     return;
   }
 
-  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  EXPECT_EQ(PIPELINE_OK,
-            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
-
-  source.EndOfStream();
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_AVC3) {
-  MockMediaSource source("bear-1280x720-v_frag-avc3.mp4", kMP4VideoAVC3,
-                         kAppendWholeFile);
   EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
   source.EndOfStream();
-
-  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
-  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
-  EXPECT_EQ(k1280IsoAVC3FileDurationMs,
-            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
-
-  Play();
-
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-}
-
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_VP9) {
-  MockMediaSource source("bear-320x240-v_frag-vp9.mp4", kMP4VideoVP9,
-                         kAppendWholeFile);
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableVp9InMp4)) {
-    ASSERT_EQ(ChunkDemuxer::kNotSupported, source.AddId());
-    return;
-  }
-
-  EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
-  source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_HEVC1) {
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlayback_MediaSource_VideoOnly_MP4_HEVC1) {
   // HEVC demuxing might be enabled even on platforms that don't support HEVC
   // decoding. For those cases we'll get DECODER_ERROR_NOT_SUPPORTED, which
   // indicates indicates that we did pass media mime type checks and attempted
   // to actually demux and decode the stream. On platforms that support both
   // demuxing and decoding we'll get PIPELINE_OK.
   MockMediaSource source("bear-320x240-v_frag-hevc.mp4", kMP4VideoHEVC1,
                          kAppendWholeFile);
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   PipelineStatus status = StartPipelineWithMediaSource(&source);
   EXPECT_TRUE(status == PIPELINE_OK || status == DECODER_ERROR_NOT_SUPPORTED);
 #else
   EXPECT_EQ(
       DEMUXER_ERROR_COULD_NOT_OPEN,
       StartPipelineWithMediaSource(&source, kExpectDemuxerFailure, nullptr));
 #endif
 }
 
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_HEVC2) {
+TEST_P(CommonPipelineIntegrationTest,
+       BasicPlayback_MediaSource_VideoOnly_MP4_HEVC2) {
   // HEVC demuxing might be enabled even on platforms that don't support HEVC
   // decoding. For those cases we'll get DECODER_ERROR_NOT_SUPPORTED, which
   // indicates indicates that we did pass media mime type checks and attempted
   // to actually demux and decode the stream. On platforms that support both
   // demuxing and decoding we'll get PIPELINE_OK.
   MockMediaSource source("bear-320x240-v_frag-hevc.mp4", kMP4VideoHEVC2,
                          kAppendWholeFile);
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   PipelineStatus status = StartPipelineWithMediaSource(&source);
   EXPECT_TRUE(status == PIPELINE_OK || status == DECODER_ERROR_NOT_SUPPORTED);
 #else
   EXPECT_EQ(
       DEMUXER_ERROR_COULD_NOT_OPEN,
       StartPipelineWithMediaSource(&source, kExpectDemuxerFailure, nullptr));
 #endif
 }
 
 #endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 
-TEST_F(PipelineIntegrationTest, SeekWhilePaused) {
+TEST_P(CommonPipelineIntegrationTest, SeekWhilePaused) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
   Pause();
   ASSERT_TRUE(Seek(seek_time));
   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 
   // Make sure seeking after reaching the end works as expected.
   Pause();
   ASSERT_TRUE(Seek(seek_time));
   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, SeekWhilePlaying) {
+TEST_P(CommonPipelineIntegrationTest, SeekWhilePlaying) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
   ASSERT_TRUE(Seek(seek_time));
   EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
   ASSERT_TRUE(WaitUntilOnEnded());
 
   // Make sure seeking after reaching the end works as expected.
   ASSERT_TRUE(Seek(seek_time));
   EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, SuspendWhilePaused) {
+TEST_P(CommonPipelineIntegrationTest, SuspendWhilePaused) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
   Pause();
 
   // Suspend while paused.
   ASSERT_TRUE(Suspend());
 
   // Resuming the pipeline will create a new Renderer,
   // which in turn will trigger video size and opacity notifications.
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(320, 240))).Times(1);
   EXPECT_CALL(*this, OnVideoOpacityChange(true)).Times(1);
 
   ASSERT_TRUE(Resume(seek_time));
   EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-TEST_F(PipelineIntegrationTest, SuspendWhilePlaying) {
+TEST_P(CommonPipelineIntegrationTest, SuspendWhilePlaying) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
   ASSERT_TRUE(Suspend());
 
   // Resuming the pipeline will create a new Renderer,
   // which in turn will trigger video size and opacity notifications.
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(320, 240))).Times(1);
   EXPECT_CALL(*this, OnVideoOpacityChange(true)).Times(1);
 
   ASSERT_TRUE(Resume(seek_time));
   EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
-TEST_F(PipelineIntegrationTest, Rotated_Metadata_0) {
+TEST_P(CommonPipelineIntegrationTest, Rotated_Metadata_0) {
   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_0.mp4"));
   ASSERT_EQ(VIDEO_ROTATION_0, metadata_.video_rotation);
 }
 
-TEST_F(PipelineIntegrationTest, Rotated_Metadata_90) {
+TEST_P(CommonPipelineIntegrationTest, Rotated_Metadata_90) {
   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_90.mp4"));
   ASSERT_EQ(VIDEO_ROTATION_90, metadata_.video_rotation);
 }
 
-TEST_F(PipelineIntegrationTest, Rotated_Metadata_180) {
+TEST_P(CommonPipelineIntegrationTest, 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) {
+TEST_P(CommonPipelineIntegrationTest, Rotated_Metadata_270) {
   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_270.mp4"));
   ASSERT_EQ(VIDEO_ROTATION_270, metadata_.video_rotation);
 }
 #endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 
 // Verify audio decoder & renderer can handle aborted demuxer reads.
-TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
+TEST_P(CommonPipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-audio-only.webm", kAudioOnlyWebM,
                                  16384, base::TimeDelta::FromMilliseconds(464),
                                  base::TimeDelta::FromMilliseconds(617), 0x10CA,
                                  19730));
 }
 
 // Verify video decoder & renderer can handle aborted demuxer reads.
-TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
+TEST_P(CommonPipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", kVideoOnlyWebM,
                                  32768, base::TimeDelta::FromMilliseconds(167),
                                  base::TimeDelta::FromMilliseconds(1668),
                                  0x1C896, 65536));
 }
 
 // Verify that Opus audio in WebM containers can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_AudioOnly_Opus_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_AudioOnly_Opus_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-opus-end-trimming.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // Verify that VP9 video in WebM containers can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VideoOnly_VP9_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VideoOnly_VP9_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // Verify that VP9 video and Opus audio in the same WebM container can be played
 // back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VP9_Opus_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VP9_Opus_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9-opus.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // Verify that VP8 video with alpha channel can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VP8A_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VP8A_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp8a.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV12A);
 }
 
 // Verify that VP8A video with odd width/height can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VP8A_Odd_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VP8A_Odd_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp8a-odd-dimensions.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV12A);
 }
 
 // Verify that VP9 video with odd width/height can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VP9_Odd_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VP9_Odd_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9-odd-dimensions.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // Verify that VP9 video with alpha channel can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VP9A_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VP9A_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9a.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV12A);
 }
 
 // Verify that VP9A video with odd width/height can be played back.
-TEST_F(PipelineIntegrationTest, BasicPlayback_VP9A_Odd_WebM) {
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_VP9A_Odd_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9a-odd-dimensions.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV12A);
 }
 
+// Verify that VP9 video with 4:4:4 subsampling can be played back.
+TEST_P(CommonPipelineIntegrationTest, P444_VP9_WebM) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-P444.webm"));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+  EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV24);
+}
+
+// Verify that frames of VP9 video in the BT.709 color space have the YV12HD
+// format.
+TEST_P(CommonPipelineIntegrationTest, BT709_VP9_WebM) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear-vp9-bt709.webm"));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+  EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV12);
+  EXPECT_COLOR_SPACE_EQ(last_video_frame_color_space_, COLOR_SPACE_HD_REC709);
+}
+
+TEST_P(CommonPipelineIntegrationTest, HD_VP9_WebM) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear-1280x720.webm", kClockless));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+}
+
+// Verify that videos with an odd frame size playback successfully.
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_OddVideoSize) {
+  ASSERT_EQ(PIPELINE_OK, Start("butterfly-853x480.webm"));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+}
+
+// Verify that OPUS audio in a webm which reports a 44.1kHz sample rate plays
+// correctly at 48kHz
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_Opus441kHz) {
+  ASSERT_EQ(PIPELINE_OK, Start("sfx-opus-441.webm"));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+  EXPECT_EQ(48000, demuxer_->GetStream(DemuxerStream::AUDIO)
+                       ->audio_decoder_config()
+                       .samples_per_second());
+}
+
+// Same as above but using MediaSource.
+TEST_P(CommonPipelineIntegrationTest, BasicPlayback_MediaSource_Opus441kHz) {
+  MockMediaSource source("sfx-opus-441.webm", kOpusAudioOnlyWebM,
+                         kAppendWholeFile);
+  EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
+  source.EndOfStream();
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+  EXPECT_EQ(48000, demuxer_->GetStream(DemuxerStream::AUDIO)
+                       ->audio_decoder_config()
+                       .samples_per_second());
+}
+
+// Ensures audio-only playback with missing or negative timestamps works.  Tests
+// the common live-streaming case for chained ogg.  See http://crbug.com/396864.
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackChainedOgg) {
+  ASSERT_EQ(PIPELINE_OK, Start("double-sfx.ogg", kUnreliableDuration));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+  ASSERT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
+}
+
+// Tests that we signal ended even when audio runs longer than video track.
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackAudioLongerThanVideo) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear_audio_longer_than_video.ogv"));
+  // Audio track is 2000ms. Video track is 1001ms. Duration should be higher
+  // of the two.
+  EXPECT_EQ(2000, pipeline_->GetMediaDuration().InMilliseconds());
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+}
+
+// Tests that we signal ended even when audio runs shorter than video track.
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackAudioShorterThanVideo) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear_audio_shorter_than_video.ogv"));
+  // Audio track is 500ms. Video track is 1001ms. Duration should be higher of
+  // the two.
+  EXPECT_EQ(1001, pipeline_->GetMediaDuration().InMilliseconds());
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+}
+
+TEST_P(CommonPipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
+  ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+  ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
+            demuxer_->GetStartTime());
+}
+
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+const IntegrationTestData kIntegrationTests[] = {{PipelineType::Media},
+                                                 {PipelineType::MediaRemoting}};
+#else
+const IntegrationTestData kIntegrationTests[] = {{PipelineType::Media}};

[miu, 2017/03/29 01:39:14]

const IntegrationTestData kIntegrationTests[] = {
    {PipelineType::Media},
#if BUILDFLAG(ENABLE_MEDIA_REMOTING)
    {PipelineType::MediaRemoting},
#endif
};

[xjz, 2017/03/30 23:21:31]

Done.

+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING) && !defined(MOJO_RENDERER)
+
+INSTANTIATE_TEST_CASE_P(,
+                        CommonPipelineIntegrationTest,
+                        testing::ValuesIn(kIntegrationTests));
+
+TEST_F(PipelineIntegrationTest, MAYBE_EME(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();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(MediaSource_ConfigChange_Encrypted_WebM)) {
+  MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(640, 360))).Times(1);
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-640x360-av_enc-av.webm");
+  ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
+                                  second_file->data(),
+                                  second_file->data_size()));
+  source.EndOfStream();
+
+  Play();
+  EXPECT_TRUE(WaitUntilOnEnded());
+
+  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
+  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
+  EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
+            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
+
+  source.Shutdown();
+  Stop();
+}
+
+// Config changes from encrypted to clear are not currently supported.
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(MediaSource_ConfigChange_ClearThenEncrypted_WebM)) {
+  MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-640x360-av_enc-av.webm");
+
+  ASSERT_FALSE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
+                                   second_file->data(),
+                                   second_file->data_size()));
+
+  source.EndOfStream();
+
+  base::RunLoop().Run();
+  EXPECT_EQ(CHUNK_DEMUXER_ERROR_APPEND_FAILED, 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(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
+  source.Shutdown();
+}
+
+// Config changes from clear to encrypted are not currently supported.
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(MediaSource_ConfigChange_EncryptedThenClear_WebM)) {
+  MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-640x360.webm");
+
+  ASSERT_FALSE(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(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
+  source.Shutdown();
+}
+
+#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+#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,
+      public testing::WithParamInterface<Mp3FastSeekParams> {};
+
+TEST_P(Mp3FastSeekIntegrationTest, FastSeekAccuracy_MP3) {
+  Mp3FastSeekParams config = GetParam();
+  ASSERT_EQ(PIPELINE_OK, Start(config.filename, kHashed));
+
+  // The XING TOC is inaccurate. We don't use it for CBR, we tolerate it for VBR
+  // (best option for fast seeking; see Mp3SeekFFmpegDemuxerTest). The chosen
+  // seek time exposes inaccuracy in TOC such that the hash will change if seek
+  // logic is regressed. See https://crbug.com/545914.
+  //
+  // Quick TOC design (not pretty!):
+  // - All MP3 TOCs are 100 bytes
+  // - Each byte is read as a uint8_t; value between 0 - 255.
+  // - The index into this array is the numerator in the ratio: index / 100.
+  //   This fraction represents a playback time as a percentage of duration.
+  // - The value at the given index is the numerator in the ratio: value / 256.
+  //   This fraction represents a byte offset as a percentage of the file size.
+  //
+  // For CBR files, each frame is the same size, so the offset for time of
+  // (0.98 * duration) should be around (0.98 * file size). This is 250.88 / 256
+  // but the numerator will be truncated in the TOC as 250, losing precision.
+  base::TimeDelta seek_time(0.98 * pipeline_->GetMediaDuration());
+
+  ASSERT_TRUE(Seek(seek_time));
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+
+  EXPECT_HASH_EQ(config.hash, GetAudioHash());
+}
+
+// TODO(CHCUNNINGHAM): Re-enable for OSX once 1% flakiness is root caused.
+// See http://crbug.com/571898
+#if !defined(OS_MACOSX)
+// CBR seeks should always be fast and accurate.
+INSTANTIATE_TEST_CASE_P(
+    CBRSeek_HasTOC,
+    Mp3FastSeekIntegrationTest,
+    ::testing::Values(Mp3FastSeekParams("bear-audio-10s-CBR-has-TOC.mp3",
+                                        "-0.71,0.36,2.96,2.68,2.10,-1.08,")));
+#endif
+
+INSTANTIATE_TEST_CASE_P(
+    CBRSeeks_NoTOC,
+    Mp3FastSeekIntegrationTest,
+    ::testing::Values(Mp3FastSeekParams("bear-audio-10s-CBR-no-TOC.mp3",
+                                        "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_HasTOC,
+    Mp3FastSeekIntegrationTest,
+    ::testing::Values(Mp3FastSeekParams("bear-audio-10s-VBR-has-TOC.mp3",
+                                        "-0.15,-0.83,0.54,1.00,1.94,0.93,")));
+INSTANTIATE_TEST_CASE_P(
+    VBRSeeks_NoTOC,
+    Mp3FastSeekIntegrationTest,
+    ::testing::Values(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,
+       MAYBE_EME(MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly)) {
+  MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
+  ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
+                                  second_file->data(),
+                                  second_file->data_size()));
+  source.EndOfStream();
+
+  Play();
+  EXPECT_TRUE(WaitUntilOnEnded());
+
+  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
+  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
+  EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
+            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
+
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(
+           MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly)) {
+  MockMediaSource source("bear-640x360-v_frag-cenc-key_rotation.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-1280x720-v_frag-cenc-key_rotation.mp4");
+  ASSERT_TRUE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
+                                  second_file->data(),
+                                  second_file->data_size()));
+  source.EndOfStream();
+
+  Play();
+  EXPECT_TRUE(WaitUntilOnEnded());
+
+  EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
+  EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
+  EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
+            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
+
+  source.Shutdown();
+  Stop();
+}
+
+// Config changes from clear to encrypted are not currently supported.
+// TODO(ddorwin): Figure out why this CHECKs in AppendAtTime().
+TEST_F(PipelineIntegrationTest,
+       DISABLED_MediaSource_ConfigChange_ClearThenEncrypted_MP4_CENC) {
+  MockMediaSource source("bear-640x360-av_frag.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(1280, 720))).Times(1);
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
+  ASSERT_FALSE(source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
+                                   second_file->data(),
+                                   second_file->data_size()));
+
+  source.EndOfStream();
+
+  base::RunLoop().Run();
+  EXPECT_EQ(CHUNK_DEMUXER_ERROR_APPEND_FAILED, 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(k640IsoFileDurationMs,
+            pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
+
+  Play();
+
+  EXPECT_EQ(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
+  source.Shutdown();
+}
+
+// Config changes from encrypted to clear are not currently supported.
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC)) {
+  MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  scoped_refptr<DecoderBuffer> second_file =
+      ReadTestDataFile("bear-1280x720-av_frag.mp4");
+
+  ASSERT_FALSE(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(CHUNK_DEMUXER_ERROR_APPEND_FAILED, WaitUntilEndedOrError());
+  source.Shutdown();
+}
+
+// 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  // BUILDFLAG(USE_PROPRIETARY_CODECS)
+
+TEST_F(PipelineIntegrationTest, MAYBE_EME(EncryptedPlayback_WebM)) {
+  MockMediaSource source("bear-320x240-av_enc-av.webm", kWebM, 219816);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest, MAYBE_EME(EncryptedPlayback_ClearStart_WebM)) {
+  MockMediaSource source("bear-320x240-av_enc-av_clear-1s.webm", kWebM,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_WebM)) {
+  MockMediaSource source("bear-320x240-av_enc-av_clear-all.webm", kWebM,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new NoResponseApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_CENC_VideoOnly)) {
+  MockMediaSource source("bear-1280x720-v_frag-cenc.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_CENC_AudioOnly)) {
+  MockMediaSource source("bear-1280x720-a_frag-cenc.mp4", kMP4Audio,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+  ASSERT_EQ(PIPELINE_OK, pipeline_status_);
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly)) {
+  MockMediaSource source("bear-1280x720-v_frag-cenc_clear-all.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new NoResponseApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly)) {
+  MockMediaSource source("bear-1280x720-a_frag-cenc_clear-all.mp4", kMP4Audio,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new NoResponseApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_CENC_SENC_Video)) {
+  MockMediaSource source("bear-640x360-v_frag-cenc-senc.mp4", kMP4Video,
+                         kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+// 'SAIZ' and 'SAIO' boxes contain redundant information which is already
+// available in 'SENC' box. Although 'SAIZ' and 'SAIO' boxes are required per
+// CENC spec for backward compatibility reasons, but we do not use the two
+// boxes if 'SENC' box is present, so the code should work even if the two
+// boxes are not present.
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_CENC_SENC_NO_SAIZ_SAIO_Video)) {
+  MockMediaSource source("bear-640x360-v_frag-cenc-senc-no-saiz-saio.mp4",
+                         kMP4Video, kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_CENC_KeyRotation_Video)) {
+  MockMediaSource source("bear-1280x720-v_frag-cenc-key_rotation.mp4",
+                         kMP4Video, kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_CENC_KeyRotation_Audio)) {
+  MockMediaSource source("bear-1280x720-a_frag-cenc-key_rotation.mp4",
+                         kMP4Audio, kAppendWholeFile);
+  FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+TEST_F(PipelineIntegrationTest,
+       MAYBE_EME(EncryptedPlayback_MP4_VP9_CENC_VideoOnly)) {
+  MockMediaSource source("bear-320x240-v_frag-vp9-cenc.mp4", kMP4VideoVP9,
+                         kAppendWholeFile);
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableVp9InMp4)) {
+    ASSERT_EQ(ChunkDemuxer::kNotSupported, source.AddId());
+    return;
+  }
+
+  FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
+  EXPECT_EQ(PIPELINE_OK,
+            StartPipelineWithEncryptedMedia(&source, &encrypted_media));
+
+  source.EndOfStream();
+
+  Play();
+
+  ASSERT_TRUE(WaitUntilOnEnded());
+  source.Shutdown();
+  Stop();
+}
+
+#endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
+
 // Verify that VP8 video with inband text track can be played back.
 TEST_F(PipelineIntegrationTest, MAYBE_TEXT(BasicPlayback_VP8_WebVTT_WebM)) {
   EXPECT_CALL(*this, OnAddTextTrack(_, _));
   ASSERT_EQ(PIPELINE_OK, Start("bear-vp8-webvtt.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
-// Verify that VP9 video with 4:4:4 subsampling can be played back.
-TEST_F(PipelineIntegrationTest, P444_VP9_WebM) {
-  ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-P444.webm"));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-  EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV24);
-}
-
-// Verify that frames of VP9 video in the BT.709 color space have the YV12HD
-// format.
-TEST_F(PipelineIntegrationTest, BT709_VP9_WebM) {
-  ASSERT_EQ(PIPELINE_OK, Start("bear-vp9-bt709.webm"));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-  EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, PIXEL_FORMAT_YV12);
-  EXPECT_COLOR_SPACE_EQ(last_video_frame_color_space_, COLOR_SPACE_HD_REC709);
-}
-
-TEST_F(PipelineIntegrationTest, HD_VP9_WebM) {
-  ASSERT_EQ(PIPELINE_OK, Start("bear-1280x720.webm", kClockless));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-}
-
-// Verify that videos with an odd frame size playback successfully.
-TEST_F(PipelineIntegrationTest, BasicPlayback_OddVideoSize) {
-  ASSERT_EQ(PIPELINE_OK, Start("butterfly-853x480.webm"));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-}
-
-// Verify that OPUS audio in a webm which reports a 44.1kHz sample rate plays
-// correctly at 48kHz
-TEST_F(PipelineIntegrationTest, BasicPlayback_Opus441kHz) {
-  ASSERT_EQ(PIPELINE_OK, Start("sfx-opus-441.webm"));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-  EXPECT_EQ(48000, demuxer_->GetStream(DemuxerStream::AUDIO)
-                       ->audio_decoder_config()
-                       .samples_per_second());
-}
-
-// Same as above but using MediaSource.
-TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Opus441kHz) {
-  MockMediaSource source("sfx-opus-441.webm", kOpusAudioOnlyWebM,
-                         kAppendWholeFile);
-  EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
-  source.EndOfStream();
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-  source.Shutdown();
-  Stop();
-  EXPECT_EQ(48000, demuxer_->GetStream(DemuxerStream::AUDIO)
-                       ->audio_decoder_config()
-                       .samples_per_second());
-}
-
-// Ensures audio-only playback with missing or negative timestamps works.  Tests
-// the common live-streaming case for chained ogg.  See http://crbug.com/396864.
-TEST_F(PipelineIntegrationTest, BasicPlaybackChainedOgg) {
-  ASSERT_EQ(PIPELINE_OK, Start("double-sfx.ogg", kUnreliableDuration));
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-  ASSERT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
-}
-
 // Ensures audio-video playback with missing or negative timestamps fails softly
 // instead of crashing.  See http://crbug.com/396864.
 TEST_F(PipelineIntegrationTest, BasicPlaybackChainedOggVideo) {
   ASSERT_EQ(PIPELINE_OK, Start("double-bear.ogv", kUnreliableDuration));
   Play();
   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
   ASSERT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 }
 
-// Tests that we signal ended even when audio runs longer than video track.
-TEST_F(PipelineIntegrationTest, BasicPlaybackAudioLongerThanVideo) {
-  ASSERT_EQ(PIPELINE_OK, Start("bear_audio_longer_than_video.ogv"));
-  // Audio track is 2000ms. Video track is 1001ms. Duration should be higher
-  // of the two.
-  EXPECT_EQ(2000, pipeline_->GetMediaDuration().InMilliseconds());
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-}
-
-// Tests that we signal ended even when audio runs shorter than video track.
-TEST_F(PipelineIntegrationTest, BasicPlaybackAudioShorterThanVideo) {
-  ASSERT_EQ(PIPELINE_OK, Start("bear_audio_shorter_than_video.ogv"));
-  // Audio track is 500ms. Video track is 1001ms. Duration should be higher of
-  // the two.
-  EXPECT_EQ(1001, pipeline_->GetMediaDuration().InMilliseconds());
-  Play();
-  ASSERT_TRUE(WaitUntilOnEnded());
-}
-
-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