ruleset_matcher.cc | Explore in Territory

// Copyright 2017 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_net_request/ruleset_matcher.h"

#include <iterator>
#include <optional>
#include <utility>

#include "base/check.h"
#include "base/containers/flat_set.h"
#include "base/containers/span.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/histogram_macros.h"
#include "base/time/time.h"
#include "extensions/browser/api/declarative_net_request/constants.h"
#include "extensions/browser/api/declarative_net_request/flat/extension_ruleset_generated.h"
#include "extensions/browser/api/declarative_net_request/request_action.h"
#include "extensions/browser/api/declarative_net_request/rule_counts.h"
#include "extensions/browser/api/declarative_net_request/ruleset_matcher_base.h"
#include "extensions/browser/api/declarative_net_request/utils.h"
#include "extensions/common/api/declarative_net_request/constants.h"

namespace extensions::declarative_net_request {

namespace {

ExtensionMetadataList;

// These constants specify the number of, the minimum, and the maximum buckets
// for histograms which record the evaluation time for a request against a
// single DNR ruleset.
constexpr int kRequestActionTimeUmaBucketCount = …;
constexpr base::TimeDelta kRequestActionUmaMinTime = …;
constexpr base::TimeDelta kRequestActionUmaMaxTime = …;

size_t ComputeUnsafeRuleCount(const ExtensionMetadataList* metadata_list) { … }

bool IsRulesetStatic(const RulesetID& id) { … }

void RecordOnBeforeRequestActionTime(const base::TimeTicks& start_time,
                                     const base::TimeDelta& regex_time,
                                     const base::TimeDelta& total_time,
                                     int rules_count,
                                     int regex_rules_count) { … }

void RecordOnHeadersReceivedActionTime(const base::TimeTicks& start_time,
                                       const base::TimeDelta& regex_time,
                                       const base::TimeDelta& total_time,
                                       int rules_count,
                                       int regex_rules_count) { … }

}  // namespace

RulesetMatcher::RulesetMatcher(std::string ruleset_data,
                               RulesetID id,
                               const ExtensionId& extension_id)
    : … { … }

RulesetMatcher::~RulesetMatcher() = default;

std::optional<RequestAction> RulesetMatcher::GetAction(
    const RequestParams& params,
    RulesetMatchingStage stage) const { … }

std::vector<RequestAction> RulesetMatcher::GetModifyHeadersActions(
    const RequestParams& params,
    RulesetMatchingStage stage,
    std::optional<uint64_t> min_priority) const { … }

bool RulesetMatcher::IsExtraHeadersMatcher() const { … }

size_t RulesetMatcher::GetRulesCount() const { … }

std::optional<size_t> RulesetMatcher::GetUnsafeRulesCount() const { … }

size_t RulesetMatcher::GetRegexRulesCount() const { … }

RuleCounts RulesetMatcher::GetRuleCounts() const { … }

void RulesetMatcher::OnRenderFrameCreated(content::RenderFrameHost* host) { … }

void RulesetMatcher::OnRenderFrameDeleted(content::RenderFrameHost* host) { … }

void RulesetMatcher::OnDidFinishNavigation(
    content::NavigationHandle* navigation_handle) { … }

std::optional<RequestAction>
RulesetMatcher::GetAllowlistedFrameActionForTesting(
    content::RenderFrameHost* host) const { … }

void RulesetMatcher::SetDisabledRuleIds(base::flat_set<int> disabled_rule_ids) { … }

const base::flat_set<int>& RulesetMatcher::GetDisabledRuleIdsForTesting()
    const { … }

size_t RulesetMatcher::GetRulesCount(RulesetMatchingStage stage) const { … }

size_t RulesetMatcher::GetRegexRulesCount(RulesetMatchingStage stage) const { … }

}  // namespace extensions::declarative_net_request
chromium/extensions/browser/api/declarative_net_request/ruleset_matcher.cc
