Fix various problems with inline autocomplete and URLs that change length dur...

chrome/browser/autocomplete/history_url_provider.cc

 // Copyright (c) 2009 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 "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/histogram.h"
@@ skipping 50 matching lines @@
   done_ = true;
 
   if (params_)
     params_->cancel = true;
 }
 
 void HistoryURLProvider::DeleteMatch(const AutocompleteMatch& match) {
   DCHECK(done_);
 
   // Delete the match from the history DB.
-  HistoryService* history_service =
-      profile_ ? profile_->GetHistoryService(Profile::EXPLICIT_ACCESS) :
-      history_service_;
+  HistoryService* const history_service =
+      profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   GURL selected_url(match.destination_url);
   if (!history_service || !selected_url.is_valid()) {
     NOTREACHED() << "Can't delete requested URL";
     return;
   }
   history_service->DeleteURL(selected_url);
 
   // Delete the match from the current set of matches.
   bool found = false;
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i) {
@@ skipping 537 matching lines @@
   // we'll run this again in DoAutocomplete() and use that result instead.
   const bool trim_http = !url_util::FindAndCompareScheme(
       WideToUTF8(input.text()), chrome::kHttpScheme, NULL);
   // Don't do this for queries -- while we can sometimes mark up a match for
   // this, it's not what the user wants, and just adds noise.
   if ((input.type() != AutocompleteInput::QUERY) &&
       input.canonicalized_url().is_valid())
     matches_.push_back(SuggestExactInput(input, trim_http));
 
   // We'll need the history service to run both passes, so try to obtain it.
-  HistoryService* const history_service = profile_ ?
-      profile_->GetHistoryService(Profile::EXPLICIT_ACCESS) : history_service_;
+  HistoryService* const history_service =
+      profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (!history_service)
     return;
 
   // Create the data structure for the autocomplete passes.  We'll save this off
   // onto the |params_| member for later deletion below if we need to run pass
   // 2.
-  const std::wstring& languages = profile_ ?
-      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages) : std::wstring();
+  std::wstring languages(languages_);
+  if (languages.empty() && profile_)
+    languages = profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
   scoped_ptr<HistoryURLProviderParams> params(
       new HistoryURLProviderParams(input, trim_http, languages));
 
   if (fixup_input_and_run_pass_1) {
     // Do some fixup on the user input before matching against it, so we provide
     // good results for local file paths, input with spaces, etc.
     // NOTE: This purposefully doesn't take input.desired_tld() into account; if
     // it did, then holding "ctrl" would change all the results from the
     // HistoryURLProvider provider, not just the What You Typed Result.
     const std::wstring fixed_text(FixupUserInput(input));
@@ skipping 168 matching lines @@
     HistoryURLProviderParams* params,
     const HistoryMatch& history_match,
     MatchType match_type,
     size_t match_number) {
   const history::URLRow& info = history_match.url_info;
   AutocompleteMatch match(this,
       CalculateRelevance(params->input.type(), match_type, match_number),
       !!info.visit_count(), AutocompleteMatch::HISTORY_URL);
   match.destination_url = info.url();
   DCHECK(match.destination_url.is_valid());
+  size_t inline_autocomplete_offset =
+      history_match.input_location + params->input.text().length();
   match.fill_into_edit = net::FormatUrl(info.url(),
-      match_type == WHAT_YOU_TYPED ? std::wstring() : params->languages);
-  if (!params->input.prevent_inline_autocomplete()) {
-    match.inline_autocomplete_offset =
-        history_match.input_location + params->input.text().length();
-  }
+      match_type == WHAT_YOU_TYPED ? std::wstring() : params->languages, true,
+      UnescapeRule::SPACES, NULL, NULL, &inline_autocomplete_offset);
   size_t offset = 0;
   if (params->trim_http && !history_match.match_in_scheme) {
     offset = TrimHttpPrefix(&match.fill_into_edit);
-    if (match.inline_autocomplete_offset != std::wstring::npos) {
-      DCHECK(match.inline_autocomplete_offset >= offset);
-      match.inline_autocomplete_offset -= offset;
+    if (inline_autocomplete_offset != std::wstring::npos) {
+      DCHECK(inline_autocomplete_offset >= offset);
+      inline_autocomplete_offset -= offset;
     }
   }
+  if (!params->input.prevent_inline_autocomplete())
+    match.inline_autocomplete_offset = inline_autocomplete_offset;
   DCHECK((match.inline_autocomplete_offset == std::wstring::npos) ||
          (match.inline_autocomplete_offset <= match.fill_into_edit.length()));
 
-  match.contents = match.fill_into_edit;
-  AutocompleteMatch::ClassifyLocationInString(
-      history_match.input_location - offset, params->input.text().length(),
-      match.contents.length(), ACMatchClassification::URL,
-      &match.contents_class);
+  size_t match_start = history_match.input_location;
+  match.contents = net::FormatUrl(info.url(),
+      match_type == WHAT_YOU_TYPED ? std::wstring() : params->languages, true,
+      UnescapeRule::SPACES, NULL, NULL, &match_start);
+  if (offset) {
+    TrimHttpPrefix(&match.contents);
+    if (match_start != std::wstring::npos) {
+      DCHECK(match_start >= offset);
+      match_start -= offset;
+    }
+  }
+  if ((match_start != std::wstring::npos) &&
+      (inline_autocomplete_offset != std::wstring::npos) &&
+      (inline_autocomplete_offset != match_start)) {
+    DCHECK(inline_autocomplete_offset > match_start);
+    AutocompleteMatch::ClassifyLocationInString(match_start,
+        inline_autocomplete_offset - match_start, match.contents.length(),
+        ACMatchClassification::URL, &match.contents_class);
+  } else {
+    AutocompleteMatch::ClassifyLocationInString(std::wstring::npos, 0,
+        match.contents.length(), ACMatchClassification::URL,
+        &match.contents_class);
+  }
   match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params->input.text(), info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   return match;
 }