affiliation_utils.cc | Explore in Territory

// 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 "components/affiliations/core/browser/affiliation_utils.h"

#include <map>
#include <ostream>
#include <string_view>

#include "base/base64.h"
#include "base/ranges/algorithm.h"
#include "base/strings/escape.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "components/url_formatter/elide_url.h"
#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
#include "url/third_party/mozilla/url_parse.h"
#include "url/url_canon_stdstring.h"

namespace affiliations {

namespace {

// The scheme used for identifying Android applications.
const char kAndroidAppScheme[] = …;

// Returns a std::string_view corresponding to |component| in |uri|, or the empty
// string in case there is no such component.
std::string_view ComponentString(const std::string& uri,
                                 const url::Component& component) { … }

// Returns true if the passed ASCII |input| string contains nothing else than
// alphanumeric characters and those in |other_characters|.
bool ContainsOnlyAlphanumericAnd(std::string_view input,
                                 std::string_view other_characters) { … }

// Canonicalizes a Web facet URI, and returns true if canonicalization was
// successful and produced a valid URI.
bool CanonicalizeWebFacetURI(const std::string& input_uri,
                             const url::Parsed& input_parsed,
                             std::string* canonical_uri) { … }

// Adds padding until the length of the base64-encoded |data| becomes a multiple
// of 4, and returns true if the thusly obtained |data| is now correctly padded,
// i.e., there are at most 2 padding characters ('=') at the very end.
bool CanonicalizeBase64Padding(std::string* data) { … }

// Canonicalizes the username component in an Android facet URI (containing the
// certificate hash), and returns true if canonicalization was successful and
// produced a valid non-empty component.
bool CanonicalizeHashComponent(std::string_view input_hash,
                               url::CanonOutput* canonical_output) { … }

// Canonicalizes the host component in an Android facet URI (containing the
// package name), and returns true if canonicalization was successful and
// produced a valid non-empty component.
bool CanonicalizePackageNameComponent(
    std::string_view input_package_name,
    url::CanonOutput* canonical_output) { … }

// Canonicalizes an Android facet URI, and returns true if canonicalization was
// successful and produced a valid URI.
bool CanonicalizeAndroidFacetURI(const std::string& input_uri,
                                 const url::Parsed& input_parsed,
                                 std::string* canonical_uri) { … }

// Computes the canonicalized form of |uri| into |canonical_uri|, and returns
// true if canonicalization was successful and produced a valid URI.
bool ParseAndCanonicalizeFacetURI(const std::string& input_uri,
                                  std::string* canonical_uri) { … }

// Extracts and sorts the facet URIs of the given affiliated facets. This is
// used to determine whether two equivalence classes are equal.
std::vector<FacetURI> ExtractAndSortFacetURIs(const AffiliatedFacets& facets) { … }

// Appends a new level to the |main_domain| from |full_domain|.
// |main_domain| must be a suffix of |full_domain|.
void IncreaseDomainLevel(const std::string& full_domain,
                         std::string& main_domain) { … }

// An implementation of the disjoint-set data structure
// (https://en.wikipedia.org/wiki/Disjoint-set_data_structure). This
// implementation uses the path compression and union by rank optimizations,
// achieving near-constant runtime on all operations.
//
// This data structure allows to keep track of disjoin sets. Constructor accepts
// number of elements and initially each element represent an individual set.
// Later by calling MergeSets corresponding sets are merged together.
// Example usage:
//   DisjointSet disjoint_set(5);
//   disjoint_set.GetDisjointSets(); // Returns {{0}, {1}, {2}, {3}, {4}}
//   disjoint_set.MergeSets(0, 2);
//   disjoint_set.GetDisjointSets(); // Returns {{0, 2}, {1}, {3}, {4}}
//   disjoint_set.MergeSets(2, 4);
//   disjoint_set.GetDisjointSets(); // Returns {{0, 2, 4}, {1}, {3}}
class DisjointSet { … };

}  // namespace


// FacetURI -------------------------------------------------------------------

FacetURI::FacetURI() = default;

// static
FacetURI FacetURI::FromPotentiallyInvalidSpec(const std::string& spec) { … }

// static
FacetURI FacetURI::FromCanonicalSpec(const std::string& canonical_spec) { … }

bool FacetURI::IsValidWebFacetURI() const { … }

bool FacetURI::IsValidAndroidFacetURI() const { … }

std::string FacetURI::scheme() const { … }

std::string FacetURI::android_package_name() const { … }

std::string FacetURI::GetAndroidPackageDisplayName() const { … }

FacetURI::FacetURI(const std::string& canonical_spec, bool is_valid)
    : … { … }

// Facet

Facet::Facet(FacetURI uri,
             FacetBrandingInfo branding_info,
             GURL change_password_url,
             std::string main_domain)
    : … { … }

Facet::~Facet() = default;

Facet::Facet(const Facet& other) = default;

Facet::Facet(Facet&& other) = default;

Facet& Facet::operator=(const Facet& other) = default;

Facet& Facet::operator=(Facet&& other) = default;

// GroupedFacets

GroupedFacets::GroupedFacets() = default;

GroupedFacets::~GroupedFacets() = default;

GroupedFacets::GroupedFacets(const GroupedFacets& other) = default;

GroupedFacets::GroupedFacets(GroupedFacets&& other) = default;

GroupedFacets& GroupedFacets::operator=(const GroupedFacets& other) = default;

GroupedFacets& GroupedFacets::operator=(GroupedFacets&& other) = default;

std::vector<GroupedFacets> MergeRelatedGroups(
    const base::flat_set<std::string>& psl_extensions,
    const std::vector<GroupedFacets>& groups) { … }

// AffiliatedFacetsWithUpdateTime ---------------------------------------------

AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime() = default;

AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime(
    const AffiliatedFacetsWithUpdateTime& other) = default;

AffiliatedFacetsWithUpdateTime::AffiliatedFacetsWithUpdateTime(
    AffiliatedFacetsWithUpdateTime&& other) = default;

AffiliatedFacetsWithUpdateTime& AffiliatedFacetsWithUpdateTime::operator=(
    const AffiliatedFacetsWithUpdateTime& other) = default;

AffiliatedFacetsWithUpdateTime& AffiliatedFacetsWithUpdateTime::operator=(
    AffiliatedFacetsWithUpdateTime&& other) = default;

AffiliatedFacetsWithUpdateTime::~AffiliatedFacetsWithUpdateTime() = default;

// Helpers --------------------------------------------------------------------

std::ostream& operator<<(std::ostream& os, const FacetURI& facet_uri) { … }

bool operator==(const FacetBrandingInfo& lhs, const FacetBrandingInfo& rhs) { … }

bool operator!=(const FacetBrandingInfo& lhs, const FacetBrandingInfo& rhs) { … }

bool operator==(const Facet& lhs, const Facet& rhs) { … }

bool operator!=(const Facet& lhs, const Facet& rhs) { … }

bool operator==(const GroupedFacets& lhs, const GroupedFacets& rhs) { … }

bool operator!=(const GroupedFacets& lhs, const GroupedFacets& rhs) { … }

bool AreEquivalenceClassesEqual(const AffiliatedFacets& a,
                                const AffiliatedFacets& b) { … }

bool IsValidAndroidFacetURI(const std::string& url) { … }

std::string GetExtendedTopLevelDomain(
    const GURL& url,
    const base::flat_set<std::string>& psl_extensions) { … }

bool IsExtendedPublicSuffixDomainMatch(
    const GURL& url1,
    const GURL& url2,
    const base::flat_set<std::string>& psl_extensions) { … }

}  // namespace affiliations
chromium/components/affiliations/core/browser/affiliation_utils.cc
