Add decrypt-only external clear key browser tests.

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 "base/command_line.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/media/media_browsertest.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 15 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[] = "webkit-org.w3.clearkey";
-const char kExternalClearKeyKeySystem[] =
-    "org.chromium.externalclearkey";
+const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
+const char kDecryptOnlyExternalClearKeyKeySystem[] =

[ddorwin, 2013/11/21 04:10:58]

Start with a common prefix?
kExternalClearKeyKeySystemDecryptOnly

[xhwang, 2013/11/22 01:47:36]

Done.

+    "org.chromium.externalclearkey.decryptonly";
 
 // Supported media types.
 const char kWebMAudioOnly[] = "audio/webm; codecs=\"vorbis\"";
 const char kWebMVideoOnly[] = "video/webm; codecs=\"vp8\"";
 const char kWebMAudioVideo[] = "video/webm; codecs=\"vorbis, vp8\"";
 #if defined(USE_PROPRIETARY_CODECS)
 const char kMP4AudioOnly[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP4VideoOnly[] = "video/mp4; codecs=\"avc1.4D4041\"";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
@@ skipping 16 matching lines @@
   }
 #endif  // defined(OS_ANDROID)
   return true;
 }
 
 // Base class for encrypted media tests.
 class EncryptedMediaTestBase : public MediaBrowserTest {
  public:
   EncryptedMediaTestBase() : is_pepper_cdm_registered_(false) {}
 
-  bool IsExternalClearKey(const char* key_system) {
-    return (strcmp(key_system, kExternalClearKeyKeySystem) == 0);
+  bool IsExternalClearKey(const std::string& key_system) {
+    return key_system == kExternalClearKeyKeySystem ||
+           key_system == kDecryptOnlyExternalClearKeyKeySystem;

[ddorwin, 2013/11/21 04:10:58]

Just check if the first length of kExternalClearKeyKeySystem bytes is
kExternalClearKeyKeySystem?

[xhwang, 2013/11/22 01:47:36]

Done.

This is not super accurate. The correct way should be:
key_system == kExternalClearKeyKeySystem or "org.chromium.externalclearkey_._"
is a prefix of |key_system|. Basically org.chromium.externalclearkeyfoo is not
external clear key.

But I feel a simple prefix check should be sufficient for our test purpose.
WDYT?

[ddorwin, 2013/11/22 04:28:59]

Yeah, I know. Agreed.
You could add:
&& (key_system.size() = eck_prefix.size() || key_system[eck_prefix.size()] ==
'.')

[xhwang, 2013/11/22 07:44:26]

Done.

   }
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
-  bool IsWidevine(const char* key_system) {
-    return (strcmp(key_system, kWidevineKeySystem) == 0);
+  bool IsWidevine(const std::string& key_system) {
+    return key_system == kWidevineKeySystem;
   }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
   void RunEncryptedMediaTest(const char* html_page,
                              const char* media_file,
                              const char* media_type,
                              const char* key_system,
                              SrcType src_type,
                              const char* expectation) {
     if (src_type == MSE && !IsMSESupported()) {
@@ skipping 51 matching lines @@
     command_line->AppendSwitch(
         switches::kDisableGestureRequirementForMediaPlayback);
 #endif  // defined(OS_ANDROID)
   }
 
   void SetUpCommandLineForKeySystem(const char* key_system,
                                     CommandLine* command_line) {
 #if defined(ENABLE_PEPPER_CDMS)
     if (IsExternalClearKey(key_system)) {
       RegisterPepperCdm(command_line, kClearKeyCdmAdapterFileName,
-                        kExternalClearKeyKeySystem);
+                        key_system);

[ddorwin, 2013/11/21 04:10:58]

fits?

[xhwang, 2013/11/22 01:47:36]

Done.

     }
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
     else if (IsWidevine(key_system)) {
       RegisterPepperCdm(command_line, kWidevineCdmAdapterFileName,
                         kWidevineKeySystem);

[ddorwin, 2013/11/21 04:10:58]

change here too?

[xhwang, 2013/11/22 01:47:36]

Done.

     }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 #endif  // defined(ENABLE_PEPPER_CDMS)
   }
 
  private:
 #if defined(ENABLE_PEPPER_CDMS)
   void RegisterPepperCdm(CommandLine* command_line,
                          const std::string& adapter_name,
                          const std::string& key_system) {
@@ skipping 12 matching lines @@
     pepper_plugin.append(ASCIIToWide(GetPepperType(key_system)));
 #else
     pepper_plugin.append(GetPepperType(key_system));
 #endif
     command_line->AppendSwitchNative(switches::kRegisterPepperPlugins,
                                      pepper_plugin);
   }
 
   // Adapted from key_systems.cc.
   std::string GetPepperType(const std::string& key_system) {
-    if (key_system == kExternalClearKeyKeySystem)
+    if (IsExternalClearKey(key_system))
       return kClearKeyCdmPluginMimeType;
 #if defined(WIDEVINE_CDM_AVAILABLE)
-    if (key_system == kWidevineKeySystem)
+    if (IsWidevine(key_system))
       return kWidevineCdmPluginMimeType;
 #endif  // WIDEVINE_CDM_AVAILABLE
 
     NOTREACHED();
     return "";
   }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
   bool is_pepper_cdm_registered_;
 };
 
 #if defined(ENABLE_PEPPER_CDMS)
-// Tests encrypted media playback using ExternalClearKey key system.
+// Tests encrypted media playback using ExternalClearKey key system in
+// decrypt-and-decode mode.
 class ECKEncryptedMediaTest : public EncryptedMediaTestBase {
  protected:
   virtual void SetUpCommandLine(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.
@@ skipping 76 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(MSE_ClearKey, EncryptedMediaTest,
     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, EncryptedMediaTest,
     Combine(Values(kExternalClearKeyKeySystem), Values(SRC)));
 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKey, EncryptedMediaTest,
     Combine(Values(kExternalClearKeyKeySystem), Values(MSE)));
+INSTANTIATE_TEST_CASE_P(SRC_DecryptOnlyExternalClearKey, EncryptedMediaTest,

[ddorwin, 2013/11/21 04:10:58]

This is going to add a lot of test time (in addition to coverage). :(
We should at least file a bug to cut down the test duration, most likely by
shortening the video run time.

[xhwang, 2013/11/22 01:47:36]

The decrypt only path is orthogonal to SRC/MSE. Dropped SRC to reduce test time.

+    Combine(Values(kDecryptOnlyExternalClearKeyKeySystem), Values(SRC)));
+INSTANTIATE_TEST_CASE_P(MSE_DecryptOnlyExternalClearKey, EncryptedMediaTest,
+    Combine(Values(kDecryptOnlyExternalClearKeyKeySystem), Values(MSE)));
 #endif // defined(ENABLE_PEPPER_CDMS)
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 // 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, EncryptedMediaTest,
     Combine(Values(kWidevineKeySystem), Values(MSE)));
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
@@ skipping 61 matching lines @@
                         kEmeNotSupportedError);
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 #if defined(ENABLE_PEPPER_CDMS)
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest,
                        ExternalClearKeyInitializeCDMFail) {
   RunEncryptedMediaTest("encrypted_media_player.html",
                         "bear-a-enc_a.webm",
                         kWebMAudioOnly,
                         "org.chromium.externalclearkey.initializefail",

[ddorwin, 2013/11/21 04:10:58]

Move this up with all other known "modes".

[xhwang, 2013/11/22 01:47:36]

Done.

                         SRC,
                         kEmeKeyError);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)