browsing_data_remover_impl.cc | Explore in Territory

// Copyright 2012 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/browsing_data/browsing_data_remover_impl.h"

#include <map>
#include <optional>
#include <set>
#include <string>
#include <utility>

#include "base/containers/contains.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_forward.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/user_metrics.h"
#include "base/observer_list.h"
#include "base/strings/strcat.h"
#include "base/task/bind_post_task.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "content/browser/browsing_data/browsing_data_filter_builder_impl.h"
#include "content/browser/renderer_host/render_frame_host_impl.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/common/features.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/browsing_data_filter_builder.h"
#include "content/public/browser/browsing_data_remover_delegate.h"
#include "content/public/browser/client_hints_controller_delegate.h"
#include "content/public/browser/content_browser_client.h"
#include "content/public/browser/download_manager.h"
#include "content/public/browser/storage_partition.h"
#include "content/public/browser/storage_partition_config.h"
#include "mojo/public/cpp/bindings/callback_helpers.h"
#include "services/network/public/cpp/features.h"
#include "services/network/public/mojom/clear_data_filter.mojom.h"
#include "services/network/public/mojom/network_context.mojom.h"
#include "storage/browser/quota/special_storage_policy.h"
#include "url/gurl.h"
#include "url/origin.h"
#include "url/url_util.h"

UserMetricsAction;

