Remove prefixed EME.

chrome/browser/media/encrypted_media_browsertest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 23 matching lines @@
     "clearkeycdmadapter.dll";
 #elif defined(OS_POSIX)
     "libclearkeycdmadapter.so";
 #endif
 
 const char kClearKeyCdmPluginMimeType[] = "application/x-ppapi-clearkey-cdm";
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 // Available key systems.
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
-const char kPrefixedClearKeyKeySystem[] = "webkit-org.w3.clearkey";
 const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
 const char kExternalClearKeyFileIOTestKeySystem[] =
     "org.chromium.externalclearkey.fileiotest";
 const char kExternalClearKeyInitializeFailKeySystem[] =
     "org.chromium.externalclearkey.initializefail";
 const char kExternalClearKeyCrashKeySystem[] =
     "org.chromium.externalclearkey.crash";
 
 // Supported media types.
 const char kWebMAudioOnly[] = "audio/webm; codecs=\"vorbis\"";
@@ skipping 12 matching lines @@
 
 // EME-specific test results and errors.
 const char kFileIOTestSuccess[] = "FILE_IO_TEST_SUCCESS";
 const char kEmeNotSupportedError[] = "NOTSUPPORTEDERROR";
 const char kEmeGenerateRequestFailed[] = "EME_GENERATEREQUEST_FAILED";
 const char kEmeSessionNotFound[] = "EME_SESSION_NOT_FOUND";
 const char kEmeLoadFailed[] = "EME_LOAD_FAILED";
 const char kEmeUpdateFailed[] = "EME_UPDATE_FAILED";
 const char kEmeErrorEvent[] = "EME_ERROR_EVENT";
 const char kEmeMessageUnexpectedType[] = "EME_MESSAGE_UNEXPECTED_TYPE";
-const char kPrefixedEmeRenewalMissingHeader[] =
-    "PREFIXED_EME_RENEWAL_MISSING_HEADER";
-const char kPrefixedEmeErrorEvent[] = "PREFIXED_EME_ERROR_EVENT";
+const char kEmeRenewalMissingHeader[] = "EME_RENEWAL_MISSING_HEADER";
 
 const char kDefaultEmePlayer[] = "eme_player.html";
 
 // The type of video src used to load media.
 enum SrcType {
   SRC,
   MSE
 };
 
-// Whether to use prefixed or unprefixed EME.
-enum EmeVersion {
-  PREFIXED,
-  UNPREFIXED
-};
-
 // Whether the video should be played once or twice.
 enum class PlayTwice { NO, YES };
 
 // Format of a container when testing different streams.
 enum class EncryptedContainer {
   CLEAR_WEBM,
   CLEAR_MP4,
   ENCRYPTED_WEBM,
   ENCRYPTED_MP4
 };
