Remove wstring from autocomplete....

chrome/browser/autocomplete/autocomplete_edit_view_gtk.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_view_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include <algorithm>
@@ skipping 43 matching lines @@
 
 const gchar* kAutocompleteEditViewGtkKey = "__ACE_VIEW_GTK__";
 
 const char kTextBaseColor[] = "#808080";
 const char kSecureSchemeColor[] = "#079500";
 const char kSecurityErrorSchemeColor[] = "#a20000";
 
 const double kStrikethroughStrokeRed = 162.0 / 256.0;
 const double kStrikethroughStrokeWidth = 2.0;
 
-size_t GetUTF8Offset(const std::wstring& wide_text, size_t wide_text_offset) {
-  return WideToUTF8(wide_text.substr(0, wide_text_offset)).size();
+size_t GetUTF8Offset(const string16& text, size_t text_offset) {
+  return UTF16ToUTF8(text.substr(0, text_offset)).size();
 }
 
 // Stores GTK+-specific state so it can be restored after switching tabs.
 struct ViewState {
   explicit ViewState(const AutocompleteEditViewGtk::CharRange& selection_range)
       : selection_range(selection_range) {
   }
 
   // Range of selected text.
   AutocompleteEditViewGtk::CharRange selection_range;
@@ skipping 373 matching lines @@
   // NOTE: GetStateForTabSwitch may affect GetSelection, so order is important.
   AutocompleteEditModel::State model_state = model_->GetStateForTabSwitch();
   GetStateAccessor()->SetProperty(
       tab->property_bag(),
       AutocompleteEditState(model_state, ViewState(GetSelection())));
 }
 
 void AutocompleteEditViewGtk::Update(const TabContents* contents) {
   // NOTE: We're getting the URL text here from the ToolbarModel.
   bool visibly_changed_permanent_text =
-      model_->UpdatePermanentText(toolbar_model_->GetText());
+      model_->UpdatePermanentText(WideToUTF16Hack(toolbar_model_->GetText()));
 
   ToolbarModel::SecurityLevel security_level =
         toolbar_model_->GetSecurityLevel();
   bool changed_security_level = (security_level != security_level_);
   security_level_ = security_level;
 
   if (contents) {
     selected_text_.clear();
     RevertAll();
     const AutocompleteEditState* state =
@@ skipping 13 matching lines @@
   } else if (changed_security_level) {
     EmphasizeURLComponents();
   }
 }
 
 void AutocompleteEditViewGtk::OpenURL(const GURL& url,
                                       WindowOpenDisposition disposition,
                                       PageTransition::Type transition,
                                       const GURL& alternate_nav_url,
                                       size_t selected_line,
-                                      const std::wstring& keyword) {
+                                      const string16& keyword) {
   if (!url.is_valid())
     return;
 
   model_->OpenURL(url, disposition, transition, alternate_nav_url,
                   selected_line, keyword);
 }
 
-std::wstring AutocompleteEditViewGtk::GetText() const {
+string16 AutocompleteEditViewGtk::GetText() const {
   GtkTextIter start, end;
   GetTextBufferBounds(&start, &end);
   gchar* utf8 = gtk_text_buffer_get_text(text_buffer_, &start, &end, false);
-  std::wstring out(UTF8ToWide(utf8));
+  string16 out(UTF8ToUTF16(utf8));
   g_free(utf8);
 
 #if GTK_CHECK_VERSION(2, 20, 0)
   // We need to treat the text currently being composed by the input method as
   // part of the text content, so that omnibox can work correctly in the middle
   // of composition.
   if (preedit_.size()) {
     GtkTextMark* mark = gtk_text_buffer_get_insert(text_buffer_);
     gtk_text_buffer_get_iter_at_mark(text_buffer_, &start, mark);
     out.insert(gtk_text_iter_get_offset(&start), preedit_);
   }
 #endif
   return out;
 }
 
 bool AutocompleteEditViewGtk::IsEditingOrEmpty() const {
   return model_->user_input_in_progress() || (GetTextLength() == 0);
 }
 
 int AutocompleteEditViewGtk::GetIcon() const {
   return IsEditingOrEmpty() ?
       AutocompleteMatch::TypeToIcon(model_->CurrentTextType()) :
       toolbar_model_->GetIcon();
 }
 
-void AutocompleteEditViewGtk::SetUserText(const std::wstring& text) {
+void AutocompleteEditViewGtk::SetUserText(const string16& text) {
   SetUserText(text, text, true);
 }
 
-void AutocompleteEditViewGtk::SetUserText(const std::wstring& text,
-                                          const std::wstring& display_text,
+void AutocompleteEditViewGtk::SetUserText(const string16& text,
+                                          const string16& display_text,
                                           bool update_popup) {
   model_->SetUserText(text);
   // TODO(deanm): something about selection / focus change here.
   SetWindowTextAndCaretPos(display_text, display_text.length());
   if (update_popup)
     UpdatePopup();
   TextChanged();
 }
 
-void AutocompleteEditViewGtk::SetWindowTextAndCaretPos(const std::wstring& text,
+void AutocompleteEditViewGtk::SetWindowTextAndCaretPos(const string16& text,
                                                        size_t caret_pos) {
   CharRange range(static_cast<int>(caret_pos), static_cast<int>(caret_pos));
   SetTextAndSelectedRange(text, range);
 }
 
 void AutocompleteEditViewGtk::SetForcedQuery() {
-  const std::wstring current_text(GetText());
-  const size_t start = current_text.find_first_not_of(kWhitespaceWide);
-  if (start == std::wstring::npos || (current_text[start] != '?')) {
-    SetUserText(L"?");
+  const string16 current_text(GetText());
+  const size_t start = current_text.find_first_not_of(kWhitespaceUTF16);
+  if (start == string16::npos || (current_text[start] != '?')) {
+    SetUserText(ASCIIToUTF16("?"));
   } else {
     StartUpdatingHighlightedText();
     SetSelectedRange(CharRange(current_text.size(), start + 1));
     FinishUpdatingHighlightedText();
   }
 }
 
 bool AutocompleteEditViewGtk::IsSelectAll() {
   GtkTextIter sel_start, sel_end;
   gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end);
 
   GtkTextIter start, end;
   GetTextBufferBounds(&start, &end);
 
   // Returns true if the |text_buffer_| is empty.
   return gtk_text_iter_equal(&start, &sel_start) &&
       gtk_text_iter_equal(&end, &sel_end);
 }
 
 bool AutocompleteEditViewGtk::DeleteAtEndPressed() {
   return delete_at_end_pressed_;
 }
 
-void AutocompleteEditViewGtk::GetSelectionBounds(std::wstring::size_type* start,
-                                                 std::wstring::size_type* end) {
+void AutocompleteEditViewGtk::GetSelectionBounds(string16::size_type* start,
+                                                 string16::size_type* end) {
   CharRange selection = GetSelection();
   *start = static_cast<size_t>(selection.cp_min);
   *end = static_cast<size_t>(selection.cp_max);
 }
 
 void AutocompleteEditViewGtk::SelectAll(bool reversed) {
   // SelectAll() is invoked as a side effect of other actions (e.g.  switching
   // tabs or hitting Escape) in autocomplete_edit.cc, so we don't update the
   // PRIMARY selection here.
   SelectAllInternal(reversed, false);
@@ skipping 19 matching lines @@
 }
 
 void AutocompleteEditViewGtk::ClosePopup() {
   if (popup_view_->GetModel()->IsOpen())
     controller_->OnAutocompleteWillClosePopup();
 
   popup_view_->GetModel()->StopAutocomplete();
 }
 
 void AutocompleteEditViewGtk::OnTemporaryTextMaybeChanged(
-    const std::wstring& display_text,
+    const string16& display_text,
     bool save_original_selection) {
   if (save_original_selection)
     saved_temporary_selection_ = GetSelection();
 
   StartUpdatingHighlightedText();
   SetWindowTextAndCaretPos(display_text, display_text.length());
   FinishUpdatingHighlightedText();
   TextChanged();
 }
 
 bool AutocompleteEditViewGtk::OnInlineAutocompleteTextMaybeChanged(
-    const std::wstring& display_text,
+    const string16& display_text,
     size_t user_text_length) {
   if (display_text == GetText())
     return false;
 
   StartUpdatingHighlightedText();
   CharRange range(display_text.size(), user_text_length);
   SetTextAndSelectedRange(display_text, range);
   FinishUpdatingHighlightedText();
   TextChanged();
   return true;
@@ skipping 51 matching lines @@
   CharRange new_sel = GetSelection();
   int length = GetTextLength();
   bool selection_differs =
       ((new_sel.cp_min != new_sel.cp_max) ||
        (sel_before_change_.cp_min != sel_before_change_.cp_max)) &&
       ((new_sel.cp_min != sel_before_change_.cp_min) ||
        (new_sel.cp_max != sel_before_change_.cp_max));
   bool at_end_of_edit = (new_sel.cp_min == length && new_sel.cp_max == length);
 
   // See if the text or selection have changed since OnBeforePossibleChange().
-  std::wstring new_text(GetText());
+  string16 new_text(GetText());
   text_changed_ = (new_text != text_before_change_);
 #if GTK_CHECK_VERSION(2, 20, 0)
   text_changed_ =
       text_changed_ || (preedit_.size() != preedit_size_before_change_);
 #endif
 
   if (text_changed_)
     AdjustTextJustification();
 
   // When the user has deleted text, we don't allow inline autocomplete.  Make
@@ skipping 113 matching lines @@
 #if defined(TOOLKIT_VIEWS)
 views::View* AutocompleteEditViewGtk::AddToView(views::View* parent) {
   views::NativeViewHost* host = new views::NativeViewHost;
   parent->AddChildView(host);
   host->set_focus_view(parent);
   host->Attach(GetNativeView());
   return host;
 }
 
 bool AutocompleteEditViewGtk::CommitInstantSuggestion(
-    const std::wstring& typed_text,
-    const std::wstring& suggestion) {
+    const string16& typed_text,
+    const string16& suggestion) {
   return CommitInstantSuggestion();
 }
 
 void AutocompleteEditViewGtk::EnableAccessibility() {
   accessible_widget_helper_.reset(
       new AccessibleWidgetHelper(text_view(), model_->profile()));
   accessible_widget_helper_->SetWidgetName(
       text_view(), l10n_util::GetStringUTF8(IDS_ACCNAME_LOCATION));
 }
 
@@ skipping 575 matching lines @@
   gtk_widget_set_sensitive(search_engine_menuitem,
       command_updater_->IsCommandEnabled(IDC_EDIT_SEARCH_ENGINES));
   gtk_widget_show(search_engine_menuitem);
 
   // We need to update the paste and go controller before we know what text
   // to show. We could do this all asynchronously, but it would be elaborate
   // because we'd have to account for multiple menus showing, getting called
   // back after shutdown, and similar issues.
   GtkClipboard* x_clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
   gchar* text = gtk_clipboard_wait_for_text(x_clipboard);
-  std::wstring text_wstr = UTF8ToWide(text);
+  string16 text_wstr = UTF8ToUTF16(text);
   g_free(text);
 
   // Paste and Go menu item.
   GtkWidget* paste_go_menuitem = gtk_menu_item_new_with_mnemonic(
       gfx::ConvertAcceleratorsFromWindowsStyle(
           l10n_util::GetStringUTF8(model_->is_paste_and_search() ?
               IDS_PASTE_AND_SEARCH : IDS_PASTE_AND_GO)).c_str());
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), paste_go_menuitem);
   g_signal_connect(paste_go_menuitem, "activate",
                    G_CALLBACK(HandlePasteAndGoThunk), this);
@@ skipping 74 matching lines @@
 
   // Don't try to PasteAndGo on drops originating from this omnibox. However, do
   // allow default behavior for such drags.
   if (context->source_window == text_view_->window)
     return;
 
   guchar* text = gtk_selection_data_get_text(selection_data);
   if (!text)
     return;
 
-  std::wstring possible_url = UTF8ToWide(reinterpret_cast<char*>(text));
+  string16 possible_url = UTF8ToUTF16(reinterpret_cast<char*>(text));
   g_free(text);
   if (model_->CanPasteAndGo(CollapseWhitespace(possible_url, true))) {
     model_->PasteAndGo();
     gtk_drag_finish(context, TRUE, TRUE, time);
 
     static guint signal_id =
         g_signal_lookup("drag-data-received", GTK_TYPE_WIDGET);
     g_signal_stop_emission(text_view_, signal_id, 0);
   }
 }
@@ skipping 128 matching lines @@
   if (!gtk_text_buffer_get_has_selection(text_buffer_))
     return;
 
   GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
   if (!clipboard)
     return;
 
   CharRange selection = GetSelection();
   GURL url;
-  std::wstring text(UTF8ToWide(GetSelectedText()));
+  string16 text(UTF8ToUTF16(GetSelectedText()));
   bool write_url;
   model_->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
                             &url, &write_url);
 
   if (write_url) {
-    string16 text16(WideToUTF16(text));
     BookmarkNodeData data;
-    data.ReadFromTuple(url, text16);
+    data.ReadFromTuple(url, text);
     data.WriteToClipboard(NULL);
 
     // Stop propagating the signal.
     static guint copy_signal_id =
         g_signal_lookup("copy-clipboard", GTK_TYPE_TEXT_VIEW);
     static guint cut_signal_id =
         g_signal_lookup("cut-clipboard", GTK_TYPE_TEXT_VIEW);
     g_signal_stop_emission(text_view_,
                            copy ? copy_signal_id : cut_signal_id,
                            0);
 
     if (!copy)
       gtk_text_buffer_delete_selection(text_buffer_, true, true);
   }
 
-  OwnPrimarySelection(WideToUTF8(text));
+  OwnPrimarySelection(UTF16ToUTF8(text));
 }
 
 void AutocompleteEditViewGtk::OwnPrimarySelection(const std::string& text) {
   primary_selection_text_ = text;
 
   GtkTargetList* list = gtk_target_list_new(NULL, 0);
   gtk_target_list_add_text_targets(list, 0);
   gint len;
   GtkTargetEntry* entries = gtk_target_table_new_from_list(list, &len);
 
@@ skipping 170 matching lines @@
     return;
   }
 #endif
   // See whether the contents are a URL with a non-empty host portion, which we
   // should emphasize.  To check for a URL, rather than using the type returned
   // by Parse(), ask the model, which will check the desired page transition for
   // this input.  This can tell us whether an UNKNOWN input string is going to
   // be treated as a search or a navigation, and is the same method the Paste
   // And Go system uses.
   url_parse::Component scheme, host;
-  std::wstring text(GetText());
+  string16 text(GetText());
   AutocompleteInput::ParseForEmphasizeComponents(
       text, model_->GetDesiredTLD(), &scheme, &host);
   const bool emphasize = model_->CurrentTextIsURL() && (host.len > 0);
 
   // Set the baseline emphasis.
   GtkTextIter start, end;
   GetTextBufferBounds(&start, &end);
   gtk_text_buffer_remove_all_tags(text_buffer_, &start, &end);
   if (emphasize) {
     gtk_text_buffer_apply_tag(text_buffer_, faded_text_tag_, &start, &end);
@@ skipping 41 matching lines @@
   instant_animation_->Stop();
   UpdateInstantViewColors();
 }
 
 bool AutocompleteEditViewGtk::CommitInstantSuggestion() {
   const gchar* suggestion = gtk_label_get_text(GTK_LABEL(instant_view_));
   if (!suggestion || !*suggestion)
     return false;
 
   model()->FinalizeInstantQuery(GetText(),
-                                UTF8ToWide(suggestion));
+                                UTF8ToUTF16(suggestion));
   return true;
 }
 
 void AutocompleteEditViewGtk::TextChanged() {
   EmphasizeURLComponents();
   controller_->OnChanged();
 }
 
 void AutocompleteEditViewGtk::SavePrimarySelection(
     const std::string& selected_text) {
   GtkClipboard* clipboard =
       gtk_widget_get_clipboard(text_view_, GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
   if (!clipboard)
     return;
 
   gtk_clipboard_set_text(
       clipboard, selected_text.data(), selected_text.size());
 }
 
-void AutocompleteEditViewGtk::SetTextAndSelectedRange(const std::wstring& text,
+void AutocompleteEditViewGtk::SetTextAndSelectedRange(const string16& text,
                                                       const CharRange& range) {
   if (text != GetText()) {
-    std::string utf8 = WideToUTF8(text);
+    std::string utf8 = UTF16ToUTF8(text);
     gtk_text_buffer_set_text(text_buffer_, utf8.data(), utf8.length());
   }
   SetSelectedRange(range);
   AdjustTextJustification();
 }
 
 void AutocompleteEditViewGtk::SetSelectedRange(const CharRange& range) {
   GtkTextIter insert, bound;
   ItersFromCharRange(range, &bound, &insert);
   gtk_text_buffer_select_range(text_buffer_, &insert, &bound);
@@ skipping 145 matching lines @@
     gchar* text = gtk_text_iter_get_text(&start, &end);
     size_t text_len = strlen(text);
     if (text_len)
       result = std::string(text, text_len);
     g_free(text);
   }
   return result;
 }
 
 void AutocompleteEditViewGtk::UpdatePrimarySelectionIfValidURL() {
-  std::wstring text = UTF8ToWide(GetSelectedText());
+  string16 text = UTF8ToUTF16(GetSelectedText());
 
   if (text.empty())
     return;
 
   // Use AdjustTextForCopy to make sure we prefix the text with 'http://'.
   CharRange selection = GetSelection();
   GURL url;
   bool write_url;
   model_->AdjustTextForCopy(selection.selection_min(), IsSelectAll(), &text,
                             &url, &write_url);
   if (write_url) {
-    selected_text_ = WideToUTF8(text);
+    selected_text_ = UTF16ToUTF8(text);
     OwnPrimarySelection(selected_text_);
   }
 }
 
 #if GTK_CHECK_VERSION(2, 20, 0)
 void AutocompleteEditViewGtk::HandlePreeditChanged(GtkWidget* sender,
                                                    const gchar* preedit) {
   // GtkTextView won't fire "begin-user-action" and "end-user-action" signals
   // when changing the preedit string, so we need to call
   // OnBeforePossibleChange() and OnAfterPossibleChange() by ourselves.
   OnBeforePossibleChange();
   if (preedit && *preedit) {
     // GtkTextView will only delete the selection range when committing the
     // preedit string, which will cause very strange behavior, so we need to
     // delete the selection range here explicitly. See http://crbug.com/18808.
     if (preedit_.empty())
       gtk_text_buffer_delete_selection(text_buffer_, false, true);
-    preedit_ = UTF8ToWide(preedit);
+    preedit_ = UTF8ToUTF16(preedit);
   } else {
     preedit_.clear();
   }
   OnAfterPossibleChange();
 }
 #endif
 
 void AutocompleteEditViewGtk::HandleWindowSetFocus(
     GtkWindow* sender, GtkWidget* focus) {
   // This is actually a guess. If the focused widget changes in "focus-out"
@@ skipping 31 matching lines @@
   // baseline, so we need to move the |instant_view_| down to make sure it
   // has the same baseline as the |text_view_|.
   PangoLayout* layout = gtk_label_get_layout(GTK_LABEL(instant_view_));
   int height;
   pango_layout_get_size(layout, NULL, &height);
   PangoLayoutIter* iter = pango_layout_get_iter(layout);
   int baseline = pango_layout_iter_get_baseline(iter);
   pango_layout_iter_free(iter);
   g_object_set(instant_anchor_tag_, "rise", baseline - height, NULL);
 }