Revert of Move ENABLE_PEPPER_CDMS to a buildflag header.

chrome/browser/media/encrypted_media_supported_types_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 <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 10 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
 #include "media/media_features.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
-#include "ppapi/features/features.h"
 #include "url/gurl.h"
 
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(ENABLE_PEPPER_CDMS)
 #include "chrome/browser/media/pepper_cdm_test_constants.h"
 #include "chrome/browser/media/pepper_cdm_test_helper.h"
 #endif
 
 #if defined(OS_ANDROID)
 #error This file needs to be updated to run on Android.
 #endif
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
@@ skipping 27 matching lines @@
 #define EXPECT_UNKNOWN_KEYSYSTEM(test) EXPECT_EQ(kUnsupportedResult, test)
 #define EXPECT_NO_MATCH(test) EXPECT_EQ(kNoMatchResult, test)
 
 #if defined(USE_PROPRIETARY_CODECS)
 #define EXPECT_PROPRIETARY EXPECT_SUCCESS
 #else
 #define EXPECT_PROPRIETARY EXPECT_NO_MATCH
 #endif
 
 // Expectations for External Clear Key.
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(ENABLE_PEPPER_CDMS)
 #define EXPECT_ECK EXPECT_SUCCESS
 #define EXPECT_ECK_PROPRIETARY EXPECT_PROPRIETARY
 #define EXPECT_ECK_NO_MATCH EXPECT_NO_MATCH
 #else
 #define EXPECT_ECK EXPECT_UNKNOWN_KEYSYSTEM
 #define EXPECT_ECK_PROPRIETARY EXPECT_UNKNOWN_KEYSYSTEM
 #define EXPECT_ECK_NO_MATCH EXPECT_UNKNOWN_KEYSYSTEM
-#endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
+#endif  // defined(ENABLE_PEPPER_CDMS)
 
 // Expectations for Widevine.
 #if defined(WIDEVINE_CDM_AVAILABLE)
 #define EXPECT_WV_SUCCESS EXPECT_SUCCESS
 #define EXPECT_WV_PROPRIETARY EXPECT_PROPRIETARY
 #define EXPECT_WV_NO_MATCH EXPECT_NO_MATCH
 #else  // defined(WIDEVINE_CDM_AVAILABLE)
 #define EXPECT_WV_SUCCESS EXPECT_UNKNOWN_KEYSYSTEM
 #define EXPECT_WV_PROPRIETARY EXPECT_UNKNOWN_KEYSYSTEM
 #define EXPECT_WV_NO_MATCH EXPECT_UNKNOWN_KEYSYSTEM
@@ skipping 60 matching lines @@
   const CodecVector& no_codecs() const { return no_codecs_; }
   const CodecVector& audio_webm_codecs() const { return audio_webm_codecs_; }
   const CodecVector& video_webm_codecs() const { return video_webm_codecs_; }
   const CodecVector& audio_mp4_codecs() const { return audio_mp4_codecs_; }
   const CodecVector& video_mp4_codecs() const { return video_mp4_codecs_; }
   const CodecVector& video_mp4_hi10p_codecs() const {
     return video_mp4_hi10p_codecs_;
   }
   const CodecVector& invalid_codecs() const { return invalid_codecs_; }
 
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(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)
+#endif  // defined(ENABLE_PEPPER_CDMS)
 
   void SetUpOnMainThread() override {
     InProcessBrowserTest::SetUpOnMainThread();
 
     // Load the test page needed so that checkKeySystemWithMediaMimeType()
     // is available.
     std::unique_ptr<net::EmbeddedTestServer> http_test_server(
         new net::EmbeddedTestServer);
     http_test_server->ServeFilesFromSourceDirectory(media::GetTestDataPath());
     CHECK(http_test_server->Start());
@@ skipping 84 matching lines @@
 };
 
 // For ClearKey, nothing additional is required.
 class EncryptedMediaSupportedTypesClearKeyTest
     : public EncryptedMediaSupportedTypesTest {
 };
 
 // For ExternalClearKey tests, ensure that the ClearKey adapter is loaded.
 class EncryptedMediaSupportedTypesExternalClearKeyTest
     : public EncryptedMediaSupportedTypesTest {
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(ENABLE_PEPPER_CDMS)
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaSupportedTypesTest::SetUpCommandLine(command_line);
     RegisterPepperCdm(command_line, kClearKeyCdmBaseDirectory,
                       kClearKeyCdmAdapterFileName, kClearKeyCdmDisplayName,
                       kClearKeyCdmPepperMimeType);
     command_line->AppendSwitchASCII(switches::kEnableFeatures,
                                     media::kExternalClearKeyForTesting.name);
   }
