media: Enable encrypted media content browsertests when MojoCdm is used

content/browser/media/encrypted_media_browsertest.cc

 // Copyright (c) 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/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "content/browser/media/media_browsertest.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/shell/browser/shell.h"
+#include "media/base/media.h"
+#include "media/base/media_switches.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
-#include "media/base/media.h"
-#include "media/base/media_switches.h"
 #endif
 
-#if defined(ENABLE_MOJO_RENDERER)
-// TODO(xhwang): Enable tests by running AesDecryptor in remote mojo CDM and
-// using ExternalClearKey instead of ClearKey: crbug.com/641559
-#define DISABLE_ENCRYPTED_MEDIA_PLAYBACK_TESTS 1
+// MojoCdm supports Clear Key, but currently MojoRenderer cannot use it.
+// See http://crbug.com/441957 for details.
+#if !(defined(ENABLE_MOJO_CDM) && defined(ENABLE_MOJO_RENDERER))
+#define SUPPORTS_CLEAR_KEY_IN_CONTENT_SHELL
+#endif
+
+#if defined(ENABLE_MOJO_CDM)
+// When mojo CDM is enabled, External Clear Key is supported in //content/shell/
+// by using mojo CDM with AesDecryptor running in the remote (e.g. GPU or
+// Browser) process.
+// Note that External Clear Key is also supported in chrome/ when pepper CDM is
+// used, which is tested in browser_tests.
+#define SUPPORTS_EXTERNAL_CLEAR_KEY_IN_CONTENT_SHELL
 #endif
 
 // Available key systems.
+#if defined(SUPPORTS_CLEAR_KEY_IN_CONTENT_SHELL)
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
+#endif
 
-#if defined(OS_ANDROID)
+#if defined(SUPPORTS_EXTERNAL_CLEAR_KEY_IN_CONTENT_SHELL)
 const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
 #endif
 
 // Supported media types.
 const char kWebMVorbisAudioOnly[] = "audio/webm; codecs=\"vorbis\"";
-#if !defined(DISABLE_ENCRYPTED_MEDIA_PLAYBACK_TESTS)
 const char kWebMOpusAudioOnly[] = "audio/webm; codecs=\"opus\"";
 const char kWebMVP8VideoOnly[] = "video/webm; codecs=\"vp8\"";
 const char kWebMVP9VideoOnly[] = "video/webm; codecs=\"vp9\"";
 const char kWebMOpusAudioVP9Video[] = "video/webm; codecs=\"opus, vp9\"";
-#endif
 const char kWebMVorbisAudioVP8Video[] = "video/webm; codecs=\"vorbis, vp8\"";
 
 // EME-specific test results and errors.
 const char kEmeKeyError[] = "KEYERROR";
 const char kEmeNotSupportedError[] = "NOTSUPPORTEDERROR";
 
 const char kDefaultEmePlayer[] = "eme_player.html";
 
 // The type of video src used to load media.
 enum SrcType {
@@ skipping 72 matching lines @@
   // We want to fail quickly when a test fails because an error is encountered.
   void AddTitlesToAwait(content::TitleWatcher* title_watcher) override {
     MediaBrowserTest::AddTitlesToAwait(title_watcher);
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeNotSupportedError));
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeKeyError));
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kDisableGestureRequirementForMediaPlayback);
-#if defined(OS_ANDROID)
+#if defined(SUPPORTS_EXTERNAL_CLEAR_KEY_IN_CONTENT_SHELL)
     command_line->AppendSwitchASCII(switches::kEnableFeatures,
                                     media::kExternalClearKeyForTesting.name);
 #endif
   }
 };
 
 using ::testing::Combine;
 using ::testing::Values;
 
+#if defined(SUPPORTS_CLEAR_KEY_IN_CONTENT_SHELL)
 INSTANTIATE_TEST_CASE_P(SRC_ClearKey, EncryptedMediaTest,
                         Combine(Values(kClearKeyKeySystem), Values(SRC)));
 
 INSTANTIATE_TEST_CASE_P(MSE_ClearKey, EncryptedMediaTest,
                         Combine(Values(kClearKeyKeySystem), Values(MSE)));
+#endif
 
-#if !defined(DISABLE_ENCRYPTED_MEDIA_PLAYBACK_TESTS)
+#if defined(SUPPORTS_EXTERNAL_CLEAR_KEY_IN_CONTENT_SHELL)
+INSTANTIATE_TEST_CASE_P(SRC_ExternalClearKey,
+                        EncryptedMediaTest,
+                        Combine(Values(kExternalClearKeyKeySystem),
+                                Values(SRC)));
+
+INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKey,
+                        EncryptedMediaTest,
+                        Combine(Values(kExternalClearKeyKeySystem),
+                                Values(MSE)));
+#endif
+
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) {
   TestSimplePlayback("bear-a_enc-a.webm", kWebMVorbisAudioOnly);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) {
   TestSimplePlayback("bear-320x240-av_enc-a.webm", kWebMVorbisAudioVP8Video);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoAudio_WebM) {
   TestSimplePlayback("bear-320x240-av_enc-av.webm", kWebMVorbisAudioVP8Video);
@@ skipping 42 matching lines @@
   TestSimplePlayback("bear-320x240-opus-av_enc-v.webm", kWebMOpusAudioVP9Video);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, ConfigChangeVideo) {
   TestConfigChange();
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, FrameSizeChangeVideo) {
   TestFrameSizeChange();
 }
-#endif  // !defined(DISABLE_ENCRYPTED_MEDIA_PLAYBACK_TESTS)
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaTest, UnknownKeySystemThrowsException) {
   RunEncryptedMediaTest(kDefaultEmePlayer, "bear-a_enc-a.webm",
                         kWebMVorbisAudioOnly, "com.example.foo", MSE,
                         kEmeNotSupportedError);
 }
 
-#if defined(OS_ANDROID)
-// On Android, External Clear Key is supported in //content/shell/ by using mojo
-// CDM with AesDecryptor running in the GPU process.
-// On other platforms, External Clear Key is supported in chrome/, so it is
-// tested in browser_tests.
-IN_PROC_BROWSER_TEST_F(EncryptedMediaTest, ExternalClearKeyPlayback) {
-  RunSimpleEncryptedMediaTest("bear-320x240-av_enc-av.webm",
-                              kWebMVorbisAudioVP8Video,
-                              kExternalClearKeyKeySystem, MSE);
-}
-#endif
-
 }  // namespace content