1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/logging.h"
#include "chrome/browser/autocomplete/autocomplete_match.h"
#include "grit/theme_resources.h"
// AutocompleteMatch ----------------------------------------------------------
AutocompleteMatch::AutocompleteMatch()
: provider(NULL),
relevance(0),
deletable(false),
inline_autocomplete_offset(std::wstring::npos),
transition(PageTransition::GENERATED),
is_history_what_you_typed_match(false),
type(SEARCH_WHAT_YOU_TYPED),
template_url(NULL),
starred(false) {
}
AutocompleteMatch::AutocompleteMatch(AutocompleteProvider* provider,
int relevance,
bool deletable,
Type type)
: provider(provider),
relevance(relevance),
deletable(deletable),
inline_autocomplete_offset(std::wstring::npos),
transition(PageTransition::TYPED),
is_history_what_you_typed_match(false),
type(type),
template_url(NULL),
starred(false) {
}
AutocompleteMatch::~AutocompleteMatch() {
}
// static
std::string AutocompleteMatch::TypeToString(Type type) {
const char* strings[NUM_TYPES] = {
"url-what-you-typed",
"history-url",
"history-title",
"history-body",
"history-keyword",
"navsuggest",
"search-what-you-typed",
"search-history",
"search-suggest",
"search-other-engine",
"open-history-page",
};
DCHECK(arraysize(strings) == NUM_TYPES);
return strings[type];
}
// static
int AutocompleteMatch::TypeToIcon(Type type) {
int icons[NUM_TYPES] = {
IDR_OMNIBOX_HTTP,
IDR_OMNIBOX_HTTP,
IDR_OMNIBOX_HISTORY,
IDR_OMNIBOX_HISTORY,
IDR_OMNIBOX_HISTORY,
IDR_OMNIBOX_HTTP,
IDR_OMNIBOX_SEARCH,
IDR_OMNIBOX_SEARCH,
IDR_OMNIBOX_SEARCH,
IDR_OMNIBOX_SEARCH,
IDR_OMNIBOX_MORE,
};
DCHECK(arraysize(icons) == NUM_TYPES);
return icons[type];
}
// static
bool AutocompleteMatch::MoreRelevant(const AutocompleteMatch& elem1,
const AutocompleteMatch& elem2) {
// For equal-relevance matches, we sort alphabetically, so that providers
// who return multiple elements at the same priority get a "stable" sort
// across multiple updates.
if (elem1.relevance == elem2.relevance)
return elem1.contents > elem2.contents;
// A negative relevance indicates the real relevance can be determined by
// negating the value. If both relevances are negative, negate the result
// so that we end up with positive relevances, then negative relevances with
// the negative relevances sorted by absolute values.
const bool result = elem1.relevance > elem2.relevance;
return (elem1.relevance < 0 && elem2.relevance < 0) ? !result : result;
}
// static
bool AutocompleteMatch::DestinationSortFunc(const AutocompleteMatch& elem1,
const AutocompleteMatch& elem2) {
// Sort identical destination_urls together. Place the most relevant matches
// first, so that when we call std::unique(), these are the ones that get
// preserved.
return (elem1.destination_url != elem2.destination_url) ?
(elem1.destination_url < elem2.destination_url) :
MoreRelevant(elem1, elem2);
}
// static
bool AutocompleteMatch::DestinationsEqual(const AutocompleteMatch& elem1,
const AutocompleteMatch& elem2) {
return elem1.destination_url == elem2.destination_url;
}
// static
void AutocompleteMatch::ClassifyMatchInString(
const std::wstring& find_text,
const std::wstring& text,
int style,
ACMatchClassifications* classification) {
ClassifyLocationInString(text.find(find_text), find_text.length(),
text.length(), style, classification);
}
void AutocompleteMatch::ClassifyLocationInString(
size_t match_location,
size_t match_length,
size_t overall_length,
int style,
ACMatchClassifications* classification) {
classification->clear();
// Don't classify anything about an empty string
// (AutocompleteMatch::Validate() checks this).
if (overall_length == 0)
return;
// Mark pre-match portion of string (if any).
if (match_location != 0) {
classification->push_back(ACMatchClassification(0, style));
}
// Mark matching portion of string.
if (match_location == std::wstring::npos) {
// No match, above classification will suffice for whole string.
return;
}
// Classifying an empty match makes no sense and will lead to validation
// errors later.
DCHECK(match_length > 0);
classification->push_back(ACMatchClassification(match_location,
(style | ACMatchClassification::MATCH) & ~ACMatchClassification::DIM));
// Mark post-match portion of string (if any).
const size_t after_match(match_location + match_length);
if (after_match < overall_length) {
classification->push_back(ACMatchClassification(after_match, style));
}
}
#ifndef NDEBUG
void AutocompleteMatch::Validate() const {
ValidateClassifications(contents, contents_class);
ValidateClassifications(description, description_class);
}
void AutocompleteMatch::ValidateClassifications(
const std::wstring& text,
const ACMatchClassifications& classifications) const {
if (text.empty()) {
DCHECK(classifications.size() == 0);
return;
}
// The classifications should always cover the whole string.
DCHECK(classifications.size() > 0) << "No classification for text";
DCHECK(classifications[0].offset == 0) << "Classification misses beginning";
if (classifications.size() == 1)
return;
// The classifications should always be sorted.
size_t last_offset = classifications[0].offset;
for (ACMatchClassifications::const_iterator i(classifications.begin() + 1);
i != classifications.end(); ++i) {
DCHECK(i->offset > last_offset) << "Classification unsorted";
DCHECK(i->offset < text.length()) << "Classification out of bounds";
last_offset = i->offset;
}
}
#endif
|
