rules_registry.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 "extensions/browser/api/declarative/rules_registry.h"

#include <memory>
#include <utility>

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "base/values.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "extensions/browser/api/declarative/rules_cache_delegate.h"
#include "extensions/browser/extension_error.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extensions_browser_client.h"
#include "extensions/browser/state_store.h"
#include "extensions/common/api/declarative/declarative_manifest_data.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/extensions_client.h"
#include "extensions/common/manifest_constants.h"

namespace extensions {

namespace {

const char kSuccess[] = …;
const char kDuplicateRuleId[] = …;
const char kErrorCannotRemoveManifestRules[] = …;

base::Value::List RulesToValue(
    const std::vector<const api::events::Rule*>& rules) { … }

std::vector<api::events::Rule> RulesFromValue(
    const std::optional<base::Value>& value) { … }

std::string ToId(int identifier) { … }

}  // namespace


// RulesRegistry

RulesRegistry::RulesRegistry(content::BrowserContext* browser_context,
                             const std::string& event_name,
                             RulesCacheDelegate* cache_delegate,
                             int id)
    : … { … }

std::string RulesRegistry::AddRulesNoFill(
    const ExtensionId& extension_id,
    std::vector<api::events::Rule> rules_in,
    RulesDictionary* destination,
    std::vector<const api::events::Rule*>* rules_out) { … }

std::string RulesRegistry::AddRules(
    const ExtensionId& extension_id,
    std::vector<api::events::Rule> rules_in,
    std::vector<const api::events::Rule*>* rules_out) { … }

std::string RulesRegistry::AddRulesInternal(
    const ExtensionId& extension_id,
    std::vector<api::events::Rule> rules_in,
    RulesDictionary* destination,
    std::vector<const api::events::Rule*>* rules_out) { … }

std::string RulesRegistry::RemoveRules(
    const ExtensionId& extension_id,
    const std::vector<std::string>& rule_identifiers) { … }

std::string RulesRegistry::RemoveAllRules(const ExtensionId& extension_id) { … }

std::string RulesRegistry::RemoveAllRulesNoStoreUpdate(
    const ExtensionId& extension_id,
    bool remove_manifest_rules) { … }

void RulesRegistry::GetRules(const ExtensionId& extension_id,
                             const std::vector<std::string>& rule_identifiers,
                             std::vector<const api::events::Rule*>* out) { … }

void RulesRegistry::GetRules(const ExtensionId& extension_id,
                             RulesDictionary* rules,
                             std::vector<const api::events::Rule*>* out) { … }

void RulesRegistry::GetAllRules(const ExtensionId& extension_id,
                                std::vector<const api::events::Rule*>* out) { … }

void RulesRegistry::OnShutdown() { … }

void RulesRegistry::OnExtensionUnloaded(const Extension* extension) { … }

void RulesRegistry::OnExtensionUninstalled(const Extension* extension) { … }

void RulesRegistry::OnExtensionLoaded(const Extension* extension) { … }

size_t RulesRegistry::GetNumberOfUsedRuleIdentifiersForTesting() const { … }

void RulesRegistry::DeserializeAndAddRules(const ExtensionId& extension_id,
                                           std::optional<base::Value> rules) { … }

void RulesRegistry::ReportInternalError(const ExtensionId& extension_id,
                                        const std::string& error) { … }

RulesRegistry::~RulesRegistry() { … }

void RulesRegistry::MarkReady() { … }

void RulesRegistry::ProcessChangedRules(const ExtensionId& extension_id) { … }

void RulesRegistry::MaybeProcessChangedRules(const ExtensionId& extension_id) { … }

bool RulesRegistry::IsUniqueId(const ExtensionId& extension_id,
                               const std::string& rule_id) const { … }

std::string RulesRegistry::GenerateUniqueId(const ExtensionId& extension_id) { … }

std::string RulesRegistry::CheckAndFillInOptionalRules(
    const ExtensionId& extension_id,
    std::vector<api::events::Rule>* rules) { … }

void RulesRegistry::FillInOptionalPriorities(
    std::vector<api::events::Rule>* rules) { … }

void RulesRegistry::RemoveUsedRuleIdentifiers(
    const ExtensionId& extension_id,
    const std::vector<std::string>& identifiers) { … }

void RulesRegistry::RemoveAllUsedRuleIdentifiers(
    const ExtensionId& extension_id) { … }

}  // namespace extensions
chromium/extensions/browser/api/declarative/rules_registry.cc
