Remove wstring from autocomplete....

chrome/browser/autocomplete/autocomplete_edit.cc

 // Copyright (c) 2011 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/autocomplete_edit.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/metrics/histogram.h"
@@ skipping 25 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditController
 
 AutocompleteEditController::~AutocompleteEditController() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditModel::State
 
 AutocompleteEditModel::State::State(bool user_input_in_progress,
-                                    const std::wstring& user_text,
-                                    const std::wstring& keyword,
+                                    const string16& user_text,
+                                    const string16& keyword,
                                     bool is_keyword_hint)
     : user_input_in_progress(user_input_in_progress),
       user_text(user_text),
       keyword(keyword),
       is_keyword_hint(is_keyword_hint) {
 }
 
 AutocompleteEditModel::State::~State() {
 }
 
@@ skipping 36 matching lines @@
 
 const AutocompleteEditModel::State
     AutocompleteEditModel::GetStateForTabSwitch() {
   // Like typing, switching tabs "accepts" the temporary text as the user
   // text, because it makes little sense to have temporary text when the
   // popup is closed.
   if (user_input_in_progress_) {
     // Weird edge case to match other browsers: if the edit is empty, revert to
     // the permanent text (so the user can get it back easily) but select it (so
     // on switching back, typing will "just work").
-    const std::wstring user_text(UserTextFromDisplayText(view_->GetText()));
+    const string16 user_text(UserTextFromDisplayText(view_->GetText()));
     if (user_text.empty()) {
       view_->RevertAll();
       view_->SelectAll(true);
     } else {
       InternalSetUserText(user_text);
     }
   }
 
   return State(user_input_in_progress_, user_text_, keyword_, is_keyword_hint_);
 }
@@ skipping 10 matching lines @@
   }
 }
 
 AutocompleteMatch AutocompleteEditModel::CurrentMatch() {
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   return match;
 }
 
 bool AutocompleteEditModel::UpdatePermanentText(
-    const std::wstring& new_permanent_text) {
+    const string16& new_permanent_text) {
   // When there's a new URL, and the user is not editing anything or the edit
   // doesn't have focus, we want to revert the edit to show the new URL.  (The
   // common case where the edit doesn't have focus is when the user has started
   // an edit and then abandoned it and clicked a link on the page.)
   const bool visibly_changed_permanent_text =
       (permanent_text_ != new_permanent_text) &&
       (!user_input_in_progress_ || !has_focus_);
 
   permanent_text_ = new_permanent_text;
   return visibly_changed_permanent_text;
 }
 
