chrome/browser/media/encrypted_media_browsertest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/path_service.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/win/windows_version.h"
  10 #include "chrome/browser/media/media_browsertest.h"
  11 #include "chrome/browser/media/test_license_server.h"
  12 #include "chrome/browser/media/wv_test_license_server_config.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  15 #include "chrome/common/chrome_switches.h"
  16 #include "content/public/test/browser_test_utils.h"
  17 #include "testing/gtest/include/gtest/gtest-spi.h"
  18 #if defined(OS_ANDROID)
  19 #include "base/android/build_info.h"
  20 #endif
  21
  22 #include "widevine_cdm_version.h"  //  In SHARED_INTERMEDIATE_DIR.
  23
  24 #if defined(ENABLE_PEPPER_CDMS)
  25 // Platform-specific filename relative to the chrome executable.
  26 const char kClearKeyCdmAdapterFileName[] =
  27 #if defined(OS_MACOSX)
  28     "clearkeycdmadapter.plugin";
  29 #elif defined(OS_WIN)
  30     "clearkeycdmadapter.dll";
  31 #elif defined(OS_POSIX)
  32     "libclearkeycdmadapter.so";
  33 #endif
  34
  35 const char kClearKeyCdmPluginMimeType[] = "application/x-ppapi-clearkey-cdm";
  36 #endif  // defined(ENABLE_PEPPER_CDMS)
  37
  38 // Available key systems.
  39 const char kClearKeyKeySystem[] = "org.w3.clearkey";
  40 const char kPrefixedClearKeyKeySystem[] = "webkit-org.w3.clearkey";
  41 const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
  42 const char kExternalClearKeyDecryptOnlyKeySystem[] =
  43     "org.chromium.externalclearkey.decryptonly";
  44 const char kExternalClearKeyFileIOTestKeySystem[] =
  45     "org.chromium.externalclearkey.fileiotest";
  46 const char kExternalClearKeyInitializeFailKeySystem[] =
  47     "org.chromium.externalclearkey.initializefail";
  48 const char kExternalClearKeyCrashKeySystem[] =
  49     "org.chromium.externalclearkey.crash";
  50
  51 // Supported media types.
  52 const char kWebMAudioOnly[] = "audio/webm; codecs=\"vorbis\"";
  53 const char kWebMVideoOnly[] = "video/webm; codecs=\"vp8\"";
  54 const char kWebMAudioVideo[] = "video/webm; codecs=\"vorbis, vp8\"";
  55 const char kWebMVP9VideoOnly[] = "video/webm; codecs=\"vp9\"";
  56 #if defined(USE_PROPRIETARY_CODECS)
  57 const char kMP4AudioOnly[] = "audio/mp4; codecs=\"mp4a.40.2\"";
  58 const char kMP4VideoOnly[] = "video/mp4; codecs=\"avc1.4D4041\"";
  59 #endif  // defined(USE_PROPRIETARY_CODECS)
  60
  61 // Sessions to load.
  62 const char kNoSessionToLoad[] = "";
  63 const char kLoadableSession[] = "LoadableSession";
  64 const char kUnknownSession[] = "UnknownSession";
  65
  66 // EME-specific test results and errors.
  67 const char kEmeKeyError[] = "KEY_ERROR";
  68 const char kEmeNotSupportedError[] = "NOTSUPPORTEDERROR";
  69 const char kFileIOTestSuccess[] = "FILE_IO_TEST_SUCCESS";
  70
  71 const char kDefaultEmePlayer[] = "eme_player.html";
  72
  73 // The type of video src used to load media.
  74 enum SrcType {
  75   SRC,
  76   MSE
  77 };
  78
  79 // Whether to use prefixed or unprefixed EME.
  80 enum EmeVersion {
  81   PREFIXED,
  82   UNPREFIXED
  83 };
  84
  85 // Whether the video should be played once or twice.
  86 enum class PlayTwice { NO, YES };
  87
  88 // MSE is available on all desktop platforms and on Android 4.1 and later.
  89 static bool IsMSESupported() {
  90 #if defined(OS_ANDROID)
  91   if (base::android::BuildInfo::GetInstance()->sdk_int() < 16) {
  92     DVLOG(0) << "MSE is only supported in Android 4.1 and later.";
  93     return false;
  94   }
  95 #endif  // defined(OS_ANDROID)
  96   return true;
  97 }
  98
  99 static bool IsParentKeySystemOf(const std::string& parent_key_system,
 100                                 const std::string& key_system) {
 101   std::string prefix = parent_key_system + '.';
 102   return key_system.substr(0, prefix.size()) == prefix;
 103 }
 104
 105 // Base class for encrypted media tests.
 106 class EncryptedMediaTestBase : public MediaBrowserTest {
 107  public:
 108   EncryptedMediaTestBase() : is_pepper_cdm_registered_(false) {}
 109
 110   bool IsExternalClearKey(const std::string& key_system) {
 111     return key_system == kExternalClearKeyKeySystem ||
 112            IsParentKeySystemOf(kExternalClearKeyKeySystem, key_system);
 113   }
 114
 115 #if defined(WIDEVINE_CDM_AVAILABLE)
 116   bool IsWidevine(const std::string& key_system) {
 117     return key_system == kWidevineKeySystem;
 118   }
 119 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 120
 121   void RunEncryptedMediaTestPage(
 122       const std::string& html_page,
 123       const std::string& key_system,
 124       base::StringPairs& query_params,
 125       const std::string& expected_title) {
 126     base::StringPairs new_query_params = query_params;
 127     StartLicenseServerIfNeeded(key_system, &new_query_params);
 128     RunMediaTestPage(html_page, new_query_params, expected_title, true);
 129   }
 130
 131   // Tests |html_page| using |media_file| (with |media_type|) and |key_system|.
 132   // When |session_to_load| is not empty, the test will try to load
 133   // |session_to_load| with stored keys, instead of creating a new session
 134   // and trying to update it with licenses.
 135   // When |force_invalid_response| is true, the test will provide invalid
 136   // responses, which should trigger errors.
 137   // TODO(xhwang): Find an easier way to pass multiple configuration test
 138   // options.
 139   void RunEncryptedMediaTest(const std::string& html_page,
 140                              const std::string& media_file,
 141                              const std::string& media_type,
 142                              const std::string& key_system,
 143                              SrcType src_type,
 144                              EmeVersion eme_version,
 145                              const std::string& session_to_load,
 146                              bool force_invalid_response,
 147                              PlayTwice play_twice,
 148                              const std::string& expected_title) {
 149     if (src_type == MSE && !IsMSESupported()) {
 150       DVLOG(0) << "Skipping test - MSE not supported.";
 151       return;
 152     }
 153     base::StringPairs query_params;
 154     query_params.push_back(std::make_pair("mediaFile", media_file));
 155     query_params.push_back(std::make_pair("mediaType", media_type));
 156     query_params.push_back(std::make_pair("keySystem", key_system));
 157     if (src_type == MSE)
 158       query_params.push_back(std::make_pair("useMSE", "1"));
 159     if (eme_version == PREFIXED)
 160       query_params.push_back(std::make_pair("usePrefixedEME", "1"));
 161     if (force_invalid_response)
 162       query_params.push_back(std::make_pair("forceInvalidResponse", "1"));
 163     if (!session_to_load.empty())
 164       query_params.push_back(std::make_pair("sessionToLoad", session_to_load));
 165     if (play_twice == PlayTwice::YES)
 166       query_params.push_back(std::make_pair("playTwice", "1"));
 167     RunEncryptedMediaTestPage(html_page, key_system, query_params,
 168                               expected_title);
 169   }
 170
 171   void RunSimpleEncryptedMediaTest(const std::string& media_file,
 172                                    const std::string& media_type,
 173                                    const std::string& key_system,
 174                                    SrcType src_type,
 175                                    EmeVersion eme_version) {
 176     std::string expected_title = kEnded;
 177     if (!IsPlayBackPossible(key_system))
 178       expected_title = kEmeKeyError;
 179
 180     RunEncryptedMediaTest(kDefaultEmePlayer, media_file, media_type, key_system,
 181                           src_type, eme_version, kNoSessionToLoad, false,
 182                           PlayTwice::NO, expected_title);
 183     // Check KeyMessage received for all key systems.
 184     bool receivedKeyMessage = false;
 185     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
 186         browser()->tab_strip_model()->GetActiveWebContents(),
 187         "window.domAutomationController.send("
 188         "document.querySelector('video').receivedKeyMessage);",
 189         &receivedKeyMessage));
 190     EXPECT_TRUE(receivedKeyMessage);
 191   }
 192
 193   // Starts a license server if available for the |key_system| and adds a
 194   // 'licenseServerURL' query parameter to |query_params|.
 195   void StartLicenseServerIfNeeded(const std::string& key_system,
 196                                   base::StringPairs* query_params) {
 197     scoped_ptr<TestLicenseServerConfig> config = GetServerConfig(key_system);
 198     if (!config)
 199       return;
 200     license_server_.reset(new TestLicenseServer(config.Pass()));
 201     EXPECT_TRUE(license_server_->Start());
 202     query_params->push_back(
 203         std::make_pair("licenseServerURL", license_server_->GetServerURL()));
 204   }
 205
 206   bool IsPlayBackPossible(const std::string& key_system) {
 207 #if defined(WIDEVINE_CDM_AVAILABLE)
 208     if (IsWidevine(key_system) && !GetServerConfig(key_system))
 209       return false;
 210 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 211     return true;
 212   }
 213
 214   scoped_ptr<TestLicenseServerConfig> GetServerConfig(
 215       const std::string& key_system) {
 216 #if defined(WIDEVINE_CDM_AVAILABLE)
 217     if (IsWidevine(key_system)) {
 218       scoped_ptr<TestLicenseServerConfig> config =
 219          scoped_ptr<TestLicenseServerConfig>(new WVTestLicenseServerConfig());
 220       if (config->IsPlatformSupported())
 221         return config.Pass();
 222     }
 223 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 224     return scoped_ptr<TestLicenseServerConfig>();
 225   }
 226
 227  protected:
 228   scoped_ptr<TestLicenseServer> license_server_;
 229
 230   // We want to fail quickly when a test fails because an error is encountered.
 231   void AddWaitForTitles(content::TitleWatcher* title_watcher) override {
 232     MediaBrowserTest::AddWaitForTitles(title_watcher);
 233     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeNotSupportedError));
 234     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeKeyError));
 235   }
 236
 237   void SetUpCommandLine(base::CommandLine* command_line) override {
 238 #if defined(OS_ANDROID)
 239     command_line->AppendSwitch(
 240         switches::kDisableGestureRequirementForMediaPlayback);
 241 #endif  // defined(OS_ANDROID)
 242   }
 243
 244   void SetUpCommandLineForKeySystem(const std::string& key_system,
 245                                     base::CommandLine* command_line) {
 246     if (GetServerConfig(key_system))
 247       // Since the web and license servers listen on different ports, we need to
 248       // disable web-security to send license requests to the license server.
 249       // TODO(shadi): Add port forwarding to the test web server configuration.
 250       command_line->AppendSwitch(switches::kDisableWebSecurity);
 251
 252 #if defined(ENABLE_PEPPER_CDMS)
 253     if (IsExternalClearKey(key_system)) {
 254       RegisterPepperCdm(command_line, kClearKeyCdmAdapterFileName, key_system);
 255     }
 256 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 257     else if (IsWidevine(key_system)) {  // NOLINT
 258       RegisterPepperCdm(command_line, kWidevineCdmAdapterFileName, key_system);
 259     }
 260 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 261 #endif  // defined(ENABLE_PEPPER_CDMS)
 262   }
 263
 264  private:
 265 #if defined(ENABLE_PEPPER_CDMS)
 266   void RegisterPepperCdm(base::CommandLine* command_line,
 267                          const std::string& adapter_name,
 268                          const std::string& key_system) {
 269     DCHECK(!is_pepper_cdm_registered_)
 270         << "RegisterPepperCdm() can only be called once.";
 271     is_pepper_cdm_registered_ = true;
 272
 273     // Append the switch to register the Clear Key CDM Adapter.
 274     base::FilePath plugin_dir;
 275     EXPECT_TRUE(PathService::Get(base::DIR_MODULE, &plugin_dir));
 276     base::FilePath plugin_lib = plugin_dir.AppendASCII(adapter_name);
 277     EXPECT_TRUE(base::PathExists(plugin_lib)) << plugin_lib.value();
 278     base::FilePath::StringType pepper_plugin = plugin_lib.value();
 279     pepper_plugin.append(FILE_PATH_LITERAL("#CDM#0.1.0.0;"));
 280 #if defined(OS_WIN)
 281     pepper_plugin.append(base::ASCIIToUTF16(GetPepperType(key_system)));
 282 #else
 283     pepper_plugin.append(GetPepperType(key_system));
 284 #endif
 285     command_line->AppendSwitchNative(switches::kRegisterPepperPlugins,
 286                                      pepper_plugin);
 287   }
 288
 289   // Adapted from key_systems.cc.
 290   std::string GetPepperType(const std::string& key_system) {
 291     if (IsExternalClearKey(key_system))
 292       return kClearKeyCdmPluginMimeType;
 293 #if defined(WIDEVINE_CDM_AVAILABLE)
 294     if (IsWidevine(key_system))
 295       return kWidevineCdmPluginMimeType;
 296 #endif  // WIDEVINE_CDM_AVAILABLE
 297
 298     NOTREACHED();
 299     return "";
 300   }
 301 #endif  // defined(ENABLE_PEPPER_CDMS)
 302
 303   bool is_pepper_cdm_registered_;
 304 };
 305
 306 #if defined(ENABLE_PEPPER_CDMS)
 307 // Tests encrypted media playback using ExternalClearKey key system in
 308 // decrypt-and-decode mode.
 309 class ECKEncryptedMediaTest : public EncryptedMediaTestBase {
 310  public:
 311   // We use special |key_system| names to do non-playback related tests, e.g.
 312   // kExternalClearKeyFileIOTestKeySystem is used to test file IO.
 313   void TestNonPlaybackCases(const std::string& key_system,
 314                             const std::string& expected_title) {
 315     // Since we do not test playback, arbitrarily choose a test file and source
 316     // type.
 317     RunEncryptedMediaTest(
 318         kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly, key_system, SRC,
 319         UNPREFIXED, kNoSessionToLoad, false, PlayTwice::NO, expected_title);
 320   }
 321
 322   void TestPlaybackCase(const std::string& session_to_load,
 323                         const std::string& expected_title) {
 324     RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-v_enc-v.webm",
 325                           kWebMVideoOnly, kExternalClearKeyKeySystem, SRC,
 326                           UNPREFIXED, session_to_load, false, PlayTwice::NO,
 327                           expected_title);
 328   }
 329
 330  protected:
 331   void SetUpCommandLine(base::CommandLine* command_line) override {
 332     EncryptedMediaTestBase::SetUpCommandLine(command_line);
 333     SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
 334   }
 335 };
 336
 337 // Tests encrypted media playback using ExternalClearKey key system in
 338 // decrypt-and-decode mode for unprefixed EME.
 339 class ECKPrefixedEncryptedMediaTest : public EncryptedMediaTestBase {
 340  public:
 341   // We use special |key_system| names to do non-playback related tests, e.g.
 342   // kExternalClearKeyFileIOTestKeySystem is used to test file IO.
 343   void TestNonPlaybackCases(const std::string& key_system,
 344                             const std::string& expected_title) {
 345     // Since we do not test playback, arbitrarily choose a test file and source
 346     // type.
 347     RunEncryptedMediaTest(
 348         kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly, key_system, SRC,
 349         PREFIXED, kNoSessionToLoad, false, PlayTwice::NO, expected_title);
 350   }
 351
 352   void TestPlaybackCase(const std::string& session_to_load,
 353                         const std::string& expected_title) {
 354     RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-v_enc-v.webm",
 355                           kWebMVideoOnly, kExternalClearKeyKeySystem, SRC,
 356                           PREFIXED, session_to_load, false, PlayTwice::NO,
 357                           expected_title);
 358   }
 359
 360  protected:
 361   void SetUpCommandLine(base::CommandLine* command_line) override {
 362     EncryptedMediaTestBase::SetUpCommandLine(command_line);
 363     SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
 364   }
 365 };
 366
 367 #if defined(WIDEVINE_CDM_AVAILABLE)
 368 // Tests encrypted media playback using Widevine key system.
 369 class WVEncryptedMediaTest : public EncryptedMediaTestBase {
 370  protected:
 371   void SetUpCommandLine(base::CommandLine* command_line) override {
 372     EncryptedMediaTestBase::SetUpCommandLine(command_line);
 373     SetUpCommandLineForKeySystem(kWidevineKeySystem, command_line);
 374   }
 375 };
 376
 377 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 378 #endif  // defined(ENABLE_PEPPER_CDMS)
 379
 380 // Tests encrypted media playback with a combination of parameters:
 381 // - char*: Key system name.
 382 // - SrcType: Use MSE or SRC.
 383 // - EmeVersion: Use PREFIXED or UNPREFIXED EME.
 384 //
 385 // Note: Only parameterized (*_P) tests can be used. Non-parameterized (*_F)
 386 // tests will crash at GetParam(). To add non-parameterized tests, use
 387 // EncryptedMediaTestBase or one of its subclasses (e.g. WVEncryptedMediaTest).
 388 class EncryptedMediaTest
 389     : public EncryptedMediaTestBase,
 390       public testing::WithParamInterface<
 391           std::tr1::tuple<const char*, SrcType, EmeVersion> > {
 392  public:
 393   std::string CurrentKeySystem() {
 394     return std::tr1::get<0>(GetParam());
 395   }
 396
 397   SrcType CurrentSourceType() {
 398     return std::tr1::get<1>(GetParam());
 399   }
 400
 401   EmeVersion CurrentEmeVersion() {
 402     return std::tr1::get<2>(GetParam());
 403   }
 404
 405   void TestSimplePlayback(const std::string& encrypted_media,
 406                           const std::string& media_type) {
 407     RunSimpleEncryptedMediaTest(encrypted_media,
 408                                 media_type,
 409                                 CurrentKeySystem(),
 410                                 CurrentSourceType(),
 411                                 CurrentEmeVersion());
 412   }
 413
 414   void TestMultiplePlayback(const std::string& encrypted_media,
 415                             const std::string& media_type) {
 416     DCHECK(IsPlayBackPossible(CurrentKeySystem()));
 417     RunEncryptedMediaTest(kDefaultEmePlayer, encrypted_media, media_type,
 418                           CurrentKeySystem(), CurrentSourceType(),
 419                           CurrentEmeVersion(), kNoSessionToLoad, false,
 420                           PlayTwice::YES, kEnded);
 421   }
 422
 423   void RunInvalidResponseTest() {
 424     RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-av_enc-av.webm",
 425                           kWebMAudioVideo, CurrentKeySystem(),
 426                           CurrentSourceType(), CurrentEmeVersion(),
 427                           kNoSessionToLoad, true, PlayTwice::NO, kEmeKeyError);
 428   }
 429
 430   void TestFrameSizeChange() {
 431     RunEncryptedMediaTest(
 432         "encrypted_frame_size_change.html", "frame_size_change-av_enc-v.webm",
 433         kWebMAudioVideo, CurrentKeySystem(), CurrentSourceType(),
 434         CurrentEmeVersion(), kNoSessionToLoad, false, PlayTwice::NO, kEnded);
 435   }
 436
 437   void TestConfigChange() {
 438     DCHECK(IsMSESupported());
 439     base::StringPairs query_params;
 440     query_params.push_back(std::make_pair("keySystem", CurrentKeySystem()));
 441     query_params.push_back(std::make_pair("runEncrypted", "1"));
 442     if (CurrentEmeVersion() == PREFIXED)
 443       query_params.push_back(std::make_pair("usePrefixedEME", "1"));
 444     RunEncryptedMediaTestPage("mse_config_change.html",
 445                               CurrentKeySystem(),
 446                               query_params,
 447                               kEnded);
 448   }
 449
 450  protected:
 451   void SetUpCommandLine(base::CommandLine* command_line) override {
 452     EncryptedMediaTestBase::SetUpCommandLine(command_line);
 453     SetUpCommandLineForKeySystem(CurrentKeySystem(), command_line);
 454   }
 455 };
 456
 457 using ::testing::Combine;
 458 using ::testing::Values;
 459
 460 #if !defined(OS_ANDROID)
 461 INSTANTIATE_TEST_CASE_P(SRC_ClearKey_Prefixed,
 462                         EncryptedMediaTest,
 463                         Combine(Values(kPrefixedClearKeyKeySystem),
 464                                 Values(SRC),
 465                                 Values(PREFIXED)));
 466
 467 INSTANTIATE_TEST_CASE_P(SRC_ClearKey,
 468                         EncryptedMediaTest,
 469                         Combine(Values(kClearKeyKeySystem),
 470                                 Values(SRC),
 471                                 Values(UNPREFIXED)));
 472 #endif  // !defined(OS_ANDROID)
 473
 474 INSTANTIATE_TEST_CASE_P(MSE_ClearKey_Prefixed,
 475                         EncryptedMediaTest,
 476                         Combine(Values(kPrefixedClearKeyKeySystem),
 477                                 Values(MSE),
 478                                 Values(PREFIXED)));
 479 INSTANTIATE_TEST_CASE_P(MSE_ClearKey,
 480                         EncryptedMediaTest,
 481                         Combine(Values(kClearKeyKeySystem),
 482                                 Values(MSE),
 483                                 Values(UNPREFIXED)));
 484
 485 // External Clear Key is currently only used on platforms that use Pepper CDMs.
 486 #if defined(ENABLE_PEPPER_CDMS)
 487 INSTANTIATE_TEST_CASE_P(SRC_ExternalClearKey_Prefixed,
 488                         EncryptedMediaTest,
 489                         Combine(Values(kExternalClearKeyKeySystem),
 490                                 Values(SRC),
 491                                 Values(PREFIXED)));
 492 INSTANTIATE_TEST_CASE_P(SRC_ExternalClearKey,
 493                         EncryptedMediaTest,
 494                         Combine(Values(kExternalClearKeyKeySystem),
 495                                 Values(SRC),
 496                                 Values(UNPREFIXED)));
 497 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKey_Prefixed,
 498                         EncryptedMediaTest,
 499                         Combine(Values(kExternalClearKeyKeySystem),
 500                                 Values(MSE),
 501                                 Values(PREFIXED)));
 502 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKey,
 503                         EncryptedMediaTest,
 504                         Combine(Values(kExternalClearKeyKeySystem),
 505                                 Values(MSE),
 506                                 Values(UNPREFIXED)));
 507 // To reduce test time, only run ExternalClearKeyDecryptOnly with MSE.
 508 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly_Prefixed,
 509                         EncryptedMediaTest,
 510                         Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
 511                                 Values(MSE),
 512                                 Values(PREFIXED)));
 513 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly,
 514                         EncryptedMediaTest,
 515                         Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
 516                                 Values(MSE),
 517                                 Values(UNPREFIXED)));
 518 #endif  // defined(ENABLE_PEPPER_CDMS)
 519
 520 #if defined(WIDEVINE_CDM_AVAILABLE)
 521
 522 // Prefixed Widevine tests fail in Chrome OS official builds due to the request
 523 // for permissions. Since prefixed EME is deprecated and will be removed soon,
 524 // don't run these tests. http://crbug.com/430711
 525 #if !(defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
 526
 527 // This test doesn't fully test playback with Widevine. So we only run Widevine
 528 // test with MSE (no SRC) to reduce test time. Also, on Android EME only works
 529 // with MSE and we cannot run this test with SRC.
 530 INSTANTIATE_TEST_CASE_P(MSE_Widevine_Prefixed,
 531                         EncryptedMediaTest,
 532                         Combine(Values(kWidevineKeySystem),
 533                                 Values(MSE),
 534                                 Values(PREFIXED)));
 535 #endif  // !(defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
 536
 537 INSTANTIATE_TEST_CASE_P(MSE_Widevine,
 538                         EncryptedMediaTest,
 539                         Combine(Values(kWidevineKeySystem),
 540                                 Values(MSE),
 541                                 Values(UNPREFIXED)));
 542 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 543
 544 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) {
 545   TestSimplePlayback("bear-a_enc-a.webm", kWebMAudioOnly);
 546 }
 547
 548 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) {
 549   TestSimplePlayback("bear-320x240-av_enc-a.webm", kWebMAudioVideo);
 550 }
 551
 552 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoAudio_WebM) {
 553   TestSimplePlayback("bear-320x240-av_enc-av.webm", kWebMAudioVideo);
 554 }
 555
 556 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoOnly_WebM) {
 557   TestSimplePlayback("bear-320x240-v_enc-v.webm", kWebMVideoOnly);
 558 }
 559
 560 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoClearAudio_WebM) {
 561   TestSimplePlayback("bear-320x240-av_enc-v.webm", kWebMAudioVideo);
 562 }
 563
 564 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VP9Video_WebM) {
 565   TestSimplePlayback("bear-320x240-v-vp9_enc-v.webm", kWebMVP9VideoOnly);
 566 }
 567
 568 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM_Opus) {
 569   TestSimplePlayback("bear-320x240-opus-a_enc-a.webm", kWebMAudioOnly);
 570 }
 571
 572 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoAudio_WebM_Opus) {
 573   TestSimplePlayback("bear-320x240-opus-av_enc-av.webm", kWebMAudioVideo);
 574 }
 575
 576 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoClearAudio_WebM_Opus) {
 577   TestSimplePlayback("bear-320x240-opus-av_enc-v.webm", kWebMAudioVideo);
 578 }
 579
 580 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_Multiple_VideoAudio_WebM) {
 581   if (!IsPlayBackPossible(CurrentKeySystem())) {
 582     DVLOG(0) << "Skipping test - Playback_Multiple test requires playback.";
 583     return;
 584   }
 585   TestMultiplePlayback("bear-320x240-av_enc-av.webm", kWebMAudioVideo);
 586 }
 587
 588 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, InvalidResponseKeyError) {
 589   RunInvalidResponseTest();
 590 }
 591
 592 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, ConfigChangeVideo) {
 593   if (CurrentSourceType() != MSE || !IsMSESupported()) {
 594     DVLOG(0) << "Skipping test - ConfigChange test requires MSE.";
 595     return;
 596   }
 597   if (!IsPlayBackPossible(CurrentKeySystem())) {
 598     DVLOG(0) << "Skipping test - ConfigChange test requires video playback.";
 599     return;
 600   }
 601   TestConfigChange();
 602 }
 603
 604 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, FrameSizeChangeVideo) {
 605   // Times out on Windows XP. http://crbug.com/171937
 606 #if defined(OS_WIN)
 607   if (base::win::GetVersion() < base::win::VERSION_VISTA)
 608     return;
 609 #endif
 610   if (!IsPlayBackPossible(CurrentKeySystem())) {
 611     DVLOG(0) << "Skipping test - FrameSizeChange test requires video playback.";
 612     return;
 613   }
 614   TestFrameSizeChange();
 615 }
 616
 617 #if defined(USE_PROPRIETARY_CODECS)
 618 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoOnly_MP4) {
 619   // MP4 without MSE is not support yet, http://crbug.com/170793.
 620   if (CurrentSourceType() != MSE) {
 621     DVLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
 622     return;
 623   }
 624   TestSimplePlayback("bear-640x360-v_frag-cenc.mp4", kMP4VideoOnly);
 625 }
 626
 627 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_MP4) {
 628   // MP4 without MSE is not support yet, http://crbug.com/170793.
 629   if (CurrentSourceType() != MSE) {
 630     DVLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
 631     return;
 632   }
 633   TestSimplePlayback("bear-640x360-a_frag-cenc.mp4", kMP4AudioOnly);
 634 }
 635 #endif  // defined(USE_PROPRIETARY_CODECS)
 636
 637 #if defined(WIDEVINE_CDM_AVAILABLE)
 638 // The parent key system cannot be used in generateKeyRequest.
 639 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException_Prefixed) {
 640   RunEncryptedMediaTest(kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly,
 641                         "com.widevine", MSE, PREFIXED, kNoSessionToLoad, false,
 642                         PlayTwice::NO, kEmeNotSupportedError);
 643 }
 644
 645 // TODO(jrummell): http://crbug.com/349181
 646 // The parent key system cannot be used when creating MediaKeys.
 647 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException) {
 648   RunEncryptedMediaTest(kDefaultEmePlayer, "bear-a_enc-a.webm", kWebMAudioOnly,
 649                         "com.widevine", MSE, UNPREFIXED, kNoSessionToLoad,
 650                         false, PlayTwice::NO, kEmeNotSupportedError);
 651 }
 652 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 653
 654 #if defined(ENABLE_PEPPER_CDMS)
 655 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, InitializeCDMFail) {
 656   TestNonPlaybackCases(kExternalClearKeyInitializeFailKeySystem,
 657                        kEmeNotSupportedError);
 658 }
 659
 660 // When CDM crashes, we should still get a decode error.
 661 // crbug.com/386657
 662 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, DISABLED_CDMCrashDuringDecode) {
 663   IgnorePluginCrash();
 664   TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError);
 665 }
 666
 667 // Testing that the media browser test does fail on plugin crash.
 668 // crbug.com/386657
 669 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, DISABLED_CDMExpectedCrash) {
 670   // Plugin crash is not ignored by default, the test is expected to fail.
 671   EXPECT_NONFATAL_FAILURE(
 672       TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError),
 673       "plugin crash");
 674 }
 675
 676 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, FileIOTest) {
 677   TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem,
 678                        kFileIOTestSuccess);
 679 }
 680
 681 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadLoadableSession) {
 682   TestPlaybackCase(kLoadableSession, kEnded);
 683 }
 684
 685 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadUnknownSession) {
 686   // TODO(xhwang): Add a specific error for this failure, e.g. kSessionNotFound.
 687   TestPlaybackCase(kUnknownSession, kEmeKeyError);
 688 }
 689
 690 IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, InitializeCDMFail) {
 691   TestNonPlaybackCases(kExternalClearKeyInitializeFailKeySystem, kEmeKeyError);
 692 }
 693
 694 // When CDM crashes, we should still get a decode error.
 695 // crbug.com/386657
 696 IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest,
 697                        DISABLED_CDMCrashDuringDecode) {
 698   IgnorePluginCrash();
 699   TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError);
 700 }
 701
 702 // Testing that the media browser test does fail on plugin crash.
 703 // crbug.com/386657
 704 IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest,
 705                        DISABLED_CDMExpectedCrash) {
 706   // Plugin crash is not ignored by default, the test is expected to fail.
 707   EXPECT_NONFATAL_FAILURE(
 708       TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError),
 709       "plugin crash");
 710 }
 711
 712 IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, FileIOTest) {
 713   TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem,
 714                        kFileIOTestSuccess);
 715 }
 716
 717 IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, LoadLoadableSession) {
 718   TestPlaybackCase(kLoadableSession, kEnded);
 719 }
 720
 721 IN_PROC_BROWSER_TEST_F(ECKPrefixedEncryptedMediaTest, LoadUnknownSession) {
 722   // TODO(xhwang): Add a specific error for this failure, e.g. kSessionNotFound.
 723   TestPlaybackCase(kUnknownSession, kEmeKeyError);
 724 }
 725 #endif  // defined(ENABLE_PEPPER_CDMS)