cdm_registry_impl.cc | Explore in Territory

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/media/cdm_registry_impl.h"

#include <stddef.h>

#include "base/check.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/no_destructor.h"
#include "base/strings/string_split.h"
#include "base/task/bind_post_task.h"
#include "base/types/optional_util.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "content/public/common/cdm_info.h"
#include "content/public/common/content_client.h"
#include "content/public/common/content_switches.h"
#include "media/base/key_system_capability.h"
#include "media/base/key_system_names.h"
#include "media/base/key_systems.h"
#include "media/base/media_switches.h"
#include "media/base/video_codecs.h"
#include "media/media_buildflags.h"
#include "media/mojo/buildflags.h"

#if BUILDFLAG(IS_ANDROID)
#include "content/browser/media/key_system_support_android.h"
#include "media/base/android/media_drm_bridge.h"
#endif

#if BUILDFLAG(IS_WIN)
#include "content/browser/gpu/gpu_data_manager_impl.h"
#include "content/browser/media/key_system_support_win.h"
#include "gpu/config/gpu_driver_bug_workaround_type.h"
#endif

namespace content {

namespace {

bool MatchKeySystem(const CdmInfo& cdm_info, const std::string& key_system) { … }

// Reports whether the software secure CDM is available.
void ReportSoftwareSecureCdmAvailableUMA(const std::string& key_system,
                                         bool available) { … }

constexpr media::VideoCodec kVideoCodecsToReportToUma[] = …;

// Reports the status and capabilities of the hardware secure CDM. Only reported
// once per browser session per `key_system`.
void ReportHardwareSecureCapabilityStatusUMA(
    const std::string& key_system,
    CdmInfo::Status status,
    const media::CdmCapability* hw_secure_capability) { … }

bool IsEnabled(CdmInfo::Status status) { … }

// Returns a CdmCapability with codecs specified on command line. Returns null
// if kOverrideHardwareSecureCodecsForTesting was not specified or not valid
// codecs specified.
std::optional<media::CdmCapability>
GetHardwareSecureCapabilityOverriddenFromCommandLine() { … }

#if BUILDFLAG(IS_WIN)
bool IsMediaFoundationHardwareSecurityDisabledByGpuFeature() {
  auto* gpu_data_manager = GpuDataManagerImpl::GetInstance();
  DCHECK(gpu_data_manager->IsGpuFeatureInfoAvailable());
  return gpu_data_manager->GetGpuFeatureInfo().IsWorkaroundEnabled(
      gpu::DISABLE_MEDIA_FOUNDATION_HARDWARE_SECURITY);
}

bool IsGpuHardwareCompositionDisabled() {
  auto* gpu_data_manager = GpuDataManagerImpl::GetInstance();
  return gpu_data_manager->IsGpuCompositingDisabled() ||
         !gpu_data_manager->GetGPUInfo().overlay_info.direct_composition;
}

bool IsGpuSoftwareEmulated() {
  auto* gpu_data_manager = GpuDataManagerImpl::GetInstance();
  const bool is_gpu_software_emulated =
      gpu_data_manager->GetGPUInfo().active_gpu().IsSoftwareRenderer();
  return is_gpu_software_emulated;
}
#endif  // BUILDFLAG(IS_WIN)

}  // namespace

// static
CdmRegistry* CdmRegistry::GetInstance() { … }

// static
CdmRegistryImpl* CdmRegistryImpl::GetInstance() { … }

CdmRegistryImpl::CdmRegistryImpl() { … }

CdmRegistryImpl::~CdmRegistryImpl() { … }

void CdmRegistryImpl::Init() { … }

void CdmRegistryImpl::RegisterCdm(const CdmInfo& info) { … }

void CdmRegistryImpl::SetHardwareSecureCdmStatus(CdmInfo::Status status) { … }

void CdmRegistryImpl::OnGpuInfoUpdate() { … }

const std::vector<CdmInfo>& CdmRegistryImpl::GetRegisteredCdms() const { … }

std::unique_ptr<CdmInfo> CdmRegistryImpl::GetCdmInfo(
    const std::string& key_system,
    CdmInfo::Robustness robustness) const { … }

base::CallbackListSubscription CdmRegistryImpl::ObserveKeySystemCapabilities(
    bool allow_hw_secure_capability_check,
    KeySystemCapabilitiesUpdateCB cb) { … }

std::pair<std::optional<media::CdmCapability>, CdmInfo::Status>
CdmRegistryImpl::GetCapability(const std::string& key_system,
                               CdmInfo::Robustness robustness) { … }

std::pair<std::optional<media::CdmCapability>, CdmInfo::Status>
CdmRegistryImpl::GetFinalCapability(const std::string& key_system,
                                    CdmInfo::Robustness robustness) { … }

void CdmRegistryImpl::FinalizeKeySystemCapabilities() { … }

void CdmRegistryImpl::AttemptToFinalizeKeySystemCapability(
    const std::string& key_system,
    CdmInfo::Robustness robustness) { … }

// TODO(xhwang): Find a way to register this as callbacks so we don't have to
// hardcode platform-specific logic here.
void CdmRegistryImpl::LazyInitializeCapability(
    const std::string& key_system,
    CdmInfo::Robustness robustness,
    media::CdmCapabilityCB cdm_capability_cb) { … }

void CdmRegistryImpl::OnCapabilityInitialized(
    const std::string& key_system,
    const CdmInfo::Robustness robustness,
    std::optional<media::CdmCapability> cdm_capability) { … }

void CdmRegistryImpl::FinalizeCapability(
    const std::string& key_system,
    const CdmInfo::Robustness robustness,
    std::optional<media::CdmCapability> cdm_capability,
    CdmInfo::Status status) { … }

void CdmRegistryImpl::UpdateAndNotifyKeySystemCapabilities() { … }

std::set<std::string> CdmRegistryImpl::GetSupportedKeySystems() const { … }

KeySystemCapabilities CdmRegistryImpl::GetKeySystemCapabilities() { … }

void CdmRegistryImpl::SetCapabilityCBForTesting(CapabilityCB cb) { … }

}  // namespace content
chromium/content/browser/media/cdm_registry_impl.cc