-void AutocompleteEditModel::SetUserText(const std::wstring& text) {
+void AutocompleteEditModel::SetUserText(const string16& text) {
   SetInputInProgress(true);
   InternalSetUserText(text);
   paste_state_ = NONE;
   has_temporary_text_ = false;
 }
 
 void AutocompleteEditModel::FinalizeInstantQuery(
-    const std::wstring& input_text,
-    const std::wstring& suggest_text) {
+    const string16& input_text,
+    const string16& suggest_text) {
   popup_->FinalizeInstantQuery(input_text, suggest_text);
 }
 
 void AutocompleteEditModel::GetDataForURLExport(GURL* url,
-                                                std::wstring* title,
+                                                string16* title,
                                                 SkBitmap* favicon) {
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   *url = match.destination_url;
-  if (*url == URLFixerUpper::FixupURL(WideToUTF8(permanent_text_),
+  if (*url == URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_),
                                       std::string())) {
     *title = controller_->GetTitle();
     *favicon = controller_->GetFavIcon();
   }
 }
 
 bool AutocompleteEditModel::UseVerbatimInstant() {
 #if defined(OS_MACOSX)
   // TODO(suzhe): Fix Mac port to display Instant suggest in a separated NSView,
   // so that we can display instant suggest along with composition text.
   const AutocompleteInput& input = popup_->autocomplete_controller()->input();
   if (input.initial_prevent_inline_autocomplete())
     return true;
 #endif
 
   // The value of input.initial_prevent_inline_autocomplete() is determined by
   // following conditions:
   // 1. If the caret is at the end of the text (checked below).
   // 2. If it's in IME composition mode.
   // As we use a separated widget for displaying the instant suggest, it won't
   // interfere with IME composition, so we don't need to care about the value of
   // input.initial_prevent_inline_autocomplete() here.
   if (view_->DeleteAtEndPressed() || (popup_->selected_line() != 0) ||
       just_deleted_text_)
     return true;
 
-  std::wstring::size_type start, end;
+  string16::size_type start, end;
   view_->GetSelectionBounds(&start, &end);
   return (start != end) || (start != view_->GetText().size());
 }
 
-std::wstring AutocompleteEditModel::GetDesiredTLD() const {
+string16 AutocompleteEditModel::GetDesiredTLD() const {
   // Tricky corner case: The user has typed "foo" and currently sees an inline
   // autocomplete suggestion of "foo.net".  He now presses ctrl-a (e.g. to
   // select all, on Windows).  If we treat the ctrl press as potentially for the
   // sake of ctrl-enter, then we risk "www.foo.com" being promoted as the best
   // match.  This would make the autocompleted text disappear, leaving our user
   // feeling very confused when the wrong text gets highlighted.
   //
   // Thus, we only treat the user as pressing ctrl-enter when the user presses
   // ctrl without any fragile state built up in the omnibox:
   // * the contents of the omnibox have not changed since the keypress,
   // * there is no autocompleted text visible, and
   // * the user is not typing a keyword query.
   return (control_key_state_ == DOWN_WITHOUT_CHANGE &&
           inline_autocomplete_text_.empty() && !KeywordIsSelected())?
-    std::wstring(L"com") : std::wstring();
+    ASCIIToUTF16("com") : string16();
 }
 
 bool AutocompleteEditModel::CurrentTextIsURL() const {
   // If !user_input_in_progress_, the permanent text is showing, which should
   // always be a URL, so no further checking is needed.  By avoiding checking in
   // this case, we avoid calling into the autocomplete providers, and thus
   // initializing the history system, as long as possible, which speeds startup.
   if (!user_input_in_progress_)
     return true;
 
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   return match.transition == PageTransition::TYPED;
 }
 
 AutocompleteMatch::Type AutocompleteEditModel::CurrentTextType() const {
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   return match.type;
 }
 
 void AutocompleteEditModel::AdjustTextForCopy(int sel_min,
                                               bool is_all_selected,
-                                              std::wstring* text,
+                                              string16* text,
                                               GURL* url,
                                               bool* write_url) {
   *write_url = false;
 
   if (sel_min != 0)
     return;
 
   // We can't use CurrentTextIsURL() or GetDataForURLExport() because right now
   // the user is probably holding down control to cause the copy, which will
   // screw up our calculation of the desired_tld.
   if (!GetURLForText(*text, url))
     return;  // Can't be parsed as a url, no need to adjust text.
 
   if (!user_input_in_progress() && is_all_selected) {
     // The user selected all the text and has not edited it. Use the url as the
     // text so that if the scheme was stripped it's added back, and the url
     // is unescaped (we escape parts of the url for display).
-    *text = UTF8ToWide(url->spec());
+    *text = UTF8ToUTF16(url->spec());
     *write_url = true;
     return;
   }
 
   // Prefix the text with 'http://' if the text doesn't start with 'http://',
   // the text parses as a url with a scheme of http, the user selected the
   // entire host, and the user hasn't edited the host or manually removed the
   // scheme.
   GURL perm_url;
   if (GetURLForText(permanent_text_, &perm_url) &&
       perm_url.SchemeIs(chrome::kHttpScheme) &&
       url->SchemeIs(chrome::kHttpScheme) &&
       perm_url.host() == url->host()) {
     *write_url = true;
 
-    std::wstring http = ASCIIToWide(chrome::kHttpScheme) +
-        ASCIIToWide(chrome::kStandardSchemeSeparator);
+    string16 http = ASCIIToUTF16(chrome::kHttpScheme) +
+        ASCIIToUTF16(chrome::kStandardSchemeSeparator);
     if (text->compare(0, http.length(), http) != 0)
       *text = http + *text;
   }
 }
 
 void AutocompleteEditModel::SetInputInProgress(bool in_progress) {
   if (user_input_in_progress_ == in_progress)
     return;
 
   user_input_in_progress_ = in_progress;
   controller_->OnInputInProgress(in_progress);
 }
 
 void AutocompleteEditModel::Revert() {
   SetInputInProgress(false);
   paste_state_ = NONE;
-  InternalSetUserText(std::wstring());
+  InternalSetUserText(string16());
   keyword_.clear();
   is_keyword_hint_ = false;
   has_temporary_text_ = false;
   view_->SetWindowTextAndCaretPos(permanent_text_,
                                   has_focus_ ? permanent_text_.length() : 0);
 }
 
 void AutocompleteEditModel::StartAutocomplete(
     bool has_selected_text,
     bool prevent_inline_autocomplete) const {
   bool keyword_is_selected = KeywordIsSelected();
   popup_->StartAutocomplete(user_text_, GetDesiredTLD(),
       prevent_inline_autocomplete || just_deleted_text_ ||
       (has_selected_text && inline_autocomplete_text_.empty()) ||
       (paste_state_ != NONE), keyword_is_selected, keyword_is_selected);
 }
 
-bool AutocompleteEditModel::CanPasteAndGo(const std::wstring& text) const {
+bool AutocompleteEditModel::CanPasteAndGo(const string16& text) const {
   if (!view_->GetCommandUpdater()->IsCommandEnabled(IDC_OPEN_CURRENT_URL))
     return false;
 
   AutocompleteMatch match;
-  profile_->GetAutocompleteClassifier()->Classify(text, std::wstring(), false,
+  profile_->GetAutocompleteClassifier()->Classify(text, string16(), false,
       &match, &paste_and_go_alternate_nav_url_);
   paste_and_go_url_ = match.destination_url;
   paste_and_go_transition_ = match.transition;
   return paste_and_go_url_.is_valid();
 }
 
 void AutocompleteEditModel::PasteAndGo() {
   // The final parameter to OpenURL, keyword, is not quite correct here: it's
   // possible to "paste and go" a string that contains a keyword.  This is
   // enough of an edge case that we ignore this possibility.
   view_->RevertAll();
   view_->OpenURL(paste_and_go_url_, CURRENT_TAB, paste_and_go_transition_,
       paste_and_go_alternate_nav_url_, AutocompletePopupModel::kNoMatch,
-      std::wstring());
+      string16());
 }
 
 void AutocompleteEditModel::AcceptInput(WindowOpenDisposition disposition,
                                         bool for_drop) {
   // Get the URL and transition type for the selected entry.
   AutocompleteMatch match;
   GURL alternate_nav_url;
   GetInfoForCurrentText(&match, &alternate_nav_url);
 
   if (!match.destination_url.is_valid())
     return;
 
   if ((match.transition == PageTransition::TYPED) && (match.destination_url ==
-      URLFixerUpper::FixupURL(WideToUTF8(permanent_text_), std::string()))) {
+      URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_), std::string()))) {
     // When the user hit enter on the existing permanent URL, treat it like a
     // reload for scoring purposes.  We could detect this by just checking
     // user_input_in_progress_, but it seems better to treat "edits" that end
     // up leaving the URL unchanged (e.g. deleting the last character and then
     // retyping it) as reloads too.  We exclude non-TYPED transitions because if
     // the transition is GENERATED, the user input something that looked
     // different from the current URL, even if it wound up at the same place
     // (e.g. manually retyping the same search query), and it seems wrong to
     // treat this as a reload.
     match.transition = PageTransition::RELOAD;
   } else if (for_drop || ((paste_state_ != NONE) &&
                           match.is_history_what_you_typed_match)) {
     // When the user pasted in a URL and hit enter, score it like a link click
     // rather than a normal typed URL, so it doesn't get inline autocompleted
     // as aggressively later.
     match.transition = PageTransition::LINK;
   }
 
   if (match.type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED ||
       match.type == AutocompleteMatch::SEARCH_HISTORY ||
       match.type == AutocompleteMatch::SEARCH_SUGGEST) {
     const TemplateURL* default_provider =
         profile_->GetTemplateURLModel()->GetDefaultSearchProvider();
     if (default_provider && default_provider->url() &&
         default_provider->url()->HasGoogleBaseURLs())
       GoogleURLTracker::GoogleURLSearchCommitted();
   }
   view_->OpenURL(match.destination_url, disposition, match.transition,
                  alternate_nav_url, AutocompletePopupModel::kNoMatch,
-                 is_keyword_hint_ ? std::wstring() : keyword_);
+                 is_keyword_hint_ ? string16() : keyword_);
 }
 
 void AutocompleteEditModel::OpenURL(const GURL& url,
                                     WindowOpenDisposition disposition,
                                     PageTransition::Type transition,
                                     const GURL& alternate_nav_url,
                                     size_t index,
-                                    const std::wstring& keyword) {
+                                    const string16& keyword) {
   // We only care about cases where there is a selection (i.e. the popup is
   // open).
   if (popup_->IsOpen()) {
     scoped_ptr<AutocompleteLog> log(popup_->GetAutocompleteLog());
     if (index != AutocompletePopupModel::kNoMatch)
       log->selected_index = index;
     else if (!has_temporary_text_)
       log->inline_autocompleted_length = inline_autocomplete_text_.length();
     NotificationService::current()->Notify(
         NotificationType::OMNIBOX_OPENED_URL, Source<Profile>(profile_),
         Details<AutocompleteLog>(log.get()));
   }
 
   TemplateURLModel* template_url_model = profile_->GetTemplateURLModel();
   if (template_url_model && !keyword.empty()) {
     const TemplateURL* const template_url =
-        template_url_model->GetTemplateURLForKeyword(WideToUTF16Hack(keyword));
+        template_url_model->GetTemplateURLForKeyword(keyword);
 
     // Special case for extension keywords. Don't increment usage count for
     // these.
     if (template_url && template_url->IsExtensionKeyword()) {
       AutocompleteMatch current_match;
       GetInfoForCurrentText(&current_match, NULL);
 
       const AutocompleteMatch& match =
           index == AutocompletePopupModel::kNoMatch ?
               current_match : result().match_at(index);
 
       // Strip the keyword + leading space off the input.
       size_t prefix_length = match.template_url->keyword().size() + 1;
       ExtensionOmniboxEventRouter::OnInputEntered(
           profile_, match.template_url->GetExtensionId(),
-          WideToUTF8(match.fill_into_edit.substr(prefix_length)));
+          UTF16ToUTF8(match.fill_into_edit.substr(prefix_length)));
       view_->RevertAll();
       return;
     }
 
     if (template_url) {
       UserMetrics::RecordAction(UserMetricsAction("AcceptedKeyword"), profile_);
       template_url_model->IncrementUsageCount(template_url);
     }
 
     // NOTE: We purposefully don't increment the usage count of the default
     // search engine, if applicable; see comments in template_url.h.
   }
 
   if (disposition != NEW_BACKGROUND_TAB) {
     controller_->OnAutocompleteWillAccept();
     view_->RevertAll();  // Revert the box to its unedited state
   }
   controller_->OnAutocompleteAccept(url, disposition, transition,
                                     alternate_nav_url);
 }
 
 bool AutocompleteEditModel::AcceptKeyword() {
   DCHECK(is_keyword_hint_ && !keyword_.empty());
 
   view_->OnBeforePossibleChange();
-  view_->SetWindowTextAndCaretPos(std::wstring(), 0);
+  view_->SetWindowTextAndCaretPos(string16(), 0);
   is_keyword_hint_ = false;
   view_->OnAfterPossibleChange();
   just_deleted_text_ = false;  // OnAfterPossibleChange() erroneously sets this
                                // since the edit contents have disappeared.  It
                                // doesn't really matter, but we clear it to be
                                // consistent.
   UserMetrics::RecordAction(UserMetricsAction("AcceptedKeywordHint"), profile_);
   return true;
 }
 
