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 kDefaultEmePlayer[] = "eme_player.html";
 
 // The type of video src used to load media.
 enum SrcType {
   SRC,
   MSE
 };
 
+// TODO(ddorwin): Remove this from the tests as well as PREFIXED_EME_ERROR_EVENT
+// and PREFIXED_EME_RENEWAL_MISSING_HEADER from the tests.
 // 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.
@@ skipping 87 matching lines @@
                               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) {
     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);
     // Check KeyMessage received for all key systems.
     bool receivedKeyMessage = false;
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         browser()->tab_strip_model()->GetActiveWebContents(),
         "window.domAutomationController.send("
@@ skipping 43 matching lines @@
     MediaBrowserTest::AddWaitForTitles(title_watcher);
     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));
   }
 
   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 75 matching lines @@
                           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);
   }
 };
 
@@ skipping 37 matching lines @@
   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);
   }
 
   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);
+        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);
   }
 
   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"));

[xhwang, 2016/02/19 23:39:14]

Can you fix this as well so that we can drop PREFIXED enum? We can keep the
UNPREFIXED enum for now.

[ddorwin, 2016/02/20 01:04:46]

Done. Removed both.

     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);

[xhwang, 2016/02/19 23:39:14]

ditto

[ddorwin, 2016/02/20 01:04:46]

Done.

     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)));
 #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)));
 
 // 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)));
 
-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)));
 
 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)));
 #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)));
 #endif  // !defined(OS_CHROMEOS)
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) {
@@ skipping 140 matching lines @@
   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);
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 #if defined(ENABLE_PEPPER_CDMS)
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, InitializeCDMFail) {
@@ skipping 23 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)