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

[ddorwin, 2014/05/30 17:42:56]

"Eme"

[shadi, 2014/05/31 00:31:37]

Done.

 
 // 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;
@@ skipping 120 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)
@@ skipping 16 matching lines @@
       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)