namespace content {

namespace {

// Timeout after which the History.ClearBrowsingData.Duration.SlowTasks180s
// histogram is recorded.
const base::TimeDelta kSlowTaskTimeout = …;

base::OnceClosure RunsOrPostOnCurrentTaskRunner(base::OnceClosure closure) { … }

// Returns whether `storage_key` matches `origin_type_mask` given the special
// storage `policy`. If `origin_type_mask` contains embedder-specific
// datatypes, `embedder_matcher` must not be null; the decision for those
// datatypes will be delegated to it.
bool DoesStorageKeyMatchMask(
    uint64_t origin_type_mask,
    const BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher&
        embedder_matcher,
    const blink::StorageKey& storage_key,
    storage::SpecialStoragePolicy* policy) { … }

}  // namespace

BrowsingDataRemoverImpl::BrowsingDataRemoverImpl(
    BrowserContext* browser_context)
    : … { … }

BrowsingDataRemoverImpl::~BrowsingDataRemoverImpl() { … }

void BrowsingDataRemoverImpl::SetRemoving(bool is_removing) { … }

void BrowsingDataRemoverImpl::SetEmbedderDelegate(
    BrowsingDataRemoverDelegate* embedder_delegate) { … }

bool BrowsingDataRemoverImpl::DoesOriginMatchMaskForTesting(
    uint64_t origin_type_mask,
    const url::Origin& origin,
    storage::SpecialStoragePolicy* policy) { … }

void BrowsingDataRemoverImpl::Remove(const base::Time& delete_begin,
                                     const base::Time& delete_end,
                                     uint64_t remove_mask,
                                     uint64_t origin_type_mask) { … }

void BrowsingDataRemoverImpl::RemoveWithFilter(
    const base::Time& delete_begin,
    const base::Time& delete_end,
    uint64_t remove_mask,
    uint64_t origin_type_mask,
    std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) { … }

void BrowsingDataRemoverImpl::RemoveAndReply(const base::Time& delete_begin,
                                             const base::Time& delete_end,
                                             uint64_t remove_mask,
                                             uint64_t origin_type_mask,
                                             Observer* observer) { … }

void BrowsingDataRemoverImpl::RemoveWithFilterAndReply(
    const base::Time& delete_begin,
    const base::Time& delete_end,
    uint64_t remove_mask,
    uint64_t origin_type_mask,
    std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
    Observer* observer) { … }

void BrowsingDataRemoverImpl::RemoveStorageBucketsAndReply(
    const std::optional<StoragePartitionConfig> storage_partition_config,
    const blink::StorageKey& storage_key,
    const std::set<std::string>& storage_buckets,
    base::OnceClosure callback) { … }

void BrowsingDataRemoverImpl::DidRemoveStorageBuckets(
    base::OnceClosure callback) { … }

void BrowsingDataRemoverImpl::RemoveInternal(
    const base::Time& delete_begin,
    const base::Time& delete_end,
    uint64_t remove_mask,
    uint64_t origin_type_mask,
    std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
    Observer* observer) { … }

void BrowsingDataRemoverImpl::RunNextTask() { … }

void BrowsingDataRemoverImpl::RemoveImpl(
    const base::Time& delete_begin,
    const base::Time& delete_end,
    uint64_t remove_mask,
    BrowsingDataFilterBuilder* filter_builder,
    uint64_t origin_type_mask) { … }

void BrowsingDataRemoverImpl::AddObserver(Observer* observer) { … }

void BrowsingDataRemoverImpl::RemoveObserver(Observer* observer) { … }

void BrowsingDataRemoverImpl::SetWouldCompleteCallbackForTesting(
    const base::RepeatingCallback<
        void(base::OnceClosure continue_to_completion)>& callback) { … }

void BrowsingDataRemoverImpl::OverrideStoragePartitionForTesting(
    const StoragePartitionConfig& storage_partition_config,
    StoragePartition* storage_partition) { … }

const base::Time& BrowsingDataRemoverImpl::GetLastUsedBeginTimeForTesting() { … }

uint64_t BrowsingDataRemoverImpl::GetLastUsedRemovalMaskForTesting() { … }

uint64_t BrowsingDataRemoverImpl::GetLastUsedOriginTypeMaskForTesting() { … }

std::optional<StoragePartitionConfig>
BrowsingDataRemoverImpl::GetLastUsedStoragePartitionConfigForTesting() { … }

uint64_t BrowsingDataRemoverImpl::GetPendingTaskCountForTesting() { … }

BrowsingDataRemoverImpl::RemovalTask::RemovalTask(
    const base::Time& delete_begin,
    const base::Time& delete_end,
    uint64_t remove_mask,
    uint64_t origin_type_mask,
    std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
    Observer* observer)
    : … { … }

BrowsingDataRemoverImpl::RemovalTask::RemovalTask(
    RemovalTask&& other) noexcept = default;

BrowsingDataRemoverImpl::RemovalTask::~RemovalTask() = default;

bool BrowsingDataRemoverImpl::RemovalTask::IsSameDeletion(
    const RemovalTask& other) { … }

StoragePartition* BrowsingDataRemoverImpl::GetStoragePartition(
    std::optional<StoragePartitionConfig> storage_partition_config) { … }

void BrowsingDataRemoverImpl::OnDelegateDone(
    base::OnceClosure completion_closure,
    uint64_t failed_data_types) { … }

void BrowsingDataRemoverImpl::Notify() { … }

void BrowsingDataRemoverImpl::OnTaskComplete(TracingDataType data_type,
                                             base::TimeTicks started) { … }

const char* BrowsingDataRemoverImpl::GetHistogramSuffix(TracingDataType task) { … }

base::OnceClosure BrowsingDataRemoverImpl::CreateTaskCompletionClosure(
    TracingDataType data_type) { … }

base::OnceClosure BrowsingDataRemoverImpl::CreateTaskCompletionClosureForMojo(
    TracingDataType data_type) { … }

void BrowsingDataRemoverImpl::RecordUnfinishedSubTasks() { … }

void BrowsingDataRemoverImpl::ClearClientHintCacheAndReply(
    const url::Origin& origin,
    base::OnceClosure callback) { … }

void BrowsingDataRemoverImpl::ClearClientHintCacheAndReplyImpl(
    const url::Origin& origin,
    base::OnceClosure callback) { … }

base::WeakPtr<BrowsingDataRemoverImpl> BrowsingDataRemoverImpl::GetWeakPtr() { … }

}  // namespace content
chromium/content/browser/browsing_data/browsing_data_remover_impl.cc