@@ skipping 47 matching lines @@
   // and trying to update it with licenses.
   // When |force_invalid_response| is true, the test will provide invalid
   // responses, which should trigger errors.
   // TODO(xhwang): Find an easier way to pass multiple configuration test
   // options.
   void RunEncryptedMediaTest(const std::string& html_page,
                              const std::string& media_file,
                              const std::string& media_type,
                              const std::string& key_system,
                              SrcType src_type,
-                             EmeVersion eme_version,
                              const std::string& session_to_load,
                              bool force_invalid_response,
                              PlayTwice play_twice,
                              const std::string& expected_title) {
     if (src_type == MSE && !IsMSESupported()) {
       DVLOG(0) << "Skipping test - MSE not supported.";
       return;
     }
     base::StringPairs query_params;
     query_params.push_back(std::make_pair("mediaFile", media_file));
     query_params.push_back(std::make_pair("mediaType", media_type));
     query_params.push_back(std::make_pair("keySystem", key_system));
     if (src_type == MSE)
       query_params.push_back(std::make_pair("useMSE", "1"));
-    if (eme_version == PREFIXED)
-      query_params.push_back(std::make_pair("usePrefixedEME", "1"));
     if (force_invalid_response)
       query_params.push_back(std::make_pair("forceInvalidResponse", "1"));
     if (!session_to_load.empty())
       query_params.push_back(std::make_pair("sessionToLoad", session_to_load));
     if (play_twice == PlayTwice::YES)
       query_params.push_back(std::make_pair("playTwice", "1"));
     RunEncryptedMediaTestPage(html_page, key_system, query_params,
                               expected_title);
   }
 
   void RunSimpleEncryptedMediaTest(const std::string& media_file,
                                    const std::string& media_type,
                                    const std::string& key_system,
-                                   SrcType src_type,
-                                   EmeVersion eme_version) {
+                                   SrcType src_type) {
     std::string expected_title = kEnded;
     if (!IsPlayBackPossible(key_system)) {
-      expected_title = (eme_version == EmeVersion::UNPREFIXED)
-                           ? kEmeUpdateFailed
-                           : kPrefixedEmeErrorEvent;
+      expected_title = kEmeUpdateFailed;
     }
 
     RunEncryptedMediaTest(kDefaultEmePlayer, media_file, media_type, key_system,
-                          src_type, eme_version, kNoSessionToLoad, false,
-                          PlayTwice::NO, expected_title);
+                          src_type, kNoSessionToLoad, false, PlayTwice::NO,
+                          expected_title);
     // Check KeyMessage received for all key systems.
     bool receivedKeyMessage = false;
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         browser()->tab_strip_model()->GetActiveWebContents(),
         "window.domAutomationController.send("
         "document.querySelector('video').receivedKeyMessage);",
         &receivedKeyMessage));
     EXPECT_TRUE(receivedKeyMessage);
   }
 
@@ skipping 39 matching lines @@
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeNotSupportedError));
     title_watcher->AlsoWaitForTitle(
         base::ASCIIToUTF16(kEmeGenerateRequestFailed));
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeSessionNotFound));
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeLoadFailed));
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeUpdateFailed));
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeErrorEvent));
     title_watcher->AlsoWaitForTitle(
         base::ASCIIToUTF16(kEmeMessageUnexpectedType));
     title_watcher->AlsoWaitForTitle(
-        base::ASCIIToUTF16(kPrefixedEmeRenewalMissingHeader));
-    title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kPrefixedEmeErrorEvent));
+        base::ASCIIToUTF16(kEmeRenewalMissingHeader));
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kDisableGestureRequirementForMediaPlayback);
-    // For simplicity with respect to parameterized tests, enable for all tests.
-    command_line->AppendSwitch(switches::kEnablePrefixedEncryptedMedia);
   }
 
   void SetUpCommandLineForKeySystem(const std::string& key_system,
                                     base::CommandLine* command_line) {
     if (GetServerConfig(key_system))
       // Since the web and license servers listen on different ports, we need to
       // disable web-security to send license requests to the license server.
       // TODO(shadi): Add port forwarding to the test web server configuration.
       command_line->AppendSwitch(switches::kDisableWebSecurity);
 
@@ skipping 55 matching lines @@
 // Tests encrypted media playback using ExternalClearKey key system in
 // decrypt-and-decode mode.
 class ECKEncryptedMediaTest : public EncryptedMediaTestBase {
  public:
   // We use special |key_system| names to do non-playback related tests, e.g.
   // kExternalClearKeyFileIOTestKeySystem is used to test file IO.
   void TestNonPlaybackCases(const std::string& key_system,
                             const std::string& expected_title) {
     // Since we do not test playback, arbitrarily choose a test file and source
     // type.
-    RunEncryptedMediaTest(
-        kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly, key_system, SRC,
-        UNPREFIXED, kNoSessionToLoad, false, PlayTwice::NO, expected_title);
+    RunEncryptedMediaTest(kDefaultEmePlayer, "bear-a_enc-a.webm",
+                          kWebMAudioOnly, key_system, SRC, kNoSessionToLoad,
+                          false, PlayTwice::NO, expected_title);
   }
 
   void TestPlaybackCase(const std::string& session_to_load,
                         const std::string& expected_title) {
     RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-v_enc-v.webm",
                           kWebMVideoOnly, kExternalClearKeyKeySystem, SRC,
-                          UNPREFIXED, session_to_load, false, PlayTwice::NO,
+                          session_to_load, false, PlayTwice::NO,
                           expected_title);
   }
 
- protected:
-  void SetUpCommandLine(base::CommandLine* command_line) override {
-    EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
-  }
-};
-
-// Tests encrypted media playback using ExternalClearKey key system in
-// decrypt-and-decode mode for prefixed EME.
-class ECKPrefixedEncryptedMediaTest : public EncryptedMediaTestBase {
- public:
-  // We use special |key_system| names to do non-playback related tests, e.g.
-  // kExternalClearKeyFileIOTestKeySystem is used to test file IO.
-  void TestNonPlaybackCases(const std::string& key_system,
-                            const std::string& expected_title) {
-    // Since we do not test playback, arbitrarily choose a test file and source
-    // type.
-    RunEncryptedMediaTest(
-        kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly, key_system, SRC,
-        PREFIXED, kNoSessionToLoad, false, PlayTwice::NO, expected_title);
-  }
-
-  void TestPlaybackCase(const std::string& session_to_load,
-                        const std::string& expected_title) {
-    RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-v_enc-v.webm",
-                          kWebMVideoOnly, kExternalClearKeyKeySystem, SRC,
-                          PREFIXED, session_to_load, false, PlayTwice::NO,
-                          expected_title);
-  }
-
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
     SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
   }
 };
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 // Tests encrypted media playback using Widevine key system.
 class WVEncryptedMediaTest : public EncryptedMediaTestBase {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
     SetUpCommandLineForKeySystem(kWidevineKeySystem, command_line);
   }
 };
 
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 // Tests encrypted media playback with a combination of parameters:
 // - char*: Key system name.
 // - SrcType: Use MSE or SRC.
