service_worker_router_evaluator.cc | Explore in Territory

// Copyright 2023 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/common/service_worker/service_worker_router_evaluator.h"

#include <limits>
#include <memory>
#include <tuple>

#include "base/json/json_writer.h"
#include "base/metrics/histogram_functions.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "base/timer/elapsed_timer.h"
#include "services/network/public/cpp/request_destination.h"
#include "services/network/public/cpp/request_mode.h"
#include "third_party/blink/public/common/service_worker/service_worker_router_rule.h"
#include "third_party/blink/public/mojom/service_worker/service_worker.mojom.h"
#include "third_party/liburlpattern/options.h"
#include "third_party/liburlpattern/pattern.h"
#include "third_party/liburlpattern/utils.h"
#include "third_party/re2/src/re2/re2.h"

namespace {

class BaseCondition;
class NotCondition;
class OrCondition;
class ConditionObject;

base::Value ConditionToValue(
    const blink::ServiceWorkerRouterCondition& condition);

void RecordSetupError(ServiceWorkerRouterEvaluatorErrorEnums e) { … }

void RecordMatchedSourceType(
    const std::vector<blink::ServiceWorkerRouterSource>& sources) { … }

void RecordEvaluationTime(base::TimeDelta duration) { … }

// TODO(crbug.com/40241479): consolidate code with blink::url_pattern.
//
// The type and method come form
// third_party/blink/renderer/core/url_pattern/url_pattern_component.{h,cc}.
// GetOptions is not exported yet, and there is little benefit to depend
// on the blink::URLPattern now.
enum class URLPatternFieldType { … };

// Utility method to get the correct liburlpattern parse options for a given
// type.
const std::tuple<liburlpattern::Options, std::string>
GetOptionsAndSegmentWildcardRegex(const blink::SafeUrlPattern& url_pattern,
                                  URLPatternFieldType type) { … }

liburlpattern::Pattern ConvertToPattern(
    const blink::SafeUrlPattern& url_pattern,
    URLPatternFieldType type) { … }

std::string ConvertToRegex(const blink::SafeUrlPattern& url_pattern,
                           URLPatternFieldType type) { … }

std::string ConvertToPatternString(const blink::SafeUrlPattern& url_pattern,
                                   URLPatternFieldType type) { … }

base::Value RequestToValue(
    const blink::ServiceWorkerRouterRequestCondition& request) { … }

std::string RunningStatusToString(
    const blink::ServiceWorkerRouterRunningStatusCondition& running_status) { … }

base::Value OrConditionToValue(
    const blink::ServiceWorkerRouterOrCondition& or_condition) { … }

base::Value NotConditionToValue(
    const blink::ServiceWorkerRouterNotCondition& not_condition) { … }

base::Value ConditionToValue(
    const blink::ServiceWorkerRouterCondition& condition) { … }

bool IsValidSources(
    const std::vector<blink::ServiceWorkerRouterSource> sources) { … }

[[nodiscard]] bool ExceedsMaxConditionDepth(
    const blink::ServiceWorkerRouterCondition& condition,
    int depth = 0) { … }

void UpdateMaxConditionDepthAndWidth(
    const blink::ServiceWorkerRouterCondition& condition,
    size_t& max_depth,
    size_t& max_width,
    size_t depth = 0) { … }

bool MatchRequestCondition(
    const blink::ServiceWorkerRouterRequestCondition& pattern,
    const network::ResourceRequest& request) { … }

bool MatchRunningCondition(
    const blink::ServiceWorkerRouterRunningStatusCondition& condition,
    const blink::EmbeddedWorkerStatus& running_status) { … }

class BaseCondition { … };

ServiceWorkerRouterEvaluatorErrorEnums BaseCondition::Set(
    const blink::ServiceWorkerRouterCondition& condition) { … }

bool BaseCondition::Match(
    const network::ResourceRequest& request,
    std::optional<blink::EmbeddedWorkerStatus> running_status) const { … }

bool BaseCondition::MatchUrlPatternConditions(
    const network::ResourceRequest& request) const { … }

bool BaseCondition::MatchNonUrlPatternConditions(
    const network::ResourceRequest& request,
    std::optional<blink::EmbeddedWorkerStatus> running_status) const { … }

class OrCondition { … };

class NotCondition { … };

class ConditionObject { … };

ServiceWorkerRouterEvaluatorErrorEnums OrCondition::Set(
    const std::vector<blink::ServiceWorkerRouterCondition>& conditions) { … }

bool OrCondition::Match(
    const network::ResourceRequest& request,
    std::optional<blink::EmbeddedWorkerStatus> running_status) const { … }

ServiceWorkerRouterEvaluatorErrorEnums NotCondition::Set(
    const std::unique_ptr<blink::ServiceWorkerRouterCondition>& condition) { … }

bool NotCondition::Match(
    const network::ResourceRequest& request,
    std::optional<blink::EmbeddedWorkerStatus> running_status) const { … }

}  // namespace

namespace content {

class ServiceWorkerRouterEvaluator::RouterRule { … };

ServiceWorkerRouterEvaluator::Result::Result() = default;
ServiceWorkerRouterEvaluator::Result::~Result() = default;
ServiceWorkerRouterEvaluator::Result::Result(Result&&) = default;

ServiceWorkerRouterEvaluator::ServiceWorkerRouterEvaluator(
    blink::ServiceWorkerRouterRules rules)
    : … { … }
ServiceWorkerRouterEvaluator::~ServiceWorkerRouterEvaluator() = default;

void ServiceWorkerRouterEvaluator::Compile() { … }

std::optional<ServiceWorkerRouterEvaluator::Result>
ServiceWorkerRouterEvaluator::EvaluateInternal(
    const network::ResourceRequest& request,
    std::optional<blink::EmbeddedWorkerStatus> running_status) const { … }

std::optional<ServiceWorkerRouterEvaluator::Result>
ServiceWorkerRouterEvaluator::Evaluate(
    const network::ResourceRequest& request,
    blink::EmbeddedWorkerStatus running_status) const { … }

std::optional<ServiceWorkerRouterEvaluator::Result>
ServiceWorkerRouterEvaluator::EvaluateWithoutRunningStatus(
    const network::ResourceRequest& request) const { … }

base::Value ServiceWorkerRouterEvaluator::ToValue() const { … }

std::string ServiceWorkerRouterEvaluator::ToString() const { … }

void ServiceWorkerRouterEvaluator::RecordRouterRuleInfo() const { … }

std::tuple<size_t, size_t> ServiceWorkerRouterEvaluator::GetMaxDepthAndWidth()
    const { … }

}  // namespace content
chromium/content/common/service_worker/service_worker_router_evaluator.cc
