Allow hw secured codecs on chromecast

media/base/key_systems.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 "media/base/key_systems.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 570 matching lines @@
   // Look up the key system's supported codecs.
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
 
   SupportedCodecs key_system_codec_mask =
       key_system_iter->second->GetSupportedCodecs();
-#if defined(OS_ANDROID)
+#if BUILDFLAG(ENABLE_HW_SECURE_CODEC)
   SupportedCodecs key_system_secure_codec_mask =
       key_system_iter->second->GetSupportedSecureCodecs();
-#endif  // defined(OS_ANDROID)
+#endif  // BUILDFLAG(ENABLE_HW_SECURE_CODEC)
 
   // Check that the container is supported by the key system. (This check is
   // necessary because |codecs| may be empty.)
   SupportedCodecs mime_type_codec_mask =
       GetCodecMaskForMimeType(container_mime_type);
   if ((key_system_codec_mask & mime_type_codec_mask) == 0)
     return EmeConfigRule::NOT_SUPPORTED;
 
   // Check that the codecs are supported by the key system and container.
   EmeConfigRule support = EmeConfigRule::SUPPORTED;
   for (size_t i = 0; i < codecs.size(); i++) {
     SupportedCodecs codec = GetCodecForString(codecs[i]);
     if ((codec & key_system_codec_mask & mime_type_codec_mask) == 0)
       return EmeConfigRule::NOT_SUPPORTED;
-#if defined(OS_ANDROID)
+#if BUILDFLAG(ENABLE_HW_SECURE_CODEC)
     // Check whether the codec supports a hardware-secure mode. The goal is to
     // prevent mixing of non-hardware-secure codecs with hardware-secure codecs,
     // since the mode is fixed at CDM creation.
     //
     // Because the check for regular codec support is early-exit, we don't have
     // to consider codecs that are only supported in hardware-secure mode. We
     // could do so, and make use of HW_SECURE_CODECS_REQUIRED, if it turns out
     // that hardware-secure-only codecs actually exist and are useful.
     if ((codec & key_system_secure_codec_mask) == 0)
       support = EmeConfigRule::HW_SECURE_CODECS_NOT_ALLOWED;
-#endif  // defined(OS_ANDROID)
+#endif  // BUILDFLAG(ENABLE_HW_SECURE_CODEC)
   }
 
   return support;
 }
 
 EmeConfigRule KeySystemsImpl::GetRobustnessConfigRule(
     const std::string& key_system,
     EmeMediaType media_type,
     const std::string& requested_robustness) const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 97 matching lines @@
                                uint32_t mask) {
   KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
 }
 
 MEDIA_EXPORT void AddMimeTypeCodecMask(const std::string& mime_type,
                                        uint32_t mask) {
   KeySystemsImpl::GetInstance()->AddMimeTypeCodecMask(mime_type, mask);
 }
 
 }  // namespace media