-// - EmeVersion: Use PREFIXED or UNPREFIXED EME.
 //
 // Note: Only parameterized (*_P) tests can be used. Non-parameterized (*_F)
 // tests will crash at GetParam(). To add non-parameterized tests, use
 // EncryptedMediaTestBase or one of its subclasses (e.g. WVEncryptedMediaTest).
-class EncryptedMediaTest
-    : public EncryptedMediaTestBase,
-      public testing::WithParamInterface<
-          std::tr1::tuple<const char*, SrcType, EmeVersion> > {
+class EncryptedMediaTest : public EncryptedMediaTestBase,
+                           public testing::WithParamInterface<
+                               std::tr1::tuple<const char*, SrcType>> {
  public:
   std::string CurrentKeySystem() {
     return std::tr1::get<0>(GetParam());
   }
 
   SrcType CurrentSourceType() {
     return std::tr1::get<1>(GetParam());
   }
 
-  EmeVersion CurrentEmeVersion() {
-    return std::tr1::get<2>(GetParam());
-  }
-
   void TestSimplePlayback(const std::string& encrypted_media,
                           const std::string& media_type) {
-    RunSimpleEncryptedMediaTest(encrypted_media,
-                                media_type,
-                                CurrentKeySystem(),
-                                CurrentSourceType(),
-                                CurrentEmeVersion());
+    RunSimpleEncryptedMediaTest(encrypted_media, media_type, CurrentKeySystem(),
+                                CurrentSourceType());
   }
 
   void TestMultiplePlayback(const std::string& encrypted_media,
                             const std::string& media_type) {
     DCHECK(IsPlayBackPossible(CurrentKeySystem()));
     RunEncryptedMediaTest(kDefaultEmePlayer, encrypted_media, media_type,
                           CurrentKeySystem(), CurrentSourceType(),
-                          CurrentEmeVersion(), kNoSessionToLoad, false,
-                          PlayTwice::YES, kEnded);
+                          kNoSessionToLoad, false, PlayTwice::YES, kEnded);
   }
 
   void RunInvalidResponseTest() {
-    std::string expected_response =
-        (CurrentEmeVersion() == EmeVersion::UNPREFIXED)
-            ? kEmeUpdateFailed
-            : kPrefixedEmeErrorEvent;
-    RunEncryptedMediaTest(
-        kDefaultEmePlayer, "bear-320x240-av_enc-av.webm", kWebMAudioVideo,
-        CurrentKeySystem(), CurrentSourceType(), CurrentEmeVersion(),
-        kNoSessionToLoad, true, PlayTwice::NO, expected_response);
+    RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-av_enc-av.webm",
+                          kWebMAudioVideo, CurrentKeySystem(),
+                          CurrentSourceType(), kNoSessionToLoad, true,
+                          PlayTwice::NO, kEmeUpdateFailed);
   }
 
   void TestFrameSizeChange() {
-    RunEncryptedMediaTest(
-        "encrypted_frame_size_change.html", "frame_size_change-av_enc-v.webm",
-        kWebMAudioVideo, CurrentKeySystem(), CurrentSourceType(),
-        CurrentEmeVersion(), kNoSessionToLoad, false, PlayTwice::NO, kEnded);
+    RunEncryptedMediaTest("encrypted_frame_size_change.html",
+                          "frame_size_change-av_enc-v.webm", kWebMAudioVideo,
+                          CurrentKeySystem(), CurrentSourceType(),
+                          kNoSessionToLoad, false, PlayTwice::NO, kEnded);
   }
 
   void TestConfigChange() {
     DCHECK(IsMSESupported());
     base::StringPairs query_params;
     query_params.push_back(std::make_pair("keySystem", CurrentKeySystem()));
     query_params.push_back(std::make_pair("runEncrypted", "1"));
-    if (CurrentEmeVersion() == PREFIXED)
-      query_params.push_back(std::make_pair("usePrefixedEME", "1"));
     RunEncryptedMediaTestPage("mse_config_change.html",
                               CurrentKeySystem(),
                               query_params,
                               kEnded);
   }
 
   std::string ConvertContainerFormat(EncryptedContainer format) {
     switch (format) {
       case EncryptedContainer::CLEAR_MP4:
         return "CLEAR_MP4";
       case EncryptedContainer::CLEAR_WEBM:
         return "CLEAR_WEBM";
       case EncryptedContainer::ENCRYPTED_MP4:
         return "ENCRYPTED_MP4";
       case EncryptedContainer::ENCRYPTED_WEBM:
         return "ENCRYPTED_WEBM";
     }
     NOTREACHED();
     return "UNKNOWN";
   }
 
   void TestDifferentContainers(EncryptedContainer video_format,
                                EncryptedContainer audio_format) {
     DCHECK(IsMSESupported());
-    DCHECK_NE(CurrentEmeVersion(), PREFIXED);
     base::StringPairs query_params;
     query_params.push_back(std::make_pair("keySystem", CurrentKeySystem()));
     query_params.push_back(std::make_pair("runEncrypted", "1"));
     query_params.push_back(
         std::make_pair("videoFormat", ConvertContainerFormat(video_format)));
     query_params.push_back(
         std::make_pair("audioFormat", ConvertContainerFormat(audio_format)));
     RunEncryptedMediaTestPage("mse_different_containers.html",
                               CurrentKeySystem(), query_params, kEnded);
   }
 
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
     SetUpCommandLineForKeySystem(CurrentKeySystem(), command_line);
   }
 };
 
 using ::testing::Combine;
 using ::testing::Values;
 
 #if !defined(OS_ANDROID)
