Remove wstring from autocomplete....

chrome/browser/autocomplete/autocomplete_popup_model.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_popup_model.h"
 
 #include <algorithm>
 
 #include "unicode/ubidi.h"
 
@@ skipping 31 matching lines @@
 AutocompletePopupModel::~AutocompletePopupModel() {
 }
 
 void AutocompletePopupModel::SetProfile(Profile* profile) {
   DCHECK(profile);
   profile_ = profile;
   controller_->SetProfile(profile);
 }
 
 void AutocompletePopupModel::StartAutocomplete(
-    const std::wstring& text,
-    const std::wstring& desired_tld,
+    const string16& text,
+    const string16& desired_tld,
     bool prevent_inline_autocomplete,
     bool prefer_keyword,
     bool allow_exact_keyword_match) {
   // The user is interacting with the edit, so stop tracking hover.
   SetHoveredLine(kNoMatch);
 
   manually_selected_match_.Clear();
 
   controller_->Start(text, desired_tld, prevent_inline_autocomplete,
                      prefer_keyword, allow_exact_keyword_match, false);
@@ skipping 63 matching lines @@
   // selected line.
   CHECK(selected_line_ != kNoMatch);
   GURL current_destination(result.match_at(selected_line_).destination_url);
   view_->InvalidateLine(selected_line_);
   selected_line_ = line;
   view_->InvalidateLine(selected_line_);
 
   // Update the edit with the new data for this match.
   // TODO(pkasting): If |selected_line_| moves to the controller, this can be
   // eliminated and just become a call to the observer on the edit.
-  std::wstring keyword;
+  string16 keyword;
   const bool is_keyword_hint = GetKeywordForMatch(match, &keyword);
   if (reset_to_default) {
-    std::wstring inline_autocomplete_text;
-    if ((match.inline_autocomplete_offset != std::wstring::npos) &&
+    string16 inline_autocomplete_text;
+    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);
     }
     edit_model_->OnPopupDataChanged(inline_autocomplete_text, NULL,
                                     keyword, is_keyword_hint);
   } else {
     edit_model_->OnPopupDataChanged(match.fill_into_edit, &current_destination,
                                     keyword, is_keyword_hint);
   }
@@ skipping 43 matching lines @@
     // called instead.
     CHECK(!result->empty());
     CHECK(selected_line_ < result->size());
     *match = result->match_at(selected_line_);
   }
   if (alternate_nav_url && manually_selected_match_.empty())
     *alternate_nav_url = result->alternate_nav_url();
 }
 
 bool AutocompletePopupModel::GetKeywordForMatch(const AutocompleteMatch& match,
-                                                std::wstring* keyword) const {
+                                                string16* keyword) const {
   // Assume we have no keyword until we find otherwise.
   keyword->clear();
 
   // If the current match is a keyword, return that as the selected keyword.
   if (TemplateURL::SupportsReplacement(match.template_url)) {
-    keyword->assign(UTF16ToWideHack(match.template_url->keyword()));
+    keyword->assign(match.template_url->keyword());
     return false;
   }
 
   // See if the current match's fill_into_edit corresponds to a keyword.
   if (!profile_->GetTemplateURLModel())
     return false;
   profile_->GetTemplateURLModel()->Load();
   const string16 keyword_hint(TemplateURLModel::CleanUserInputKeyword(
-      WideToUTF16Hack(match.fill_into_edit)));
+      match.fill_into_edit));
   if (keyword_hint.empty())
     return false;
 
   // Don't provide a hint if this keyword doesn't support replacement.
   const TemplateURL* const template_url =
       profile_->GetTemplateURLModel()->GetTemplateURLForKeyword(keyword_hint);
   if (!TemplateURL::SupportsReplacement(template_url))
     return false;
 
   // Don't provide a hint for inactive/disabled extension keywords.
   if (template_url->IsExtensionKeyword()) {
     const Extension* extension = profile_->GetExtensionService()->
         GetExtensionById(template_url->GetExtensionId(), false);
     if (!extension ||
         (profile_->IsOffTheRecord() &&
          !profile_->GetExtensionService()->IsIncognitoEnabled(extension)))
       return false;
   }
 
-  keyword->assign(UTF16ToWideHack(keyword_hint));
+  keyword->assign(keyword_hint);
   return true;
 }
 
 void AutocompletePopupModel::FinalizeInstantQuery(
-    const std::wstring& input_text,
-    const std::wstring& suggest_text) {
+    const string16& input_text,
+    const string16& suggest_text) {
   if (IsOpen()) {
     SearchProvider* search_provider = controller_->search_provider();
     search_provider->FinalizeInstantQuery(input_text, suggest_text);
   }
 }
 
 AutocompleteLog* AutocompletePopupModel::GetAutocompleteLog() {
   return new AutocompleteLog(controller_->input().text(),
       controller_->input().type(), selected_line_, 0, controller_->result());
 }
@@ skipping 65 matching lines @@
 }
 
 const SkBitmap* AutocompletePopupModel::GetSpecialIconForMatch(
     const AutocompleteMatch& match) const {
   if (!match.template_url || !match.template_url->IsExtensionKeyword())
     return NULL;
 
   return &profile_->GetExtensionService()->GetOmniboxPopupIcon(
       match.template_url->GetExtensionId());
 }