Integrate browser tests with new EME player.

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/memory/scoped_ptr.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"
@@ skipping 46 matching lines @@
 const char kMP4AudioOnly[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP4VideoOnly[] = "video/mp4; codecs=\"avc1.4D4041\"";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Sessions to load.
 const char kNoSessionToLoad[] = "";
 const char kLoadableSession[] = "LoadableSession";
 const char kUnknownSession[] = "UnknownSession";
 
 // EME-specific test results and errors.
-const char kEmeKeyError[] = "KEYERROR";
+const char kEmeKeyError[] = "KEY_ERROR";
 const char kEmeNotSupportedError[] = "NOTSUPPORTEDERROR";
-const char kFileIOTestSuccess[] = "FILEIOTESTSUCCESS";
+const char kFileIOTestSuccess[] = "FILE_IO_TEST_SUCCESS";
+
+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,
@@ skipping 80 matching lines @@
 
   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 = kEmeKeyError;
 
-    RunEncryptedMediaTest("encrypted_media_player.html",
+    RunEncryptedMediaTest(kDefaultEmePlayer,
                           media_file,
                           media_type,
                           key_system,
                           src_type,
                           eme_version,
                           kNoSessionToLoad,
                           false,
                           expected_title);
     // Check KeyMessage received for all key systems.
     bool receivedKeyMessage = false;
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         browser()->tab_strip_model()->GetActiveWebContents(),
-        "window.domAutomationController.send(video.receivedKeyMessage);",
+        "window.domAutomationController.send("
+        "document.querySelector('video').receivedKeyMessage);",
         &receivedKeyMessage));
     EXPECT_TRUE(receivedKeyMessage);
   }
 
 
   void StartLicenseServerIfNeeded(const std::string& key_system,
                                   std::vector<StringPair>* query_params) {
     scoped_ptr<TestLicenseServerConfig> config = GetServerConfig(key_system);
     if (!config)
       return;
@@ skipping 107 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("encrypted_media_player.html",
+    RunEncryptedMediaTest(kDefaultEmePlayer,
                           "bear-a-enc_a.webm",
                           kWebMAudioOnly,
                           key_system,
                           SRC,
                           PREFIXED,
                           kNoSessionToLoad,
                           false,
                           expected_title);
   }
 
@@ skipping 46 matching lines @@
   void TestSimplePlayback(const std::string& encrypted_media,
                           const std::string& media_type) {
     RunSimpleEncryptedMediaTest(encrypted_media,
                                 media_type,
                                 CurrentKeySystem(),
                                 CurrentSourceType(),
                                 CurrentEmeVersion());
   }
 
   void RunInvalidResponseTest() {
-    RunEncryptedMediaTest("encrypted_media_player.html",
+    RunEncryptedMediaTest(kDefaultEmePlayer,
                           "bear-320x240-av-enc_av.webm",
                           kWebMAudioVideo,
                           CurrentKeySystem(),
                           CurrentSourceType(),
                           CurrentEmeVersion(),
                           kNoSessionToLoad,
                           true,
                           kEmeKeyError);
   }
 
@@ skipping 195 matching lines @@
     VLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
     return;
   }
   TestSimplePlayback("bear-640x360-a_frag-cenc.mp4", kMP4AudioOnly);
 }
 #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("encrypted_media_player.html",
+  RunEncryptedMediaTest(kDefaultEmePlayer,
                         "bear-a-enc_a.webm",
                         kWebMAudioOnly,
                         "com.widevine",
                         MSE,
                         PREFIXED,
                         kNoSessionToLoad,
                         false,
                         kEmeNotSupportedError);
 }
 
 // TODO(jrummell): http://crbug.com/349181
 // The parent key system cannot be used when creating MediaKeys.
 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException) {
-  RunEncryptedMediaTest("encrypted_media_player.html",
+  RunEncryptedMediaTest(kDefaultEmePlayer,
                         "bear-a-enc_a.webm",
                         kWebMAudioOnly,
                         "com.widevine",
                         MSE,
                         UNPREFIXED,
                         kNoSessionToLoad,
                         false,
                         kEmeNotSupportedError);
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 #if defined(ENABLE_PEPPER_CDMS)
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, InitializeCDMFail) {
   TestNonPlaybackCases(kExternalClearKeyInitializeFailKeySystem, kEmeKeyError);
 }
 
-// TODO(jrummell): Fix these tests to handle rejected promises when the CDM
-// crashes. Currently the JavaScript doesn't expect to get any more events
-// after a crash.
-
 // When CDM crashes, we should still get a decode error.
-IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, DISABLED_CDMCrashDuringDecode) {
+IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, CDMCrashDuringDecode) {
   IgnorePluginCrash();
   TestNonPlaybackCases(kExternalClearKeyCrashKeySystem, kError);
 }
 
 // Testing that the media browser test does fail on plugin crash.
-IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, DISABLED_CDMExpectedCrash) {
+IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, 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(ECKEncryptedMediaTest, FileIOTest) {
   TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem,
                        kFileIOTestSuccess);
 }
 
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadLoadableSession) {
-  RunEncryptedMediaTest("encrypted_media_player.html",
+  RunEncryptedMediaTest(kDefaultEmePlayer,
                         "bear-320x240-v-enc_v.webm",
                         kWebMVideoOnly,
                         kExternalClearKeyKeySystem,
                         SRC,
                         PREFIXED,
                         kLoadableSession,
                         false,
                         kEnded);
 }
 
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadUnknownSession) {
   // TODO(xhwang): Add a specific error for this failure, e.g. kSessionNotFound.
-  RunEncryptedMediaTest("encrypted_media_player.html",
+  RunEncryptedMediaTest(kDefaultEmePlayer,
                         "bear-320x240-v-enc_v.webm",
                         kWebMVideoOnly,
                         kExternalClearKeyKeySystem,
                         SRC,
                         PREFIXED,
                         kUnknownSession,
                         false,
                         kEmeKeyError);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)