keyword_provider.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/omnibox/browser/keyword_provider.h"

#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/containers/contains.h"
#include "base/i18n/case_conversion.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/escape.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/trace_event/trace_event.h"
#include "components/omnibox/browser/autocomplete_match.h"
#include "components/omnibox/browser/autocomplete_provider_client.h"
#include "components/omnibox/browser/autocomplete_provider_listener.h"
#include "components/omnibox/browser/keyword_extensions_delegate.h"
#include "components/omnibox/browser/omnibox_feature_configs.h"
#include "components/omnibox/browser/omnibox_field_trial.h"
#include "components/omnibox/browser/search_provider.h"
#include "components/search_engines/template_url.h"
#include "components/search_engines/template_url_service.h"
#include "components/search_engines/template_url_starter_pack_data.h"
#include "components/strings/grit/components_strings.h"
#include "components/url_formatter/url_formatter.h"
#include "third_party/metrics_proto/omnibox_focus_type.pb.h"
#include "third_party/metrics_proto/omnibox_input_type.pb.h"
#include "ui/base/l10n/l10n_util.h"
#include "url/url_constants.h"

namespace {

// Helper functor for Start(), for sorting keyword matches by quality.
class CompareQuality { … };

// Helper for KeywordProvider::Start(), for ending keyword mode unless
// explicitly told otherwise.
class ScopedEndExtensionKeywordMode { … };

ScopedEndExtensionKeywordMode::ScopedEndExtensionKeywordMode(
    KeywordExtensionsDelegate* delegate)
    : … { … }

ScopedEndExtensionKeywordMode::~ScopedEndExtensionKeywordMode() { … }

void ScopedEndExtensionKeywordMode::StayInKeywordMode() { … }

}  // namespace

KeywordProvider::KeywordProvider(AutocompleteProviderClient* client,
                                 AutocompleteProviderListener* listener)
    : … { … }

// static
std::u16string KeywordProvider::SplitKeywordFromInput(
    const std::u16string& input,
    bool trim_leading_whitespace,
    std::u16string* remaining_input) { … }

// static
std::u16string KeywordProvider::SplitReplacementStringFromInput(
    const std::u16string& input,
    bool trim_leading_whitespace) { … }

// static
const TemplateURL* KeywordProvider::GetSubstitutingTemplateURLForInput(
    TemplateURLService* model,
    AutocompleteInput* input) { … }

// static
KeywordProvider::AdjustedInputAndStarterPackEngine
KeywordProvider::AdjustInputForStarterPackEngines(
    const AutocompleteInput& input,
    TemplateURLService* model) { … }

std::u16string KeywordProvider::GetKeywordForText(
    const std::u16string& text) const { … }

AutocompleteMatch KeywordProvider::CreateVerbatimMatch(
    const std::u16string& text,
    const std::u16string& keyword,
    const AutocompleteInput& input) { … }

void KeywordProvider::DeleteMatch(const AutocompleteMatch& match) { … }

void KeywordProvider::Start(const AutocompleteInput& input,
                            bool minimal_changes) { … }

void KeywordProvider::Stop(bool clear_cached_results,
                           bool due_to_user_inactivity) { … }

KeywordProvider::~KeywordProvider() { … }

// static
bool KeywordProvider::ExtractKeywordFromInput(
    const AutocompleteInput& input,
    const TemplateURLService* template_url_service,
    std::u16string* keyword,
    std::u16string* remaining_input) { … }

// static
int KeywordProvider::CalculateRelevance(metrics::OmniboxInputType type,
                                        bool complete,
                                        bool supports_replacement,
                                        bool prefer_keyword,
                                        bool allow_exact_keyword_match) { … }

AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
    const TemplateURL* template_url,
    const AutocompleteInput& input,
    size_t prefix_length,
    const std::u16string& remaining_input,
    bool allowed_to_be_default_match,
    int relevance,
    bool deletable) { … }

void KeywordProvider::FillInURLAndContents(
    const std::u16string& remaining_input,
    const TemplateURL* element,
    AutocompleteMatch* match) const { … }

TemplateURLService* KeywordProvider::GetTemplateURLService() const { … }

// static
std::u16string KeywordProvider::CleanUserInputKeyword(
    const TemplateURLService* template_url_service,
    const std::u16string& keyword) { … }
chromium/components/omnibox/browser/keyword_provider.cc