-void AutocompleteEditModel::ClearKeyword(const std::wstring& visible_text) {
+void AutocompleteEditModel::ClearKeyword(const string16& visible_text) {
   view_->OnBeforePossibleChange();
-  const std::wstring window_text(keyword_ + visible_text);
+  const string16 window_text(keyword_ + visible_text);
   view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length());
   keyword_.clear();
   is_keyword_hint_ = false;
   view_->OnAfterPossibleChange();
   just_deleted_text_ = true;  // OnAfterPossibleChange() fails to clear this
                               // since the edit contents have actually grown
                               // longer.
 }
 
 bool AutocompleteEditModel::query_in_progress() const {
@@ skipping 97 matching lines @@
       // should force it to open immediately.
     }
   } else {
     // The popup is open, so the user should be able to interact with it
     // normally.
     popup_->Move(count);
   }
 }
 
 void AutocompleteEditModel::OnPopupDataChanged(
-    const std::wstring& text,
+    const string16& text,
     GURL* destination_for_temporary_text_change,
-    const std::wstring& keyword,
+    const string16& keyword,
     bool is_keyword_hint) {
   // Update keyword/hint-related local state.
   bool keyword_state_changed = (keyword_ != keyword) ||
       ((is_keyword_hint_ != is_keyword_hint) && !keyword.empty());
   if (keyword_state_changed) {
     keyword_ = keyword;
     is_keyword_hint_ = is_keyword_hint;
 
     // |is_keyword_hint_| should always be false if |keyword_| is empty.
     DCHECK(!keyword_.empty() || !is_keyword_hint_);
@@ skipping 33 matching lines @@
       DisplayTextFromUserText(user_text_).length()))
     return;
 
   // All other code paths that return invoke OnChanged. We need to invoke
   // OnChanged in case the destination url changed (as could happen when control
   // is toggled).
   controller_->OnChanged();
 }
 
 bool AutocompleteEditModel::OnAfterPossibleChange(
-    const std::wstring& new_text,
+    const string16& new_text,
     bool selection_differs,
     bool text_differs,
     bool just_deleted_text,
     bool allow_keyword_ui_change) {
   // Update the paste state as appropriate: if we're just finishing a paste
   // that replaced all the text, preserve that information; otherwise, if we've
   // made some other edit, clear paste tracking.
   if (paste_state_ == PASTING)
     paste_state_ = PASTED;
   else if (text_differs)
@@ skipping 12 matching lines @@
     if (!text_differs && !popup_->IsOpen())
       return false;  // Don't open the popup for no reason.
   } else if (!user_text_changed) {
     return false;
   }
 
   // If the user text has not changed, we do not want to change the model's
   // state associated with the text.  Otherwise, we can get surprising behavior
   // where the autocompleted text unexpectedly reappears, e.g. crbug.com/55983
   if (user_text_changed) {
-    const std::wstring new_user_text = UserTextFromDisplayText(new_text);
+    const string16 new_user_text = UserTextFromDisplayText(new_text);
 
     // Try to accept the current keyword if the user only typed a space at the
     // end of content. Model's state and popup will be updated when the keyword
     // is accepted. So we just need to return false here.
     if (allow_keyword_ui_change && !selection_differs &&
         MaybeAcceptKeywordBySpace(new_user_text))
       return false;
 
     InternalSetUserText(new_user_text);
     has_temporary_text_ = false;
@@ skipping 29 matching lines @@
       return false;
   }
 }
 
 void AutocompleteEditModel::Observe(NotificationType type,
                                     const NotificationSource& source,
                                     const NotificationDetails& details) {
   DCHECK_EQ(NotificationType::AUTOCOMPLETE_CONTROLLER_DEFAULT_MATCH_UPDATED,
             type.value);
 
-  std::wstring inline_autocomplete_text;
-  std::wstring keyword;
+  string16 inline_autocomplete_text;
+  string16 keyword;
   bool is_keyword_hint = false;
   const AutocompleteResult* result =
       Details<const AutocompleteResult>(details).ptr();
   const AutocompleteResult::const_iterator match(result->default_match());
   if (match != result->end()) {
-    if ((match->inline_autocomplete_offset != std::wstring::npos) &&
+    if ((match->inline_autocomplete_offset != string16::npos) &&
         (match->inline_autocomplete_offset < match->fill_into_edit.length())) {
       inline_autocomplete_text =
           match->fill_into_edit.substr(match->inline_autocomplete_offset);
     }
 
     if (!match->destination_url.SchemeIs(chrome::kExtensionScheme)) {
       // Warm up DNS Prefetch cache, or preconnect to a search service.
       chrome_browser_net::AnticipateOmniboxUrl(match->destination_url,
                                                IsPreconnectable(match->type));
     }
 
     // We could prefetch the alternate nav URL, if any, but because there
     // can be many of these as a user types an initial series of characters,
     // the OS DNS cache could suffer eviction problems for minimal gain.
 
     is_keyword_hint = popup_->GetKeywordForMatch(*match, &keyword);
   }
 
   OnPopupDataChanged(inline_autocomplete_text, NULL, keyword, is_keyword_hint);
 }
 
-void AutocompleteEditModel::InternalSetUserText(const std::wstring& text) {
+void AutocompleteEditModel::InternalSetUserText(const string16& text) {
   user_text_ = text;
   just_deleted_text_ = false;
   inline_autocomplete_text_.clear();
 }
 
 bool AutocompleteEditModel::KeywordIsSelected() const {
   return !is_keyword_hint_ && !keyword_.empty();
 }
 
-std::wstring AutocompleteEditModel::DisplayTextFromUserText(
-    const std::wstring& text) const {
+string16 AutocompleteEditModel::DisplayTextFromUserText(
+    const string16& text) const {
   return KeywordIsSelected() ?
       KeywordProvider::SplitReplacementStringFromInput(text, false) : text;
 }
 
-std::wstring AutocompleteEditModel::UserTextFromDisplayText(
-    const std::wstring& text) const {
-  return KeywordIsSelected() ? (keyword_ + L" " + text) : text;
+string16 AutocompleteEditModel::UserTextFromDisplayText(
+    const string16& text) const {
+  return KeywordIsSelected() ? (keyword_ + char16(' ') + text) : text;
 }
 
 void AutocompleteEditModel::GetInfoForCurrentText(
     AutocompleteMatch* match,
     GURL* alternate_nav_url) const {
   if (popup_->IsOpen() || query_in_progress()) {
     popup_->InfoForCurrentSelection(match, alternate_nav_url);
   } else {
     profile_->GetAutocompleteClassifier()->Classify(
         UserTextFromDisplayText(view_->GetText()), GetDesiredTLD(), true,
         match, alternate_nav_url);
   }
 }
 
-bool AutocompleteEditModel::GetURLForText(const std::wstring& text,
+bool AutocompleteEditModel::GetURLForText(const string16& text,
                                           GURL* url) const {
   GURL parsed_url;
   const AutocompleteInput::Type type = AutocompleteInput::Parse(
-      UserTextFromDisplayText(text), std::wstring(), NULL, NULL, &parsed_url);
+      UserTextFromDisplayText(text), string16(), NULL, NULL, &parsed_url);
   if (type != AutocompleteInput::URL)
     return false;
 
   *url = parsed_url;
   return true;
 }
 
 bool AutocompleteEditModel::MaybeAcceptKeywordBySpace(
-    const std::wstring& new_user_text) {
+    const string16& new_user_text) {
   return (paste_state_ == NONE) && is_keyword_hint_ && !keyword_.empty() &&
       inline_autocomplete_text_.empty() && !user_text_.empty() &&
       (new_user_text.length() == user_text_.length() + 1) &&
       !new_user_text.compare(0, user_text_.length(), user_text_) &&
       IsSpaceCharForAcceptingKeyword(new_user_text[user_text_.length()]) &&
       !IsWhitespace(user_text_[user_text_.length() - 1]) &&
       AcceptKeyword();
 }
 
 //  static
 bool AutocompleteEditModel::IsSpaceCharForAcceptingKeyword(wchar_t c) {
   switch (c) {
     case 0x0020:  // Space
     case 0x3000:  // Ideographic Space
       return true;
     default:
       return false;
   }
 }