-INSTANTIATE_TEST_CASE_P(SRC_ClearKey_Prefixed,
-                        EncryptedMediaTest,
-                        Combine(Values(kPrefixedClearKeyKeySystem),
-                                Values(SRC),
-                                Values(PREFIXED)));
-
 INSTANTIATE_TEST_CASE_P(SRC_ClearKey,
                         EncryptedMediaTest,
-                        Combine(Values(kClearKeyKeySystem),
-                                Values(SRC),
-                                Values(UNPREFIXED)));
+                        Combine(Values(kClearKeyKeySystem), Values(SRC)));
 #endif  // !defined(OS_ANDROID)
 
-INSTANTIATE_TEST_CASE_P(MSE_ClearKey_Prefixed,
-                        EncryptedMediaTest,
-                        Combine(Values(kPrefixedClearKeyKeySystem),
-                                Values(MSE),
-                                Values(PREFIXED)));
 INSTANTIATE_TEST_CASE_P(MSE_ClearKey,
                         EncryptedMediaTest,
-                        Combine(Values(kClearKeyKeySystem),
-                                Values(MSE),
-                                Values(UNPREFIXED)));
+                        Combine(Values(kClearKeyKeySystem), Values(MSE)));
 
 // External Clear Key is currently only used on platforms that use Pepper CDMs.
 #if defined(ENABLE_PEPPER_CDMS)