-#endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
+#endif  // defined(ENABLE_PEPPER_CDMS)
 };
 
 // By default, the External Clear Key (ECK) key system is not supported even if
 // present. This test case tests this behavior by not enabling
 // kExternalClearKeyForTesting.
 // Even registering the Pepper CDM where applicable does not enable the CDM.
 class EncryptedMediaSupportedTypesExternalClearKeyNotEnabledTest
     : public EncryptedMediaSupportedTypesTest {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaSupportedTypesTest::SetUpCommandLine(command_line);
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(ENABLE_PEPPER_CDMS)
     RegisterPepperCdm(command_line, kClearKeyCdmBaseDirectory,
                       kClearKeyCdmAdapterFileName, kClearKeyCdmDisplayName,
                       kClearKeyCdmPepperMimeType);
-#endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
+#endif  // defined(ENABLE_PEPPER_CDMS)
   }
 };
 
 class EncryptedMediaSupportedTypesWidevineTest
     : public EncryptedMediaSupportedTypesTest {
 };
 
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(ENABLE_PEPPER_CDMS)
 // Registers ClearKey CDM with the wrong path (filename).
 class EncryptedMediaSupportedTypesClearKeyCDMRegisteredWithWrongPathTest
     : public EncryptedMediaSupportedTypesTest {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaSupportedTypesTest::SetUpCommandLine(command_line);
     RegisterPepperCdm(command_line, kClearKeyCdmBaseDirectory,
                       "clearkeycdmadapterwrongname.dll",
                       kClearKeyCdmDisplayName, kClearKeyCdmPepperMimeType,
                       false);
     command_line->AppendSwitchASCII(switches::kEnableFeatures,
                                     media::kExternalClearKeyForTesting.name);
   }
 };
 
 // Registers Widevine CDM with the wrong path (filename).
 class EncryptedMediaSupportedTypesWidevineCDMRegisteredWithWrongPathTest
     : public EncryptedMediaSupportedTypesTest {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaSupportedTypesTest::SetUpCommandLine(command_line);
     RegisterPepperCdm(command_line, "WidevineCdm",
                       "widevinecdmadapterwrongname.dll",
                       "Widevine Content Decryption Module",
                       "application/x-ppapi-widevine-cdm", false);
   }
 };
 
-#endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
+#endif  // defined(ENABLE_PEPPER_CDMS)
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesClearKeyTest, Basic) {
   EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, no_codecs(), kClearKey));
   EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, no_codecs(), kClearKey));
   EXPECT_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, no_codecs(), kClearKey));
   EXPECT_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, no_codecs(), kClearKey));
@@ skipping 111 matching lines @@
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, audio_webm_codecs(), kClearKey));
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, video_webm_codecs(), kClearKey));
 }
 
 //
 // External Clear Key
 //
 
-// When BUILDFLAG(ENABLE_PEPPER_CDMS), this also tests the Pepper CDM check.
+// When defined(ENABLE_PEPPER_CDMS), this also tests the Pepper CDM check.
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesExternalClearKeyTest,
                        Basic) {
   EXPECT_ECK(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, no_codecs(), kExternalClearKey));
   EXPECT_ECK(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, no_codecs(), kExternalClearKey));
   EXPECT_ECK_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, no_codecs(), kExternalClearKey));
   EXPECT_ECK_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, no_codecs(), kExternalClearKey));
@@ skipping 204 matching lines @@
 
   // Invalid or Non-MP4 codec.
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, invalid_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, audio_webm_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, video_webm_codecs(), kWidevine));
 }
 
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+#if defined(ENABLE_PEPPER_CDMS)
 // Since this test fixture does not register the CDMs on the command line, the
 // check for the CDMs in chrome_key_systems.cc should fail, and they should not
 // be registered with KeySystems.
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesTest,
                        PepperCDMsNotRegistered) {
   EXPECT_UNKNOWN_KEYSYSTEM(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, no_codecs(), kExternalClearKey));
 
 // This will fail in all builds unless widevine is available.
 #if !defined(WIDEVINE_CDM_AVAILABLE)
@@ skipping 26 matching lines @@
     EncryptedMediaSupportedTypesWidevineCDMRegisteredWithWrongPathTest,
     PepperCDMsRegisteredButAdapterNotPresent) {
   EXPECT_UNKNOWN_KEYSYSTEM(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, no_codecs(), kWidevine));
 
   // Clear Key should still be registered.
   EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, no_codecs(), kClearKey));
 }
 #endif  // !defined(WIDEVINE_CDM_AVAILABLE)
-#endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
-
+#endif  // defined(ENABLE_PEPPER_CDMS)
 }  // namespace chrome