Flip unified media pipeline to default-on w/ disabled holdback.

media/base/key_systems_unittest.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.
 
 // TODO(sandersd): Refactor to remove recomputed codec arrays, and generally
 // shorten and improve coverage.
 //   - http://crbug.com/417444
 //   - http://crbug.com/457438
 // TODO(sandersd): Add tests to cover codec vectors with empty items.
 // http://crbug.com/417461
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "media/base/eme_constants.h"
 #include "media/base/key_system_info.h"
 #include "media/base/key_systems.h"
+#include "media/base/media.h"
 #include "media/base/media_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // These are the (fake) key systems that are registered for these tests.
 // kUsesAes uses the AesDecryptor like Clear Key.
 // kExternal uses an external CDM, such as Pepper-based or Android platform CDM.
 const char kUsesAes[] = "x-org.example.clear";
 const char kUseAesNameForUMA[] = "UseAes";
@@ skipping 62 matching lines @@
     return;
 
   AddCodecMask(EmeMediaType::AUDIO, "fooaudio", TEST_CODEC_FOO_AUDIO);
   AddCodecMask(EmeMediaType::VIDEO, "foovideo", TEST_CODEC_FOO_VIDEO);
   AddMimeTypeCodecMask("audio/foo", TEST_CODEC_FOO_AUDIO_ALL);
   AddMimeTypeCodecMask("video/foo", TEST_CODEC_FOO_VIDEO_ALL);
 
   is_test_masks_added = true;
 }
 
+static bool CanRunExternalKeySystemTests() {
+#if defined(OS_ANDROID)
+  if (HasPlatformDecoderSupport())

[ddorwin, 2016/03/30 20:16:24]

These are just key system registration tests. What causes these not to be
registered?

[DaleCurtis, 2016/03/30 22:40:15]

This is due to your change here I think:
https://code.google.com/p/chromium/codesearch#chromium/src/media/base/key_sys...

[ddorwin, 2016/03/30 22:49:38]

Thanks. I forgot that code was in KeySystems.

+    return true;
+
+  EXPECT_FALSE(IsSupportedKeySystem(kExternal));
+  return false;
+#else
+  return true;
+#endif
+}
+
 class TestMediaClient : public MediaClient {
  public:
   TestMediaClient();
   ~TestMediaClient() override;
 
   // MediaClient implementation.
   void AddKeySystemsInfoForUMA(
       std::vector<KeySystemInfoForUMA>* key_systems_info_for_uma) final;
   bool IsKeySystemsUpdateNeeded() final;
   void AddSupportedKeySystems(
@@ skipping 432 matching lines @@
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, vorbis_codec(), kUsesAes));
 }
 
 //
 // Non-AesDecryptor-based key system.
 //
 
 TEST_F(KeySystemsTest, Basic_ExternalDecryptor) {
+  if (!CanRunExternalKeySystemTests())
+    return;
+
   EXPECT_TRUE(IsSupportedKeySystem(kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternal));
 
   EXPECT_FALSE(CanUseAesDecryptor(kExternal));
 #if defined(ENABLE_PEPPER_CDMS)
   EXPECT_EQ("application/x-ppapi-external-cdm", GetPepperType(kExternal));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 }
 
 TEST_F(
     KeySystemsTest,
     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer1) {
+  if (!CanRunExternalKeySystemTests())
+    return;
+
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp80_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp9_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
@@ skipping 32 matching lines @@
       kAudioWebM, vp9_and_vorbis_codecs(), kExternal));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, fooaudio_codec(), kExternal));
 }
 
 TEST_F(
     KeySystemsTest,
     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer2) {
+  if (!CanRunExternalKeySystemTests())
+    return;
+
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_codec(), kExternal));
 
   // Audio in a video container.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_and_fooaudio_codecs(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
@@ skipping 30 matching lines @@
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, vorbis_codec(), kExternal));
 }
 
 TEST_F(KeySystemsTest, KeySystemNameForUMA) {
   EXPECT_EQ("ClearKey", GetKeySystemNameForUMA(kClearKey));
 
   // External Clear Key never has a UMA name.
-  EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kExternalClearKey));
+  if (CanRunExternalKeySystemTests())
+    EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kExternalClearKey));
 }
 
 TEST_F(KeySystemsTest, KeySystemsUpdate) {
   EXPECT_TRUE(IsSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystem(kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
+
+  if (CanRunExternalKeySystemTests()) {
+    EXPECT_TRUE(IsSupportedKeySystem(kExternal));
+    EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(kVideoWebM, no_codecs(),
+                                                      kExternal));
+  }
 
   UpdateClientKeySystems();
 
   EXPECT_TRUE(IsSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUsesAes));
-  EXPECT_FALSE(IsSupportedKeySystem(kExternal));
+  if (CanRunExternalKeySystemTests()) {

[ddorwin, 2016/03/30 20:16:24]

Use of braces is inconsistent with 690. Pick one?

[DaleCurtis, 2016/03/31 22:10:33]

Done.

+    EXPECT_FALSE(IsSupportedKeySystem(kExternal));
+  }
 }
 
 TEST_F(KeySystemsPotentiallySupportedNamesTest, PotentiallySupportedNames) {
   EXPECT_FALSE(IsSupportedKeySystem("org.w3"));
   EXPECT_FALSE(IsSupportedKeySystem("org.w3."));
   EXPECT_FALSE(IsSupportedKeySystem("org.w3.clearke"));
   EXPECT_TRUE(IsSupportedKeySystem("org.w3.clearkey"));
   EXPECT_FALSE(IsSupportedKeySystem("org.w3.clearkeys"));
 
   EXPECT_FALSE(IsSupportedKeySystem("com.widevine"));
@@ skipping 22 matching lines @@
   EXPECT_FALSE(IsSupportedKeySystem("com.chromecast.something.else"));
   EXPECT_FALSE(IsSupportedKeySystem("com.chromecast.other"));
 
   EXPECT_FALSE(IsSupportedKeySystem("x-"));
   EXPECT_TRUE(IsSupportedKeySystem("x-something"));
   EXPECT_FALSE(IsSupportedKeySystem("x-something.else"));
   EXPECT_FALSE(IsSupportedKeySystem("x-other"));
 }
 
 }  // namespace media