Do not run MSE related tests when MSE is not available.

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"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/test/browser_test_utils.h"
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"
+#endif
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(OS_LINUX)
 #include <gnu/libc-version.h>
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(OS_LINUX)
 
 #if defined(ENABLE_PEPPER_CDMS)
 // Platform-specific filename relative to the chrome executable.
 const char kClearKeyCdmAdapterFileName[] =
@@ skipping 25 matching lines @@
 // EME-specific test results and errors.
 const char kEmeGkrException[] = "GENERATE_KEY_REQUEST_EXCEPTION";
 const char kEmeKeyError[] = "KEYERROR";
 
 // The type of video src used to load media.
 enum SrcType {
   SRC,
   MSE
 };
 
+// MSE is available on all desktop platforms and on Android 4.1 and later.
+static bool IsMSESupported() {
+#if defined(OS_ANDROID)
+  if (base::android::BuildInfo::GetInstance()->sdk_int() < 16) {
+    LOG(INFO) << "MSE is only supported in JellyBean and later.";

[ddorwin, 2013/10/17 00:59:56]

You have more room to add a space and even 4.1. :)

+    return false;
+  }
+#endif  // defined(OS_ANDROID)
+  return true;
+}
+
 // Tests encrypted media playback with a combination of parameters:
 // - char*: Key system name.
 // - bool: True to load media using MSE, otherwise use src.
 class EncryptedMediaTest : public MediaBrowserTest,
   public testing::WithParamInterface<std::tr1::tuple<const char*, SrcType> > {
  public:
   // Can only be used in parameterized (*_P) tests.
   const char* CurrentKeySystem() {
     return std::tr1::get<0>(GetParam());
   }
@@ skipping 20 matching lines @@
       LOG(INFO) << "FrameSizeChange test cannot run with Widevine.";
       return;
     }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
     RunEncryptedMediaTest("encrypted_frame_size_change.html",
                           "frame_size_change-av-enc-v.webm", kWebMAudioVideo,
                           CurrentKeySystem(), CurrentSourceType(), kEnded);
   }
 
   void TestConfigChange() {
+    if (CurrentSourceType() != MSE || !IsMSESupported()) {
+      LOG(INFO) << "Skipping test - config change test requires MSE.";
+      return;
+    }
+
 #if defined(WIDEVINE_CDM_AVAILABLE)
     if (IsWidevine(CurrentKeySystem())) {
       LOG(INFO) << "ConfigChange test cannot run with Widevine.";
       return;
     }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
+
     std::vector<StringPair> query_params;
     query_params.push_back(std::make_pair("keysystem", CurrentKeySystem()));
     query_params.push_back(std::make_pair("runencrypted", "1"));
     RunMediaTestPage("mse_config_change.html", &query_params, kEnded, true);
   }
 
   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()) {
+      LOG(INFO) << "Skipping test - MSE not supported.";
+      return;
+    }
+
     std::vector<StringPair> query_params;
     query_params.push_back(std::make_pair("mediafile", media_file));
     query_params.push_back(std::make_pair("mediatype", media_type));
     query_params.push_back(std::make_pair("keysystem", key_system));
     if (src_type == MSE)
       query_params.push_back(std::make_pair("usemse", "1"));
     RunMediaTestPage(html_page, &query_params, expectation, true);
   }
 
   void RunSimpleEncryptedMediaTest(const char* media_file,
@@ skipping 92 matching lines @@
     if (key_system == kWidevineKeySystem)
       return kWidevineCdmPluginMimeType;
 #endif  // WIDEVINE_CDM_AVAILABLE
 
     NOTREACHED();
     return "";
   }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 };
 
-INSTANTIATE_TEST_CASE_P(ClearKey, EncryptedMediaTest,
-    ::testing::Combine(
-        ::testing::Values(kClearKeyKeySystem), ::testing::Values(SRC, MSE)));
+using Combine;
+using Values;
+
+#if !defined(OS_ANDROID)
+INSTANTIATE_TEST_CASE_P(SRC_ClearKey, EncryptedMediaTest,
+    Combine(Values(kClearKeyKeySystem), Values(SRC)));
+#endif  // !defined(OS_ANDROID)
+
+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(ExternalClearKey, EncryptedMediaTest,
-    ::testing::Combine(
-        ::testing::Values(kExternalClearKeyKeySystem),
-        ::testing::Values(SRC, MSE)));
+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 // 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.
-INSTANTIATE_TEST_CASE_P(Widevine, EncryptedMediaTest,
-    ::testing::Combine(
-        ::testing::Values(kWidevineKeySystem), ::testing::Values(MSE)));
+// 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)
-#endif // defined(ENABLE_PEPPER_CDMS)
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) {
   TestSimplePlayback("bear-a-enc_a.webm", kWebMAudioOnly);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) {
   TestSimplePlayback("bear-320x240-av-enc_a.webm", kWebMAudioVideo);
 }
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoAudio_WebM) {
@@ skipping 41 matching lines @@
 }
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 // The parent key system cannot be used in generateKeyRequest.
 IN_PROC_BROWSER_TEST_F(EncryptedMediaTest, WVParentThrowsException) {
   RunEncryptedMediaTest("encrypted_media_player.html", "bear-a-enc_a.webm",
                         kWebMAudioOnly, "com.widevine", SRC, kEmeGkrException);
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)