expire_history_backend.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 "components/history/core/browser/expire_history_backend.h"

#include <stddef.h>

#include <functional>
#include <limits>
#include <memory>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/compiler_specific.h"
#include "base/containers/flat_set.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/ranges/algorithm.h"
#include "base/task/sequenced_task_runner.h"
#include "build/build_config.h"
#include "components/favicon/core/favicon_database.h"
#include "components/history/core/browser/features.h"
#include "components/history/core/browser/history_backend_client.h"
#include "components/history/core/browser/history_backend_notifier.h"
#include "components/history/core/browser/history_database.h"

namespace history {

// Helpers --------------------------------------------------------------------

namespace {

// The number of days by which the expiration threshold is advanced for items
// that we want to expire early, such as those of AUTO_SUBFRAME transition type.
//
// Early expiration stuff is kept around only for edge cases, as subframes
// don't appear in history and the vast majority of them are ads anyway. The
// main use case for these is if you're on a site with links to different
// frames, you'll be able to see those links as visited, and we'll also be
// able to get redirect information for those URLs.
//
// But since these uses are most valuable when you're actually on the site,
// and because these can take up the bulk of your history, we get a lot of
// space savings by deleting them quickly.
const int kEarlyExpirationAdvanceDays = …;

// Reads all types of visits starting from beginning of time to the given end
// time. This is the most general reader.
class AllVisitsReader : public ExpiringVisitsReader { … };

// Reads only AUTO_SUBFRAME visits, within a computed range. The range is
// computed as follows:
// * `begin_time` is read from the meta table. This value is updated whenever
//   there are no more additional visits to expire by this reader.
// * `end_time` is advanced forward by a constant (kEarlyExpirationAdvanceDay),
//   but not past the current time.
class AutoSubframeVisitsReader : public ExpiringVisitsReader { … };

// The number of visits we will expire very time we check for old items. This
// Prevents us from doing too much work any given time.
const int kNumExpirePerIteration = …;

// The number of seconds between checking for items that should be expired when
// we think there might be more items to expire. This timeout is used when the
// last expiration found at least kNumExpirePerIteration and we want to check
// again "soon."
const int kExpirationDelaySec = …;

// The number of minutes between checking, as with kExpirationDelaySec, but
// when we didn't find enough things to expire last time. If there was no
// history to expire last iteration, it's likely there is nothing next
// iteration, so we want to wait longer before checking to avoid wasting CPU.
const int kExpirationEmptyDelayMin = …;

// If the expiration timer is delayed by over an hour, then assume that the
// machine went to sleep.
constexpr base::TimeDelta kExpirationSleepWakeupThreshold = …;

// The minimum number of hours between checking for old on-demand favicons that
// should be cleared.
const int kClearOnDemandFaviconsIntervalHours = …;

bool IsAnyURLPinned(HistoryBackendClient* backend_client,
                    const std::vector<GURL>& urls) { … }

}  // namespace

namespace internal {

// Clearing old on-demand favicons is only enabled on mobile.
#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS)
constexpr bool kClearOldOnDemandFaviconsEnabled = true;
#else
constexpr bool kClearOldOnDemandFaviconsEnabled = …;
#endif

const int kOnDemandFaviconIsOldAfterDays = …;

}  // namespace internal

// ExpireHistoryBackend::DeleteEffects ----------------------------------------

ExpireHistoryBackend::DeleteEffects::DeleteEffects() = default;

ExpireHistoryBackend::DeleteEffects::~DeleteEffects() = default;

// ExpireHistoryBackend -------------------------------------------------------

ExpireHistoryBackend::ExpireHistoryBackend(
    HistoryBackendNotifier* notifier,
    HistoryBackendClient* backend_client,
    scoped_refptr<base::SequencedTaskRunner> task_runner)
    : … { … }

ExpireHistoryBackend::~ExpireHistoryBackend() = default;

void ExpireHistoryBackend::SetDatabases(HistoryDatabase* main_db,
                                        favicon::FaviconDatabase* favicon_db) { … }

void ExpireHistoryBackend::DeleteURL(const GURL& url, base::Time end_time) { … }

void ExpireHistoryBackend::DeleteURLs(const std::vector<GURL>& urls,
                                      base::Time end_time) { … }

void ExpireHistoryBackend::ExpireHistoryBetween(
    const std::set<GURL>& restrict_urls,
    std::optional<std::string> restrict_app_id,
    base::Time begin_time,
    base::Time end_time,
    bool user_initiated) { … }

void ExpireHistoryBackend::ExpireHistoryForTimes(
    const std::vector<base::Time>& times) { … }

void ExpireHistoryBackend::ExpireVisits(const VisitVector& visits,
                                        DeletionInfo::Reason deletion_reason) { … }

void ExpireHistoryBackend::ExpireVisitsInternal(
    const VisitVector& visits,
    const DeletionTimeRange& time_range,
    const std::set<GURL>& restrict_urls,
    DeletionType type,
    DeletionInfo::Reason deletion_reason) { … }

void ExpireHistoryBackend::ExpireHistoryBeforeForTesting(base::Time end_time) { … }

void ExpireHistoryBackend::ClearOldOnDemandFaviconsIfPossible(
    base::Time expiration_threshold) { … }

void ExpireHistoryBackend::InitWorkQueue() { … }

const ExpiringVisitsReader* ExpireHistoryBackend::GetAllVisitsReader() { … }

const ExpiringVisitsReader*
    ExpireHistoryBackend::GetAutoSubframeVisitsReader() { … }

void ExpireHistoryBackend::StartExpiringOldStuff(
    base::TimeDelta expiration_threshold) { … }

void ExpireHistoryBackend::DeleteFaviconsIfPossible(DeleteEffects* effects) { … }

void ExpireHistoryBackend::BroadcastNotifications(
    DeleteEffects* effects,
    DeletionType type,
    const DeletionTimeRange& time_range,
    std::optional<std::set<GURL>> restrict_urls,
    DeletionInfo::Reason deletion_reason) { … }

VisitVector ExpireHistoryBackend::GetVisitsAndRedirectParents(
    const VisitVector& visits) { … }

void ExpireHistoryBackend::DeleteVisitRelatedInfo(const VisitVector& visits,
                                                  DeleteEffects* effects) { … }

void ExpireHistoryBackend::DeleteOneURL(const URLRow& url_row,
                                        bool is_pinned,
                                        DeleteEffects* effects) { … }

void ExpireHistoryBackend::DeleteIcons(const GURL& gurl,
                                       DeleteEffects* effects) { … }

namespace {

struct ChangedURL { … };

}  // namespace

void ExpireHistoryBackend::ExpireURLsForVisits(const VisitVector& visits,
                                               DeleteEffects* effects) { … }

void ExpireHistoryBackend::ScheduleExpire() { … }

void ExpireHistoryBackend::DoExpireIteration() { … }

bool ExpireHistoryBackend::ExpireSomeOldHistory(
    base::Time end_time,
    const ExpiringVisitsReader* reader,
    int max_visits) { … }

void ExpireHistoryBackend::ExpireOldSegmentData(base::Time end_time) { … }

void ExpireHistoryBackend::ParanoidExpireHistory() { … }

}  // namespace history
chromium/components/history/core/browser/expire_history_backend.cc
