chromium/extensions/common/manifest_handlers/externally_connectable.cc

// Copyright 2014 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/common/manifest_handlers/externally_connectable.h"

#include <stddef.h>

#include <algorithm>
#include <memory>

#include "base/memory/ptr_util.h"
#include "base/ranges/algorithm.h"
#include "base/strings/utf_string_conversions.h"
#include "components/crx_file/id_util.h"
#include "extensions/common/api/extensions_manifest_types.h"
#include "extensions/common/error_utils.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/common/manifest_handlers/permissions_parser.h"
#include "extensions/common/permissions/api_permission_set.h"
#include "extensions/common/url_pattern.h"
#include "url/gurl.h"

namespace extensions {

namespace externally_connectable_errors {
const char kErrorInvalidMatchPattern[] = …;
const char kErrorInvalidId[] = …;
const char kErrorNothingSpecified[] = …;
const char kErrorUnusedAcceptsTlsChannelId[] = …;
}  // namespace externally_connectable_errors

keys;
ExternallyConnectable;

namespace {

const char kAllIds[] = …;

template <typename T>
std::vector<T> Sorted(const std::vector<T>& in) { … }

}  // namespace

ExternallyConnectableHandler::ExternallyConnectableHandler() = default;

ExternallyConnectableHandler::~ExternallyConnectableHandler() = default;

bool ExternallyConnectableHandler::Parse(Extension* extension,
                                         std::u16string* error) { … }

base::span<const char* const> ExternallyConnectableHandler::Keys() const { … }

// static
ExternallyConnectableInfo* ExternallyConnectableInfo::Get(
    const Extension* extension) { … }

// static
std::unique_ptr<ExternallyConnectableInfo> ExternallyConnectableInfo::FromValue(
    const base::Value& value,
    std::vector<InstallWarning>* install_warnings,
    std::u16string* error) { … }

ExternallyConnectableInfo::~ExternallyConnectableInfo() { … }

ExternallyConnectableInfo::ExternallyConnectableInfo(
    URLPatternSet matches,
    const std::vector<ExtensionId>& ids,
    bool all_ids,
    bool accepts_tls_channel_id)
    : … { … }

bool ExternallyConnectableInfo::IdCanConnect(const ExtensionId& id) { … }

}  // namespace extensions