-INSTANTIATE_TEST_CASE_P(SRC_ExternalClearKey_Prefixed,
-                        EncryptedMediaTest,
-                        Combine(Values(kExternalClearKeyKeySystem),
-                                Values(SRC),
-                                Values(PREFIXED)));
 INSTANTIATE_TEST_CASE_P(SRC_ExternalClearKey,
                         EncryptedMediaTest,
                         Combine(Values(kExternalClearKeyKeySystem),
-                                Values(SRC),
-                                Values(UNPREFIXED)));
+                                Values(SRC)));
 
-INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKey_Prefixed,
-                        EncryptedMediaTest,
-                        Combine(Values(kExternalClearKeyKeySystem),
-                                Values(MSE),
-                                Values(PREFIXED)));
 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKey,
                         EncryptedMediaTest,
                         Combine(Values(kExternalClearKeyKeySystem),
-                                Values(MSE),
-                                Values(UNPREFIXED)));
+                                Values(MSE)));
 
 const char kExternalClearKeyDecryptOnlyKeySystem[] =
     "org.chromium.externalclearkey.decryptonly";
 
 // To reduce test time, only run ExternalClearKeyDecryptOnly with MSE.
-INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly_Prefixed,
-                        EncryptedMediaTest,
-                        Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
-                                Values(MSE),
-                                Values(PREFIXED)));
 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly,
                         EncryptedMediaTest,
                         Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
-                                Values(MSE),
-                                Values(UNPREFIXED)));
+                                Values(MSE)));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
-
-// Prefixed Widevine tests fail in Chrome OS official builds due to the request
-// for permissions. Since prefixed EME is deprecated and will be removed soon,
-// don't run these tests. http://crbug.com/430711
-#if !(defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
-
-// This test doesn't fully test playback with Widevine. So we only run Widevine
-// test with MSE (no SRC) to reduce test time. Also, on Android EME only works
-// with MSE and we cannot run this test with SRC.
-INSTANTIATE_TEST_CASE_P(MSE_Widevine_Prefixed,
-                        EncryptedMediaTest,
-                        Combine(Values(kWidevineKeySystem),
-                                Values(MSE),
-                                Values(PREFIXED)));
-#endif  // !(defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
-
 #if !defined(OS_CHROMEOS)
 INSTANTIATE_TEST_CASE_P(MSE_Widevine,
                         EncryptedMediaTest,
-                        Combine(Values(kWidevineKeySystem),
-                                Values(MSE),
-                                Values(UNPREFIXED)));
+                        Combine(Values(kWidevineKeySystem), Values(MSE)));
 #endif  // !defined(OS_CHROMEOS)
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) {
   TestSimplePlayback("bear-a_enc-a.webm", kWebMAudioOnly);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) {
   TestSimplePlayback("bear-320x240-av_enc-a.webm", kWebMAudioVideo);
 }
