Replace WIDEVINE_CDM_AVAILABLE with a gyp define 'enable_widevine_cdm'.

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 94 matching lines @@
 // Base class for encrypted media tests.
 class EncryptedMediaTestBase : public MediaBrowserTest {
  public:
   EncryptedMediaTestBase() : is_pepper_cdm_registered_(false) {}
 
   bool IsExternalClearKey(const std::string& key_system) {
     return key_system == kExternalClearKeyKeySystem ||
            IsParentKeySystemOf(kExternalClearKeyKeySystem, key_system);
   }
 
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
   bool IsWidevine(const std::string& key_system) {
     return key_system == kWidevineKeySystem;
   }
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_WIDEVINE_CDM)
 
   void RunEncryptedMediaTestPage(
       const std::string& html_page,
       const std::string& key_system,
       base::StringPairs& query_params,
       const std::string& expected_title) {
     base::StringPairs new_query_params = query_params;
     StartLicenseServerIfNeeded(key_system, &new_query_params);
     RunMediaTestPage(html_page, new_query_params, expected_title, true);
   }
@@ skipping 70 matching lines @@
     scoped_ptr<TestLicenseServerConfig> config = GetServerConfig(key_system);
     if (!config)
       return;
     license_server_.reset(new TestLicenseServer(config.Pass()));
     EXPECT_TRUE(license_server_->Start());
     query_params->push_back(
         std::make_pair("licenseServerURL", license_server_->GetServerURL()));
   }
 
   bool IsPlayBackPossible(const std::string& key_system) {
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
     if (IsWidevine(key_system) && !GetServerConfig(key_system))
       return false;
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_WIDEVINE_CDM)
     return true;
   }
 
   scoped_ptr<TestLicenseServerConfig> GetServerConfig(
       const std::string& key_system) {
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
     if (IsWidevine(key_system)) {
       scoped_ptr<TestLicenseServerConfig> config =
          scoped_ptr<TestLicenseServerConfig>(new WVTestLicenseServerConfig());
       if (config->IsPlatformSupported())
         return config.Pass();
     }
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_WIDEVINE_CDM)
     return scoped_ptr<TestLicenseServerConfig>();
   }
 
  protected:
   scoped_ptr<TestLicenseServer> license_server_;
 
   // We want to fail quickly when a test fails because an error is encountered.
   void AddWaitForTitles(content::TitleWatcher* title_watcher) override {
     MediaBrowserTest::AddWaitForTitles(title_watcher);
     title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEmeNotSupportedError));
@@ skipping 12 matching lines @@
     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 defined(ENABLE_PEPPER_CDMS)
     if (IsExternalClearKey(key_system)) {
       RegisterPepperCdm(command_line, kClearKeyCdmAdapterFileName, key_system);
     }
-#if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
+#if defined(ENABLE_WIDEVINE_CDM) && defined(WIDEVINE_CDM_IS_COMPONENT)
     else if (IsWidevine(key_system)) {  // NOLINT
       RegisterPepperCdm(command_line, kWidevineCdmAdapterFileName, key_system);
     }
-#endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
+#endif  // defined(ENABLE_WIDEVINE_CDM) && defined(WIDEVINE_CDM_IS_COMPONENT)
 #endif  // defined(ENABLE_PEPPER_CDMS)
   }
 
  private:
 #if defined(ENABLE_PEPPER_CDMS)
   void RegisterPepperCdm(CommandLine* command_line,
                          const std::string& adapter_name,
                          const std::string& key_system) {
     DCHECK(!is_pepper_cdm_registered_)
         << "RegisterPepperCdm() can only be called once.";
@@ skipping 12 matching lines @@
     pepper_plugin.append(GetPepperType(key_system));
 #endif
     command_line->AppendSwitchNative(switches::kRegisterPepperPlugins,
                                      pepper_plugin);
   }
 
   // Adapted from key_systems.cc.
   std::string GetPepperType(const std::string& key_system) {
     if (IsExternalClearKey(key_system))
       return kClearKeyCdmPluginMimeType;
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
     if (IsWidevine(key_system))
       return kWidevineCdmPluginMimeType;
-#endif  // WIDEVINE_CDM_AVAILABLE
+#endif  // ENABLE_WIDEVINE_CDM
 
     NOTREACHED();
     return "";
   }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
   bool is_pepper_cdm_registered_;
 };
 
 #if defined(ENABLE_PEPPER_CDMS)
