上次看了个某个浏览器的网址补全，感觉比较弱鸡，所以想起来研究一下chromium是怎么实现这个地址匹配的。这个东西还是有点意思的，可以根据URL或title进行匹配，输入的单词没输全，或者几个单词的顺序反了都可以给你匹配到。然后主要是想看怎么快速匹配，其他无关部分就略过了。研究对象URLIndexPrivateData类，位于components/omnibox/browser/url_index_private_data.cc，以下内容基于chrome66版本源码。
可以先看一下URLIndexPrivateData的成员，这里主要关注的以下几个：
// 缓存之前的搜索结果，由于用户一般是一个个字符输入，所以每输入一个新字符时，
// 可以直接基于输入前的搜索的结果进行过滤，节省搜索时间
struct SearchTermCacheItem {
WordIDSet word_id_set_;
HistoryIDSet history_id_set_;
};
typedef std::map<base::string16, SearchTermCacheItem> SearchTermCacheMap;
// 单词索引，根据word_id找单词，word_id为顺序增长
String16Vector word_list_;
// 从word_list_删除单词时将对应的空位放入这里，留待以后使用
base::stack<WordID> available_words_;
// 查找包含某个字符的所有单词
CharWordIDMap char_word_map_;
// 根据单词找到对应的历史记录，即根据URL或title能匹配到的网址
WordIDHistoryMap word_id_history_map_;
所以懂的人估计就看出来其实这是个倒排索引了，现代搜索引擎的根基，但是很惭愧我看完了整个流程才发现是这个玩意。
功能入口URLIndexPrivateData::HistoryItemsForTerms，根据输入字符串返回一个匹配列表。
ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
base::string16 original_search_string,
size_t cursor_position,
...) {
String16Vector search_strings;
search_strings.push_back(original_search_string);
if ((cursor_position != base::string16::npos) &&
(cursor_position < original_search_string.length()) &&
(cursor_position > 0)) {
// 贴心的帮你从当前输入位置给你把字符串断开，当成两个字符串进行搜索，
// 谷歌认为这样能提高匹配成功率（如果你是按顺序输入的，那这个就没什么用）
base::string16 transformed_search_string(original_search_string);
transformed_search_string.insert(cursor_position, base::ASCIIToUTF16(" "));
search_strings.push_back(transformed_search_string);
}
...
bool history_ids_were_trimmed = false;
// 这是一个基于单词的搜索，对字符串分词后可能会有重复的单词，用set去重避免重复搜索
std::set<String16Vector> search_string_words;
for (const base::string16& search_string : search_strings) {
// 转成小写，处理转义字符（诸如%xx）
base::string16 lower_raw_string(base::i18n::ToLower(search_string));
base::string16 lower_unescaped_string = net::UnescapeURLComponent(
lower_raw_string,
net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS |
net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
// 分词
String16Vector lower_words(
String16VectorFromString16(lower_unescaped_string, false, nullptr));
if (lower_words.empty())
continue;
if (search_string_words.find(lower_words) != search_string_words.end())
continue;
search_string_words.insert(lower_words);
// 这里开始进行匹配工作
HistoryIDVector history_ids = HistoryIDsFromWords(lower_words);
...
}
...
}
对输入先做了一些预处理，之后对每个单词分别调用URLIndexPrivateData::HistoryIDsForTerm，查找匹配的项目，最终组合到一起，大体上的流程：
(1) 在char_word_map_中, 对关键词中的每个字符, 找到所有包含该字符的单词
(2) 在word_id_history_map_中, 对(1)中得到的每个单词, 找到所有包含该单词的记录
HistoryIDSet URLIndexPrivateData::HistoryIDsForTerm(
const base::string16& term) {
if (term.empty())
return HistoryIDSet();
size_t term_length = term.length();
WordIDSet word_id_set;
if (term_length > 1) {
// 先在缓存中找最长前缀字符串，如果能找到，可以基于缓存的搜索结果进行过滤
base::string16 term_lower = base::i18n::ToLower(term);
SearchTermCacheMap::iterator best_prefix(search_term_cache_.end());
for (SearchTermCacheMap::iterator cache_iter = search_term_cache_.begin();
cache_iter != search_term_cache_.end(); ++cache_iter) {
if (base::StartsWith(term_lower,
base::i18n::ToLower(cache_iter->first),
base::CompareCase::SENSITIVE) &&
(best_prefix == search_term_cache_.end() ||
cache_iter->first.length() > best_prefix->first.length()))
best_prefix = cache_iter;
}
// 取出除前缀外的剩余部分, 进行匹配,
// 最后将这部分结果与缓存中前缀的匹配结果做交集
Char16Set prefix_chars;
base::string16 leftovers(term);
if (best_prefix != search_term_cache_.end()) {
// 有可能缓存中已经存在了相同的关键词的结果, 直接使用缓存结果
size_t prefix_length = best_prefix->first.length();
if (prefix_length == term_length) {
best_prefix->second.used_ = true;
return best_prefix->second.history_id_set_;
}
// 也有可能前缀的搜索结果是空的, 那就不用继续匹配下去了
if (best_prefix->second.history_id_set_.empty()) {
search_term_cache_[term] = SearchTermCacheItem();
return HistoryIDSet();
}
word_id_set = best_prefix->second.word_id_set_;
prefix_chars = Char16SetFromString16(best_prefix->first);
leftovers = term.substr(prefix_length);
}
// 还是使用set对剩下的字符去重,
// 并找到前缀中不存在的字符, 这样才能进一步过滤结果集
Char16Set leftover_chars = Char16SetFromString16(leftovers);
Char16Set unique_chars =
base::STLSetDifference<Char16Set>(leftover_chars, prefix_chars);
if (!unique_chars.empty()) {
WordIDSet leftover_set(WordIDSetForTermChars(unique_chars));
if (leftover_set.empty()) {
search_term_cache_[term] = SearchTermCacheItem();
return HistoryIDSet();
}
if (prefix_chars.empty()) {
word_id_set = std::move(leftover_set);
} else {
// 做交集处理
base::EraseIf(word_id_set, base::IsNotIn<WordIDSet>(leftover_set));
}
}
// 之前都是按照出现的字符进行的过滤, 实际上出现的字符顺序可能是乱的,
// 所以需要按照搜索字符串的方式再过滤一次, 保证关键词一定是结果的子字符串
base::EraseIf(word_id_set, [this, &term](WordID word_id) {
return word_list_[word_id].find(term) == base::string16::npos;
});
} else {
// 如果只有一个字符就没什么好说的了, 直接按字符查找所有包含该字符的单词,
// 再搜索所有包含该单词的记录, 就是最终结果
word_id_set = WordIDSetForTermChars(Char16SetFromString16(term));
}
// 得到一个包含关键词的单词列表, 然后对该列表中的每个单词,
// 在word_id_history_map_中取出所有匹配的记录, 并用set排重得到最终结果
HistoryIDVector buffer;
for (WordID word_id : word_id_set) {
WordIDHistoryMap::iterator word_iter = word_id_history_map_.find(word_id);
if (word_iter != word_id_history_map_.end()) {
HistoryIDSet& word_history_id_set(word_iter->second);
buffer.insert(buffer.end(), word_history_id_set.begin(),
word_history_id_set.end());
}
}
HistoryIDSet history_id_set(buffer.begin(), buffer.end(),
base::KEEP_FIRST_OF_DUPES);
// 将本次匹配结果加入缓存
if (term_length > 1)
search_term_cache_[term] = SearchTermCacheItem(word_id_set, history_id_set);
return history_id_set;
}
匹配的流程就是这样，当然了这也要求了要对数据进行预处理，其实也挺简单，就是建立索引的过程可能有点耗时，所以chrome对索引本身做了文件缓存，这部分就没有仔细研究了，66版本好像是直接用protocol buffer序列成二进制流写到History Provider Cache文件里，但是从代码注释看，谷歌后面版本可能会改用数据库对索引进行存储。
知道倒排索引的话就很容易理解这个搜索过程；最后总结：
- 因为进行了分词处理，以单词为单位进行搜索，所以输入的几个单词之间顺序反了不影响匹配结果，每个单词都没输入全也不影响匹配结果；
- 使用int类型做为单词ID，并用单词ID去索引URL记录，相比于直接用单词当map的key来索引URL记录降低了内存占用，也加快了map的查找速度（这个正常人应该都能想到）
- 单词ID直接顺序增长，所有单词存一个vector就可以，然后删除的话不需要实际删除，只需要将留出来的index放入空闲列表中供后面使用就可以（我的第一感是算个hash然后存map，还是没这个省事）
- 索引本身也是可以缓存成文件的，节省了重新建立索引消耗的时间
