media_license_storage_host.cc | Explore in Territory

// Copyright 2022 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/media_license_storage_host.h"

#include <algorithm>
#include <memory>
#include <utility>
#include <vector>

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "base/sequence_checker.h"
#include "base/task/sequenced_task_runner.h"
#include "base/types/pass_key.h"
#include "components/services/storage/public/cpp/buckets/bucket_locator.h"
#include "content/browser/media/cdm_file_impl.h"
#include "content/browser/media/media_license_database.h"
#include "content/browser/media/media_license_manager.h"
#include "media/cdm/cdm_type.h"
#include "media/mojo/mojom/cdm_storage.mojom.h"
#include "mojo/public/cpp/bindings/pending_associated_remote.h"
#include "storage/browser/file_system/file_system_context.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"

namespace content {

namespace {
constexpr uint64_t kBytesPerKB = …;
constexpr int kMinDatabaseSizeKB = …;
// Used for histogram reporting, the max size of the database we expect in KB.
constexpr uint64_t kMaxDatabaseSizeKB = …;
constexpr int kSizeKBBuckets = …;
}  // namespace

// static
void MediaLicenseStorageHost::ReportDatabaseOpenError(
    MediaLicenseStorageHostOpenError error,
    bool is_incognito) { … }

MediaLicenseStorageHost::MediaLicenseStorageHost(
    MediaLicenseManager* manager,
    const storage::BucketLocator& bucket_locator)
    : … { … }

MediaLicenseStorageHost::~MediaLicenseStorageHost() { … }

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

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

void MediaLicenseStorageHost::DidOpenFile(
    const std::string& file_name,
    CdmStorageBindingContext binding_context,
    OpenCallback callback,
    MediaLicenseStorageHostOpenError error) { … }

void MediaLicenseStorageHost::ReadFile(const media::CdmType& cdm_type,
                                       const std::string& file_name,
                                       ReadFileCallback callback) { … }

void MediaLicenseStorageHost::DidReadFile(
    const media::CdmType& cdm_type,
    const std::string& file_name,
    ReadFileCallback callback,
    std::optional<std::vector<uint8_t>> data) { … }

void MediaLicenseStorageHost::DidGetDatabaseSize(const uint64_t size) { … }

void MediaLicenseStorageHost::WriteFile(const media::CdmType& cdm_type,
                                        const std::string& file_name,
                                        const std::vector<uint8_t>& data,
                                        WriteFileCallback callback) { … }

void MediaLicenseStorageHost::DidWriteFile(WriteFileCallback callback,
                                           bool success) { … }

void MediaLicenseStorageHost::DeleteFile(const media::CdmType& cdm_type,
                                         const std::string& file_name,
                                         DeleteFileCallback callback) { … }

void MediaLicenseStorageHost::DeleteBucketData(
    base::OnceCallback<void(bool)> callback) { … }

void MediaLicenseStorageHost::OnReceiverDisconnect() { … }

void MediaLicenseStorageHost::OnFileReceiverDisconnect(
    const std::string& name,
    const media::CdmType& cdm_type,
    base::PassKey<CdmFileImpl> /*pass_key*/) { … }

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