1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/autocomplete/history_quick_provider.h" 6 7 #include <vector> 8 9 #include "base/basictypes.h" 10 #include "base/command_line.h" 11 #include "base/i18n/break_iterator.h" 12 #include "base/logging.h" 13 #include "base/metrics/field_trial.h" 14 #include "base/metrics/histogram.h" 15 #include "base/prefs/pref_service.h" 16 #include "base/strings/string_number_conversions.h" 17 #include "base/strings/string_util.h" 18 #include "base/strings/utf_string_conversions.h" 19 #include "base/time/time.h" 20 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h" 21 #include "chrome/browser/autocomplete/history_url_provider.h" 22 #include "chrome/browser/history/history_database.h" 23 #include "chrome/browser/history/history_service.h" 24 #include "chrome/browser/history/history_service_factory.h" 25 #include "chrome/browser/history/in_memory_url_index.h" 26 #include "chrome/browser/history/in_memory_url_index_types.h" 27 #include "chrome/browser/history/scored_history_match.h" 28 #include "chrome/browser/profiles/profile.h" 29 #include "chrome/browser/search_engines/template_url_service_factory.h" 30 #include "chrome/common/chrome_switches.h" 31 #include "chrome/common/pref_names.h" 32 #include "chrome/common/url_constants.h" 33 #include "components/metrics/proto/omnibox_input_type.pb.h" 34 #include "components/omnibox/autocomplete_match_type.h" 35 #include "components/omnibox/autocomplete_result.h" 36 #include "components/omnibox/omnibox_field_trial.h" 37 #include "components/search_engines/template_url.h" 38 #include "components/search_engines/template_url_service.h" 39 #include "content/public/browser/notification_source.h" 40 #include "content/public/browser/notification_types.h" 41 #include "net/base/escape.h" 42 #include "net/base/net_util.h" 43 #include "net/base/registry_controlled_domains/registry_controlled_domain.h" 44 #include "url/url_parse.h" 45 #include "url/url_util.h" 46 47 using history::InMemoryURLIndex; 48 using history::ScoredHistoryMatch; 49 using history::ScoredHistoryMatches; 50 51 bool HistoryQuickProvider::disabled_ = false; 52 53 HistoryQuickProvider::HistoryQuickProvider(Profile* profile) 54 : HistoryProvider(profile, AutocompleteProvider::TYPE_HISTORY_QUICK), 55 languages_(profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)) { 56 } 57 58 void HistoryQuickProvider::Start(const AutocompleteInput& input, 59 bool minimal_changes) { 60 matches_.clear(); 61 if (disabled_) 62 return; 63 64 // Don't bother with INVALID and FORCED_QUERY. 65 if ((input.type() == metrics::OmniboxInputType::INVALID) || 66 (input.type() == metrics::OmniboxInputType::FORCED_QUERY)) 67 return; 68 69 autocomplete_input_ = input; 70 71 // TODO(pkasting): We should just block here until this loads. Any time 72 // someone unloads the history backend, we'll get inconsistent inline 73 // autocomplete behavior here. 74 if (GetIndex()) { 75 base::TimeTicks start_time = base::TimeTicks::Now(); 76 DoAutocomplete(); 77 if (input.text().length() < 6) { 78 base::TimeTicks end_time = base::TimeTicks::Now(); 79 std::string name = "HistoryQuickProvider.QueryIndexTime." + 80 base::IntToString(input.text().length()); 81 base::HistogramBase* counter = base::Histogram::FactoryGet( 82 name, 1, 1000, 50, base::Histogram::kUmaTargetedHistogramFlag); 83 counter->Add(static_cast<int>((end_time - start_time).InMilliseconds())); 84 } 85 } 86 } 87 88 HistoryQuickProvider::~HistoryQuickProvider() {} 89 90 void HistoryQuickProvider::DoAutocomplete() { 91 // Get the matching URLs from the DB. 92 ScoredHistoryMatches matches = GetIndex()->HistoryItemsForTerms( 93 autocomplete_input_.text(), 94 autocomplete_input_.cursor_position(), 95 AutocompleteProvider::kMaxMatches); 96 if (matches.empty()) 97 return; 98 99 // Figure out if HistoryURL provider has a URL-what-you-typed match 100 // that ought to go first and what its score will be. 101 bool will_have_url_what_you_typed_match_first = false; 102 int url_what_you_typed_match_score = -1; // undefined 103 // These are necessary (but not sufficient) conditions for the omnibox 104 // input to be a URL-what-you-typed match. The username test checks that 105 // either the username does not exist (a regular URL such as http://site/) 106 // or, if the username exists (http://user@site/), there must be either 107 // a password or a port. Together these exclude pure username@site 108 // inputs because these are likely to be an e-mail address. HistoryURL 109 // provider won't promote the URL-what-you-typed match to first 110 // for these inputs. 111 const bool can_have_url_what_you_typed_match_first = 112 (autocomplete_input_.type() != metrics::OmniboxInputType::QUERY) && 113 (!autocomplete_input_.parts().username.is_nonempty() || 114 autocomplete_input_.parts().password.is_nonempty() || 115 autocomplete_input_.parts().path.is_nonempty()); 116 if (can_have_url_what_you_typed_match_first) { 117 HistoryService* const history_service = 118 HistoryServiceFactory::GetForProfile(profile_, 119 Profile::EXPLICIT_ACCESS); 120 // We expect HistoryService to be available. In case it's not, 121 // (e.g., due to Profile corruption) we let HistoryQuick provider 122 // completions (which may be available because it's a different 123 // data structure) compete with the URL-what-you-typed match as 124 // normal. 125 if (history_service) { 126 history::URLDatabase* url_db = history_service->InMemoryDatabase(); 127 // url_db can be NULL if it hasn't finished initializing (or 128 // failed to to initialize). In this case, we let HistoryQuick 129 // provider completions compete with the URL-what-you-typed 130 // match as normal. 131 if (url_db) { 132 const std::string host(base::UTF16ToUTF8( 133 autocomplete_input_.text().substr( 134 autocomplete_input_.parts().host.begin, 135 autocomplete_input_.parts().host.len))); 136 // We want to put the URL-what-you-typed match first if either 137 // * the user visited the URL before (intranet or internet). 138 // * it's a URL on a host that user visited before and this 139 // is the root path of the host. (If the user types some 140 // of a path--more than a simple "/"--we let autocomplete compete 141 // normally with the URL-what-you-typed match.) 142 // TODO(mpearson): Remove this hacky code and simply score URL-what- 143 // you-typed in some sane way relative to possible completions: 144 // URL-what-you-typed should get some sort of a boost relative 145 // to completions, but completions should naturally win if 146 // they're a lot more popular. In this process, if the input 147 // is a bare intranet hostname that has been visited before, we 148 // may want to enforce that the only completions that can outscore 149 // the URL-what-you-typed match are on the same host (i.e., aren't 150 // from a longer internet hostname for which the omnibox input is 151 // a prefix). 152 if (url_db->GetRowForURL( 153 autocomplete_input_.canonicalized_url(), NULL) != 0) { 154 // We visited this URL before. 155 will_have_url_what_you_typed_match_first = true; 156 // HistoryURLProvider gives visited what-you-typed URLs a high score. 157 url_what_you_typed_match_score = 158 HistoryURLProvider::kScoreForBestInlineableResult; 159 } else if (url_db->IsTypedHost(host) && 160 (!autocomplete_input_.parts().path.is_nonempty() || 161 ((autocomplete_input_.parts().path.len == 1) && 162 (autocomplete_input_.text()[ 163 autocomplete_input_.parts().path.begin] == '/'))) && 164 !autocomplete_input_.parts().query.is_nonempty() && 165 !autocomplete_input_.parts().ref.is_nonempty()) { 166 // Not visited, but we've seen the host before. 167 will_have_url_what_you_typed_match_first = true; 168 const size_t registry_length = 169 net::registry_controlled_domains::GetRegistryLength( 170 host, 171 net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES, 172 net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES); 173 if (registry_length == 0) { 174 // Known intranet hosts get one score. 175 url_what_you_typed_match_score = 176 HistoryURLProvider::kScoreForUnvisitedIntranetResult; 177 } else { 178 // Known internet hosts get another. 179 url_what_you_typed_match_score = 180 HistoryURLProvider::kScoreForWhatYouTypedResult; 181 } 182 } 183 } 184 } 185 } 186 187 // Loop over every result and add it to matches_. In the process, 188 // guarantee that scores are decreasing. |max_match_score| keeps 189 // track of the highest score we can assign to any later results we 190 // see. Also, reduce |max_match_score| if we think there will be 191 // a URL-what-you-typed match. (We want URL-what-you-typed matches for 192 // visited URLs to beat out any longer URLs, no matter how frequently 193 // they're visited.) The strength of this reduction depends on the 194 // likely score for the URL-what-you-typed result. 195 196 // |template_url_service| or |template_url| can be NULL in unit tests. 197 TemplateURLService* template_url_service = 198 TemplateURLServiceFactory::GetForProfile(profile_); 199 TemplateURL* template_url = template_url_service ? 200 template_url_service->GetDefaultSearchProvider() : NULL; 201 int max_match_score = matches.begin()->raw_score(); 202 if (will_have_url_what_you_typed_match_first) { 203 max_match_score = std::min(max_match_score, 204 url_what_you_typed_match_score - 1); 205 } 206 for (ScoredHistoryMatches::const_iterator match_iter = matches.begin(); 207 match_iter != matches.end(); ++match_iter) { 208 const ScoredHistoryMatch& history_match(*match_iter); 209 // Culls results corresponding to queries from the default search engine. 210 // These are low-quality, difficult-to-understand matches for users, and the 211 // SearchProvider should surface past queries in a better way anyway. 212 if (!template_url || 213 !template_url->IsSearchURL(history_match.url_info.url(), 214 template_url_service->search_terms_data())) { 215 // Set max_match_score to the score we'll assign this result: 216 max_match_score = std::min(max_match_score, history_match.raw_score()); 217 matches_.push_back(QuickMatchToACMatch(history_match, max_match_score)); 218 // Mark this max_match_score as being used: 219 max_match_score--; 220 } 221 } 222 } 223 224 AutocompleteMatch HistoryQuickProvider::QuickMatchToACMatch( 225 const ScoredHistoryMatch& history_match, 226 int score) { 227 const history::URLRow& info = history_match.url_info; 228 AutocompleteMatch match( 229 this, score, !!info.visit_count(), 230 history_match.url_matches().empty() ? 231 AutocompleteMatchType::HISTORY_TITLE : 232 AutocompleteMatchType::HISTORY_URL); 233 match.typed_count = info.typed_count(); 234 match.destination_url = info.url(); 235 DCHECK(match.destination_url.is_valid()); 236 237 // Format the URL autocomplete presentation. 238 const net::FormatUrlTypes format_types = net::kFormatUrlOmitAll & 239 ~(!history_match.match_in_scheme ? 0 : net::kFormatUrlOmitHTTP); 240 match.fill_into_edit = 241 AutocompleteInput::FormattedStringWithEquivalentMeaning( 242 info.url(), 243 net::FormatUrl(info.url(), languages_, format_types, 244 net::UnescapeRule::SPACES, NULL, NULL, NULL), 245 ChromeAutocompleteSchemeClassifier(profile_)); 246 std::vector<size_t> offsets = 247 OffsetsFromTermMatches(history_match.url_matches()); 248 base::OffsetAdjuster::Adjustments adjustments; 249 match.contents = net::FormatUrlWithAdjustments( 250 info.url(), languages_, format_types, net::UnescapeRule::SPACES, NULL, 251 NULL, &adjustments); 252 base::OffsetAdjuster::AdjustOffsets(adjustments, &offsets); 253 history::TermMatches new_matches = 254 ReplaceOffsetsInTermMatches(history_match.url_matches(), offsets); 255 match.contents_class = 256 SpansFromTermMatch(new_matches, match.contents.length(), true); 257 258 // Set |inline_autocompletion| and |allowed_to_be_default_match| if possible. 259 if (history_match.can_inline()) { 260 DCHECK(!new_matches.empty()); 261 size_t inline_autocomplete_offset = new_matches[0].offset + 262 new_matches[0].length; 263 // |inline_autocomplete_offset| may be beyond the end of the 264 // |fill_into_edit| if the user has typed an URL with a scheme and the 265 // last character typed is a slash. That slash is removed by the 266 // FormatURLWithOffsets call above. 267 if (inline_autocomplete_offset < match.fill_into_edit.length()) { 268 match.inline_autocompletion = 269 match.fill_into_edit.substr(inline_autocomplete_offset); 270 } 271 match.allowed_to_be_default_match = match.inline_autocompletion.empty() || 272 !PreventInlineAutocomplete(autocomplete_input_); 273 } 274 match.EnsureUWYTIsAllowedToBeDefault( 275 autocomplete_input_.canonicalized_url(), 276 TemplateURLServiceFactory::GetForProfile(profile_)); 277 278 // Format the description autocomplete presentation. 279 match.description = info.title(); 280 match.description_class = SpansFromTermMatch( 281 history_match.title_matches(), match.description.length(), false); 282 283 match.RecordAdditionalInfo("typed count", info.typed_count()); 284 match.RecordAdditionalInfo("visit count", info.visit_count()); 285 match.RecordAdditionalInfo("last visit", info.last_visit()); 286 287 return match; 288 } 289 290 history::InMemoryURLIndex* HistoryQuickProvider::GetIndex() { 291 if (index_for_testing_.get()) 292 return index_for_testing_.get(); 293 294 HistoryService* const history_service = 295 HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS); 296 if (!history_service) 297 return NULL; 298 299 return history_service->InMemoryIndex(); 300 } 301