@@ skipping 82 matching lines @@
   TestSimplePlayback("bear-640x360-a_frag-cenc.mp4", kMP4AudioOnly);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest,
                        Playback_EncryptedVideo_MP4_ClearAudio_WEBM) {
   // MP4 without MSE is not support yet, http://crbug.com/170793.
   if (CurrentSourceType() != MSE) {
     DVLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
     return;
   }
-  if (CurrentEmeVersion() != UNPREFIXED) {
-    DVLOG(0) << "Skipping test; Only supported by unprefixed EME";
-    return;
-  }
   if (!IsPlayBackPossible(CurrentKeySystem())) {
     DVLOG(0) << "Skipping test - Test requires video playback.";
     return;
   }
   TestDifferentContainers(EncryptedContainer::ENCRYPTED_MP4,
                           EncryptedContainer::CLEAR_WEBM);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest,
                        Playback_ClearVideo_WEBM_EncryptedAudio_MP4) {
   // MP4 without MSE is not support yet, http://crbug.com/170793.
   if (CurrentSourceType() != MSE) {
     DVLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
     return;
   }
-  if (CurrentEmeVersion() != UNPREFIXED) {
-    DVLOG(0) << "Skipping test; Only supported by unprefixed EME";
-    return;
-  }
   if (!IsPlayBackPossible(CurrentKeySystem())) {
     DVLOG(0) << "Skipping test - Test requires video playback.";
     return;
   }
   TestDifferentContainers(EncryptedContainer::CLEAR_WEBM,
                           EncryptedContainer::ENCRYPTED_MP4);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest,
                        Playback_EncryptedVideo_WEBM_EncryptedAudio_MP4) {
   // MP4 without MSE is not support yet, http://crbug.com/170793.
   if (CurrentSourceType() != MSE) {
     DVLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
     return;
   }
-  if (CurrentEmeVersion() != UNPREFIXED) {
-    DVLOG(0) << "Skipping test; Only supported by unprefixed EME";
-    return;
-  }
   if (!IsPlayBackPossible(CurrentKeySystem())) {
     DVLOG(0) << "Skipping test - Test requires video playback.";
     return;
   }
   TestDifferentContainers(EncryptedContainer::ENCRYPTED_WEBM,
                           EncryptedContainer::ENCRYPTED_MP4);
 }
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
-// The parent key system cannot be used in generateKeyRequest.
-IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException_Prefixed) {
-  RunEncryptedMediaTest(kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly,
-                        "com.widevine", MSE, PREFIXED, kNoSessionToLoad, false,
-                        PlayTwice::NO, kEmeNotSupportedError);
-}
-
 // The parent key system cannot be used when creating MediaKeys.
 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException) {
   RunEncryptedMediaTest(kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly,
-                        "com.widevine", MSE, UNPREFIXED, kNoSessionToLoad,
-                        false, PlayTwice::NO, kEmeNotSupportedError);
+                        "com.widevine", MSE, kNoSessionToLoad, false,
+                        PlayTwice::NO, kEmeNotSupportedError);
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 #if defined(ENABLE_PEPPER_CDMS)
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, InitializeCDMFail) {
   TestNonPlaybackCases(kExternalClearKeyInitializeFailKeySystem,
                        kEmeNotSupportedError);
 }
 
 // When CDM crashes, we should still get a decode error. |kError| is reported
@@ skipping 18 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadLoadableSession) {
   TestPlaybackCase(kLoadableSession, kEnded);
 }
 
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadUnknownSession) {
   TestPlaybackCase(kUnknownSession, kEmeSessionNotFound);
 }
 
-IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, InitializeCDMFail) {
-  TestNonPlaybackCases(kExternalClearKeyInitializeFailKeySystem,
-                       kPrefixedEmeErrorEvent);
-}
-
-// When CDM crashes, we should still get a decode error.
-// crbug.com/386657
-IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest,
-                       DISABLED_CDMCrashDuringDecode) {
-  IgnorePluginCrash();
-  TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError);
-}
-
-// Testing that the media browser test does fail on plugin crash.
-// crbug.com/386657
-IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest,
-                       DISABLED_CDMExpectedCrash) {
-  // Plugin crash is not ignored by default, the test is expected to fail.
-  EXPECT_NONFATAL_FAILURE(
-      TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError),
-      "plugin crash");
-}
-
-IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, FileIOTest) {
-  TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem,
-                       kFileIOTestSuccess);
-}
-
-IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, LoadLoadableSession) {
-  TestPlaybackCase(kLoadableSession, kEnded);
-}
-
-IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, LoadUnknownSession) {
-  TestPlaybackCase(kUnknownSession, kPrefixedEmeErrorEvent);
-}
 #endif  // defined(ENABLE_PEPPER_CDMS)