permission_decision_auto_blocker.cc

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "components/permissions/permission_decision_auto_blocker.h"

#include <algorithm>
#include <memory>
#include <string>
#include <utility>

#include "base/feature_list.h"
#include "base/metrics/field_trial_params.h"
#include "base/strings/string_number_conversions.h"
#include "base/values.h"
#include "components/content_settings/core/browser/host_content_settings_map.h"
#include "components/keyed_service/content/browser_context_dependency_manager.h"
#include "components/permissions/features.h"
#include "components/permissions/permission_util.h"
#include "url/gurl.h"

namespace permissions {
namespace {

PermissionStatus;

constexpr int kDefaultDismissalsBeforeBlock = …;
constexpr int kDefaultIgnoresBeforeBlock = …;
constexpr int kDefaultDismissalsBeforeBlockWithQuietUi = …;
constexpr int kDefaultIgnoresBeforeBlockWithQuietUi = …;
constexpr int kDefaultEmbargoDays = …;

// The number of times that users may explicitly dismiss a
// FEDERATED_IDENTITY_API permission prompt from an origin before it is
// automatically blocked.
constexpr int kFederatedIdentityApiDismissalsBeforeBlock = …;

// The durations that an origin will stay under embargo for the
// FEDERATED_IDENTITY_API permission due to the user explicitly dismissing the
// permission prompt.
constexpr base::TimeDelta kFederatedIdentityApiEmbargoDurationDismiss[] = …;

// The duration that an origin will stay under embargo for the
// FEDERATED_IDENTITY_AUTO_REAUTHN_PERMISSION permission due to an auto re-authn
// prompt being displayed recently.
constexpr base::TimeDelta kFederatedIdentityAutoReauthnEmbargoDuration = …;

// The duration that an origin will stay under embargo for the
// SUB_APP_INSTALLATION_PROMPTS permission when the embargo is applied
// for the first time. After another dismissal, the default kDefaultEmbargoDays
// is applied.
constexpr base::TimeDelta kSubAppInstallationPromptsFirstTimeEmbargoDuration = …;

// The number of times that users may explicitly dismiss a permission prompt
// from an origin before it is automatically blocked.
int g_dismissals_before_block = …;

// The number of times that users may ignore a permission prompt from an origin
// before it is automatically blocked.
int g_ignores_before_block = …;

// The number of times that users may dismiss a permission prompt that uses the
// quiet UI from an origin before it is automatically blocked.
int g_dismissals_before_block_with_quiet_ui = …;

// The number of times that users may ignore a permission prompt that uses the
// quiet UI from an origin before it is automatically blocked.
int g_ignores_before_block_with_quiet_ui = …;

// The number of days that an origin will stay under embargo for a requested
// permission due to repeated dismissals.
int g_dismissal_embargo_days = …;

// The number of days that an origin will stay under embargo for a requested
// permission due to repeated ignores.
int g_ignore_embargo_days = …;

std::string GetStringForContentType(ContentSettingsType content_type) { … }

base::Value::Dict GetOriginAutoBlockerData(HostContentSettingsMap* settings,
                                           const GURL& origin_url) { … }

base::Value::Dict* GetOrCreatePermissionDict(base::Value::Dict& origin_dict,
                                             const std::string& permission) { … }

int RecordActionInWebsiteSettings(const GURL& url,
                                  ContentSettingsType permission,
                                  const char* key,
                                  HostContentSettingsMap* settings_map) { … }

int GetActionCount(const GURL& url,
                   ContentSettingsType permission,
                   const char* key,
                   HostContentSettingsMap* settings_map) { … }

// Returns the number of times that users may explicitly dismiss a permission
// prompt for an origin for the passed-in |permission| before it is
// automatically blocked.
int GetDismissalsBeforeBlockForContentSettingsType(
    ContentSettingsType permission) { … }

// The duration that an origin will stay under embargo for the passed-in
// |permission| due to the user explicitly dismissing the permission prompt.
base::TimeDelta GetEmbargoDurationForContentSettingsType(
    ContentSettingsType permission,
    int dismiss_count) { … }

base::Time GetEmbargoStartTime(base::Value::Dict* permission_dict,
                               const base::Feature& feature,
                               const char* key) { … }

bool IsUnderEmbargo(base::Value::Dict* permission_dict,
                    const base::Feature& feature,
                    const char* key,
                    base::Time current_time,
                    base::TimeDelta offset) { … }

void UpdateValueFromVariation(const std::string& variation_value,
                              int* value_store,
                              const int default_value) { … }

}  // namespace

// static
const char PermissionDecisionAutoBlocker::kPromptDismissCountKey[] = …;

// static
const char PermissionDecisionAutoBlocker::kPromptIgnoreCountKey[] = …;

// static
const char PermissionDecisionAutoBlocker::kPromptDismissCountWithQuietUiKey[] = …;

// static
const char PermissionDecisionAutoBlocker::kPromptIgnoreCountWithQuietUiKey[] = …;

// static
const char PermissionDecisionAutoBlocker::kPermissionDismissalEmbargoKey[] = …;

// static
const char PermissionDecisionAutoBlocker::kPermissionIgnoreEmbargoKey[] = …;

// static
const char PermissionDecisionAutoBlocker::kPermissionDisplayEmbargoKey[] = …;

// static
bool PermissionDecisionAutoBlocker::IsEnabledForContentSetting(
    ContentSettingsType content_setting) { … }

// static
std::optional<content::PermissionResult>
PermissionDecisionAutoBlocker::GetEmbargoResult(
    HostContentSettingsMap* settings_map,
    const GURL& request_origin,
    ContentSettingsType permission,
    base::Time current_time) { … }

// static
void PermissionDecisionAutoBlocker::UpdateFromVariations() { … }

bool PermissionDecisionAutoBlocker::IsEmbargoed(
    const GURL& request_origin,
    ContentSettingsType permission) { … }

std::optional<content::PermissionResult>
PermissionDecisionAutoBlocker::GetEmbargoResult(
    const GURL& request_origin,
    ContentSettingsType permission) { … }

base::Time PermissionDecisionAutoBlocker::GetEmbargoStartTime(
    const GURL& request_origin,
    ContentSettingsType permission) { … }

std::set<GURL> PermissionDecisionAutoBlocker::GetEmbargoedOrigins(
    ContentSettingsType content_type) { … }

std::set<GURL> PermissionDecisionAutoBlocker::GetEmbargoedOrigins(
    std::vector<ContentSettingsType> content_types) { … }

int PermissionDecisionAutoBlocker::GetDismissCount(
    const GURL& url,
    ContentSettingsType permission) { … }

int PermissionDecisionAutoBlocker::GetIgnoreCount(
    const GURL& url,
    ContentSettingsType permission) { … }

bool PermissionDecisionAutoBlocker::RecordDismissAndEmbargo(
    const GURL& url,
    ContentSettingsType permission,
    bool dismissed_prompt_was_quiet) { … }

bool PermissionDecisionAutoBlocker::RecordIgnoreAndEmbargo(
    const GURL& url,
    ContentSettingsType permission,
    bool ignored_prompt_was_quiet) { … }

bool PermissionDecisionAutoBlocker::RecordDisplayAndEmbargo(
    const GURL& url,
    ContentSettingsType permission) { … }

void PermissionDecisionAutoBlocker::RemoveEmbargoAndResetCounts(
    const GURL& url,
    ContentSettingsType permission) { … }

void PermissionDecisionAutoBlocker::RemoveEmbargoAndResetCounts(
    base::RepeatingCallback<bool(const GURL& url)> filter) { … }

void PermissionDecisionAutoBlocker::AddObserver(Observer* obs) { … }

void PermissionDecisionAutoBlocker::RemoveObserver(Observer* obs) { … }

// static
const char*
PermissionDecisionAutoBlocker::GetPromptDismissCountKeyForTesting() { … }

PermissionDecisionAutoBlocker::PermissionDecisionAutoBlocker(
    HostContentSettingsMap* settings_map)
    : … { … }

PermissionDecisionAutoBlocker::~PermissionDecisionAutoBlocker() { … }

void PermissionDecisionAutoBlocker::PlaceUnderEmbargo(
    const GURL& request_origin,
    ContentSettingsType permission,
    const char* key) { … }

void PermissionDecisionAutoBlocker::NotifyEmbargoStarted(
    const GURL& origin,
    ContentSettingsType content_setting) { … }

void PermissionDecisionAutoBlocker::SetClockForTesting(base::Clock* clock) { … }

}  // namespace permissions
chromium/components/permissions/permission_decision_auto_blocker.cc
