[Cleanup] Move all browsertests to use ScopedFeatureList to modify features

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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 263 matching lines @@
 
 #if BUILDFLAG(ENABLE_PEPPER_CDMS)
   void SetUpDefaultCommandLine(base::CommandLine* command_line) override {
     base::CommandLine default_command_line(base::CommandLine::NO_PROGRAM);
     InProcessBrowserTest::SetUpDefaultCommandLine(&default_command_line);
     test_launcher_utils::RemoveCommandLineSwitch(
         default_command_line, switches::kDisableComponentUpdate, command_line);
   }
 #endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
 
-  void SetUpCommandLineForKeySystem(const std::string& key_system,
-                                    CdmHostType cdm_host_type,
-                                    base::CommandLine* command_line) {
-    if (GetServerConfig(key_system))
-      // Since the web and license servers listen on different ports, we need to
-      // disable web-security to send license requests to the license server.
-      // TODO(shadi): Add port forwarding to the test web server configuration.
-      command_line->AppendSwitch(switches::kDisableWebSecurity);
-
+  void SetUpForKeySystem(const std::string& key_system,
+                         CdmHostType cdm_host_type) {
 #if BUILDFLAG(ENABLE_PEPPER_CDMS)
     if (IsExternalClearKey(key_system)) {
-      RegisterPepperCdm(command_line, media::kClearKeyCdmBaseDirectory,
-                        media::kClearKeyCdmAdapterFileName,
-                        media::kClearKeyCdmDisplayName,
-                        media::kClearKeyCdmPepperMimeType);
       if (cdm_host_type == CdmHostType::kMojo) {
         scoped_feature_list_.InitWithFeatures(
             {media::kExternalClearKeyForTesting, media::kMojoCdm,
              media::kSupportExperimentalCdmInterface},
             {});
       } else {
         // Pepper CDMs are conditionally compiled with or without support for
         // experimental CDMs, so media::kSupportExperimentalCdmInterface is
         // not needed as it isn't checked.
         scoped_feature_list_.InitWithFeatures(
             {media::kExternalClearKeyForTesting}, {});
       }
     } else {
       if (cdm_host_type == CdmHostType::kMojo) {
         scoped_feature_list_.InitWithFeatures(
             {media::kMojoCdm, media::kSupportExperimentalCdmInterface}, {});
       }
     }
 #endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
   }
 
+  void SetUpCommandLineForKeySystem(const std::string& key_system,
+                                    base::CommandLine* command_line) {
+    if (GetServerConfig(key_system))
+      // Since the web and license servers listen on different ports, we need to
+      // disable web-security to send license requests to the license server.
+      // TODO(shadi): Add port forwarding to the test web server configuration.
+      command_line->AppendSwitch(switches::kDisableWebSecurity);
+
+#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+    if (IsExternalClearKey(key_system)) {
+      RegisterPepperCdm(command_line, media::kClearKeyCdmBaseDirectory,
+                        media::kClearKeyCdmAdapterFileName,
+                        media::kClearKeyCdmDisplayName,
+                        media::kClearKeyCdmPepperMimeType);
+    }
+#endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
+  }
+
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 #if BUILDFLAG(ENABLE_PEPPER_CDMS)
 // Tests encrypted media playback using ExternalClearKey key system in
 // decrypt-and-decode mode.
 class ECKEncryptedMediaTest : public EncryptedMediaTestBase,
                               public testing::WithParamInterface<CdmHostType> {
  public:
+  ECKEncryptedMediaTest() {
+    SetUpForKeySystem(kExternalClearKeyKeySystem, GetParam());
+  }
+
   // 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(kDefaultEmePlayer, "bear-a_enc-a.webm",
                           kWebMVorbisAudioOnly, key_system, SrcType::SRC,
                           kNoSessionToLoad, false, PlayCount::ONCE,
                           expected_title);
   }
 
   void TestPlaybackCase(const std::string& key_system,
                         const std::string& session_to_load,
                         const std::string& expected_title) {
     RunEncryptedMediaTest(kDefaultEmePlayer, "bear-320x240-v_enc-v.webm",
                           kWebMVP8VideoOnly, key_system, SrcType::MSE,
                           session_to_load, false, PlayCount::ONCE,
                           expected_title);
   }
 
   bool IsUsingMojoCdm() const { return GetParam() == CdmHostType::kMojo; }
 
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, GetParam(),
-                                 command_line);
+    SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
   }
 };
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 // Tests encrypted media playback using Widevine key system.
 class WVEncryptedMediaTest : public EncryptedMediaTestBase {
+ public:
+  WVEncryptedMediaTest() {
+    SetUpForKeySystem(kWidevineKeySystem, CdmHostType::kPepper);
+  }
+
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(kWidevineKeySystem, CdmHostType::kPepper,
-                                 command_line);
+    SetUpCommandLineForKeySystem(kWidevineKeySystem, command_line);
   }
 };
 
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
 
 // Tests encrypted media playback with a combination of parameters:
 // - char*: Key system name.
 // - SrcType: Use MSE or SRC.
 //
 // Note: Only parameterized (*_P) tests can be used. Non-parameterized (*_F)
 // tests will crash at GetParam(). To add non-parameterized tests, use
 // EncryptedMediaTestBase or one of its subclasses (e.g. WVEncryptedMediaTest).
 class EncryptedMediaTest
     : public EncryptedMediaTestBase,
       public testing::WithParamInterface<
           std::tr1::tuple<const char*, SrcType, CdmHostType>> {
  public:
+  EncryptedMediaTest() {
+    SetUpForKeySystem(CurrentKeySystem(), CurrentCdmHostType());
+  }
+
   std::string CurrentKeySystem() {
     return std::tr1::get<0>(GetParam());
   }
 
   SrcType CurrentSourceType() {
     return std::tr1::get<1>(GetParam());
   }
 
   CdmHostType CurrentCdmHostType() { return std::tr1::get<2>(GetParam()); }
 
@@ skipping 76 matching lines @@
   }
 
   void DisableEncryptedMedia() {
     PrefService* pref_service = browser()->profile()->GetPrefs();
     pref_service->SetBoolean(prefs::kWebKitEncryptedMediaEnabled, false);
   }
 
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(CurrentKeySystem(), CurrentCdmHostType(),
-                                 command_line);
+    SetUpCommandLineForKeySystem(CurrentKeySystem(), command_line);
   }
 };
 
 using ::testing::Combine;
 using ::testing::Values;
 
 INSTANTIATE_TEST_CASE_P(MSE_ClearKey,
                         EncryptedMediaTest,
                         Combine(Values(kClearKeyKeySystem),
                                 Values(SrcType::MSE),
@@ skipping 334 matching lines @@
     DVLOG(0) << "Skipping test; Not working with mojo CDM yet.";
     return;
   }
 
   TestNonPlaybackCases(kExternalClearKeyVerifyCdmHostTestKeySystem,
                        kUnitTestSuccess);
 }
 #endif  // BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
 
 }  // namespace chrome