@@ skipping 31 matching lines @@
 // enabled by default.
 class ECKUnprefixedEncryptedMediaTest : public EncryptedMediaTestBase {
  protected:
   void SetUpCommandLine(CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kEnableEncryptedMedia);
     SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
   }
 };
 
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
 // Tests encrypted media playback using Widevine key system.
 class WVEncryptedMediaTest : public EncryptedMediaTestBase {
  protected:
   virtual void SetUpCommandLine(CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kEnableEncryptedMedia);
     SetUpCommandLineForKeySystem(kWidevineKeySystem, command_line);
   }
 };
 
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_WIDEVINE_CDM)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 // Tests encrypted media playback with a combination of parameters:
 // - char*: Key system name.
 // - bool: True to load media using MSE, otherwise use src.
 // - bool: True to use unprefixed EME, otherwise use prefixed EME.
 //
 // 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).
@@ skipping 129 matching lines @@
                         Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
                                 Values(MSE),
                                 Values(PREFIXED)));
 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly,
                         EncryptedMediaTest,
                         Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
                                 Values(MSE),
                                 Values(UNPREFIXED)));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
 // This test doesn't fully test playback with Widevine. So we only run Widevine
 // 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_Prefixed,
                         EncryptedMediaTest,
                         Combine(Values(kWidevineKeySystem),
                                 Values(MSE),
                                 Values(PREFIXED)));
 
 // Following tests fail if Widevine is loaded as a component, crbug.com/356833.
 #if !defined(WIDEVINE_CDM_IS_COMPONENT)
 INSTANTIATE_TEST_CASE_P(MSE_Widevine,
                         EncryptedMediaTest,
                         Combine(Values(kWidevineKeySystem),
                                 Values(MSE),
                                 Values(UNPREFIXED)));
 #endif  // !defined(WIDEVINE_CDM_IS_COMPONENT)
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_WIDEVINE_CDM)
 
 // These tests time out in Chrome OS official builds. http://crbug.com/430711
 #if !(defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
 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);
 }
@@ skipping 69 matching lines @@
   // MP4 without MSE is not support yet, http://crbug.com/170793.
   if (CurrentSourceType() != MSE) {
     DVLOG(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)
 #endif  // !(defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
 
-#if defined(WIDEVINE_CDM_AVAILABLE)
+#if defined(ENABLE_WIDEVINE_CDM)
 // The parent key system cannot be used in generateKeyRequest.
 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException_Prefixed) {
   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(kDefaultEmePlayer,
                         "bear-a_enc-a.webm",
                         kWebMAudioOnly,
                         "com.widevine",
                         MSE,
                         UNPREFIXED,
                         kNoSessionToLoad,
                         false,
                         kEmeNotSupportedError);
 }
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_WIDEVINE_CDM)
 
 #if defined(ENABLE_PEPPER_CDMS)
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, InitializeCDMFail) {
   TestNonPlaybackCases(kExternalClearKeyInitializeFailKeySystem, kEmeKeyError);
 }
 
 // When CDM crashes, we should still get a decode error.
 // crbug.com/386657
 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, DISABLED_CDMCrashDuringDecode) {
   IgnorePluginCrash();
@@ skipping 57 matching lines @@
                         "bear-320x240-v_enc-v.webm",
                         kWebMVideoOnly,
                         kExternalClearKeyKeySystem,
                         SRC,
                         UNPREFIXED,
                         kUnknownSession,
                         false,
                         kEmeKeyError);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)