bucket_host.cc | Explore in Territory

// Copyright 2021 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/buckets/bucket_host.h"

#include "base/functional/bind.h"
#include "base/task/sequenced_task_runner.h"
#include "components/services/storage/privileged/mojom/indexed_db_control.mojom.h"
#include "content/browser/buckets/bucket_context.h"
#include "content/browser/buckets/bucket_manager.h"
#include "content/browser/buckets/bucket_manager_host.h"
#include "content/browser/locks/lock_manager.h"
#include "content/browser/renderer_host/indexed_db_client_state_checker_factory.h"
#include "content/browser/storage_partition_impl.h"
#include "content/public/browser/browser_context.h"
#include "third_party/blink/public/common/permissions/permission_utils.h"

namespace content {

// `BucketContext` assumes these two mojom methods have the same signature. This
// assert is here instead of in `bucket_context.h` to avoid pulling in too many
// includes in a header.
static_assert …;

BucketHost::BucketHost(BucketManagerHost* bucket_manager_host,
                       const storage::BucketInfo& bucket_info)
    : … { … }

BucketHost::~BucketHost() = default;

mojo::PendingRemote<blink::mojom::BucketHost>
BucketHost::CreateStorageBucketBinding(
    base::WeakPtr<BucketContext> bucket_context) { … }

void BucketHost::PassStorageBucketBinding(
    base::WeakPtr<BucketContext> bucket_context,
    mojo::PendingReceiver<blink::mojom::BucketHost> receiver) { … }

void BucketHost::Persist(PersistCallback callback) { … }

void BucketHost::Persisted(PersistedCallback callback) { … }

void BucketHost::DidValidateForPersist(PersistedCallback callback,
                                       bool bucket_exists) { … }

void BucketHost::Estimate(EstimateCallback callback) { … }

void BucketHost::Durability(DurabilityCallback callback) { … }

void BucketHost::DidValidateForDurability(DurabilityCallback callback,
                                          bool bucket_exists) { … }

void BucketHost::SetExpires(base::Time expires, SetExpiresCallback callback) { … }

void BucketHost::Expires(ExpiresCallback callback) { … }

void BucketHost::DidValidateForExpires(ExpiresCallback callback,
                                       bool bucket_exists) { … }

void BucketHost::GetIdbFactory(
    mojo::PendingReceiver<blink::mojom::IDBFactory> receiver) { … }

void BucketHost::GetCaches(
    mojo::PendingReceiver<blink::mojom::CacheStorage> caches) { … }

void BucketHost::GetDirectory(GetDirectoryCallback callback) { … }

void BucketHost::GetDirectoryForDevtools(
    const std::vector<std::string>& directory_path_components,
    GetDirectoryCallback callback) { … }

void BucketHost::GetLockManager(
    mojo::PendingReceiver<blink::mojom::LockManager> receiver) { … }

void BucketHost::OnReceiverDisconnected() { … }

storage::QuotaManagerProxy* BucketHost::GetQuotaManagerProxy() { … }

void BucketHost::DidGetBucket(
    base::OnceCallback<void(bool)> callback,
    storage::QuotaErrorOr<storage::BucketInfo> bucket_info) { … }

void BucketHost::DidGetUsageAndQuota(EstimateCallback callback,
                                     blink::mojom::QuotaStatusCode code,
                                     int64_t usage,
                                     int64_t quota) { … }

}  // namespace content
chromium/content/browser/buckets/bucket_host.cc
