chromium/content/browser/media/cdm_storage_manager.cc

// Copyright 2023 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_storage_manager.h"

#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "base/task/thread_pool.h"
#include "base/types/pass_key.h"
#include "content/browser/media/cdm_storage_common.h"
#include "content/public/common/content_features.h"
#include "media/cdm/cdm_type.h"
#include "media/mojo/mojom/cdm_storage.mojom.h"

namespace content {

namespace {

const char kUmaPrefix[] = …;

const char kGetSizeForFileError[] = …;
const char kGetSizeForStorageKeyError[] = …;
const char kGetSizeForTimeFrameError[] = …;
const char kWriteFileError[] = …;
const char kReadFileError[] = …;
const char kDatabaseOpenErrorNoPeriod[] = …;
const char kDatabaseOpenError[] = …;

// Creates a task runner suitable for running SQLite database operations.
scoped_refptr<base::SequencedTaskRunner> CreateDatabaseTaskRunner() { … }

}  // namespace

CdmStorageManager::CdmStorageManager(const base::FilePath& path)
    : … { … }

CdmStorageManager::~CdmStorageManager() { … }

void CdmStorageManager::Open(const std::string& file_name,
                             OpenCallback callback) { … }

void CdmStorageManager::GetUsagePerAllStorageKeys(
    base::OnceCallback<void(const CdmStorageKeyUsageSize&)> callback,
    base::Time begin,
    base::Time end) { … }

void CdmStorageManager::DeleteDataForStorageKey(
    const blink::StorageKey& storage_key,
    base::OnceCallback<void(bool)> callback) { … }

void CdmStorageManager::OpenCdmStorage(
    const CdmStorageBindingContext& binding_context,
    mojo::PendingReceiver<media::mojom::CdmStorage> receiver) { … }

void CdmStorageManager::ReadFile(
    const blink::StorageKey& storage_key,
    const media::CdmType& cdm_type,
    const std::string& file_name,
    base::OnceCallback<void(std::optional<std::vector<uint8_t>>)> callback) { … }

void CdmStorageManager::WriteFile(const blink::StorageKey& storage_key,
                                  const media::CdmType& cdm_type,
                                  const std::string& file_name,
                                  const std::vector<uint8_t>& data,
                                  base::OnceCallback<void(bool)> callback) { … }

void CdmStorageManager::GetSizeForFile(
    const blink::StorageKey& storage_key,
    const media::CdmType& cdm_type,
    const std::string& file_name,
    base::OnceCallback<void(uint64_t)> callback) { … }

void CdmStorageManager::GetSizeForStorageKey(
    const blink::StorageKey& storage_key,
    const base::Time begin,
    const base::Time end,
    base::OnceCallback<void(uint64_t)> callback) { … }

void CdmStorageManager::GetSizeForTimeFrame(
    const base::Time begin,
    const base::Time end,
    base::OnceCallback<void(uint64_t)> callback) { … }

void CdmStorageManager::DeleteFile(const blink::StorageKey& storage_key,
                                   const media::CdmType& cdm_type,
                                   const std::string& file_name,
                                   base::OnceCallback<void(bool)> callback) { … }

void CdmStorageManager::DeleteData(
    const StoragePartition::StorageKeyMatcherFunction& storage_key_matcher,
    const blink::StorageKey& storage_key,
    const base::Time begin,
    const base::Time end,
    base::OnceCallback<void(bool)> callback) { … }

void CdmStorageManager::OnFileReceiverDisconnect(
    const std::string& name,
    const media::CdmType& cdm_type,
    const blink::StorageKey& storage_key,
    base::PassKey<CdmFileImpl> pass_key) { … }

void CdmStorageManager::DidOpenFile(const blink::StorageKey& storage_key,
                                    const media::CdmType& cdm_type,
                                    const std::string& file_name,
                                    OpenCallback callback,
                                    CdmStorageOpenError error) { … }

void CdmStorageManager::DidReadFile(
    base::OnceCallback<void(std::optional<std::vector<uint8_t>>)> callback,
    std::optional<std::vector<uint8_t>> data) { … }

void CdmStorageManager::DidWriteFile(base::OnceCallback<void(bool)> callback,
                                     bool success) { … }

void CdmStorageManager::DidGetSize(base::OnceCallback<void(uint64_t)> callback,
                                   const std::string& operation,
                                   std::optional<uint64_t> size) { … }

// TODO(crbug.com/40272342) Investigate if we can propagate the SQL errors.
// Investigate adding delete functionality to 'MojoCdmHelper::CloseCdmFileIO' to
// close database on CdmFileIO closure.

void CdmStorageManager::ReportDatabaseOpenError(CdmStorageOpenError error) { … }

}  // namespace content