Remove wstring from autocomplete.

chrome/browser/autocomplete/autocomplete_edit_view_win.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_win.h"
 
 #include <algorithm>
 #include <locale>
 #include <string>
 
@@ skipping 165 matching lines @@
 }
 
 DWORD EditDropTarget::OnDrop(IDataObject* data_object,
                              DWORD key_state,
                              POINT cursor_position,
                              DWORD effect) {
   ui::OSExchangeData os_data(new ui::OSExchangeDataProviderWin(data_object));
 
   if (drag_has_url_) {
     GURL url;
-    std::wstring title;
+    string16 title;
     if (os_data.GetURLAndTitle(&url, &title)) {
       edit_->SetUserText(UTF8ToWide(url.spec()));
       edit_->model()->AcceptInput(CURRENT_TAB, true);
       return CopyOrLinkDropEffect(effect);
     }
   } else if (drag_has_string_) {
     int string_drop_position = edit_->drop_highlight_position();
-    std::wstring text;
+    string16 text;
     if ((string_drop_position != -1 || !edit_->in_drag()) &&
         os_data.GetString(&text)) {
       DCHECK(string_drop_position == -1 ||
              ((string_drop_position >= 0) &&
               (string_drop_position <= edit_->GetTextLength())));
       const DWORD drop_operation =
           OnDragOver(data_object, key_state, cursor_position, effect);
       if (edit_->in_drag()) {
         if (drop_operation == DROPEFFECT_MOVE)
           edit_->MoveSelectedText(string_drop_position);
@@ skipping 385 matching lines @@
     // Only the security style changed, nothing else.  Redraw our text using it.
     EmphasizeURLComponents();
   }
 }
 
 void AutocompleteEditViewWin::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;
 
   // When we navigate, we first revert to the unedited state, then if necessary
   // synchronously change the permanent text to the new URL.  If we don't freeze
   // here, the user could potentially see a flicker of the current URL before
   // the new one reappears, which would look glitchy.
   ScopedFreeze freeze(this, GetTextObjectModel());
   model_->OpenURL(url, disposition, transition, alternate_nav_url,
                   selected_line, keyword);
 }
 
-std::wstring AutocompleteEditViewWin::GetText() const {
+string16 AutocompleteEditViewWin::GetText() const {
   const int len = GetTextLength() + 1;
-  std::wstring str;
+  string16 str;
   GetWindowText(WriteInto(&str, len), len);
   return str;
 }
 
 bool AutocompleteEditViewWin::IsEditingOrEmpty() const {
   return model_->user_input_in_progress() || (GetTextLength() == 0);
 }
 
 int AutocompleteEditViewWin::GetIcon() const {
   return IsEditingOrEmpty() ?
       AutocompleteMatch::TypeToIcon(model_->CurrentTextType()) :
       toolbar_model_->GetIcon();
 }
 
-void AutocompleteEditViewWin::SetUserText(const std::wstring& text) {
+void AutocompleteEditViewWin::SetUserText(const string16& text) {
   SetUserText(text, text, true);
 }
 
-void AutocompleteEditViewWin::SetUserText(const std::wstring& text,
-                                          const std::wstring& display_text,
+void AutocompleteEditViewWin::SetUserText(const string16& text,
+                                          const string16& display_text,
                                           bool update_popup) {
   ScopedFreeze freeze(this, GetTextObjectModel());
   model_->SetUserText(text);
   saved_selection_for_focus_change_.cpMin = -1;
   SetWindowTextAndCaretPos(display_text, display_text.length());
   if (update_popup)
     UpdatePopup();
   TextChanged();
 }
 
-void AutocompleteEditViewWin::SetWindowTextAndCaretPos(const std::wstring& text,
+void AutocompleteEditViewWin::SetWindowTextAndCaretPos(const string16& text,
                                                        size_t caret_pos) {
   SetWindowText(text.c_str());
   PlaceCaretAt(caret_pos);
 }
 
 void AutocompleteEditViewWin::SetForcedQuery() {
-  const std::wstring current_text(GetText());
+  const string16 current_text(GetText());
   const size_t start = current_text.find_first_not_of(kWhitespaceWide);
-  if (start == std::wstring::npos || (current_text[start] != '?'))
+  if (start == string16::npos || (current_text[start] != '?'))
     SetUserText(L"?");
   else
     SetSelection(current_text.length(), start + 1);
 }
 
 bool AutocompleteEditViewWin::IsSelectAll() {
   CHARRANGE selection;
   GetSel(selection);
   return IsSelectAllForRange(selection);
 }
 
 bool AutocompleteEditViewWin::DeleteAtEndPressed() {
   return delete_at_end_pressed_;
 }
 
-void AutocompleteEditViewWin::GetSelectionBounds(std::wstring::size_type* start,
-                                                 std::wstring::size_type* end) {
+void AutocompleteEditViewWin::GetSelectionBounds(string16::size_type* start,
+                                                 string16::size_type* end) {
   CHARRANGE selection;
   GetSel(selection);
   *start = static_cast<size_t>(selection.cpMin);
   *end = static_cast<size_t>(selection.cpMax);
 }
 
 void AutocompleteEditViewWin::SelectAll(bool reversed) {
   if (reversed)
     SetSelection(GetTextLength(), 0);
   else
@@ skipping 71 matching lines @@
 
 void AutocompleteEditViewWin::SetDropHighlightPosition(int position) {
   if (drop_highlight_position_ != position) {
     RepaintDropHighlight(drop_highlight_position_);
     drop_highlight_position_ = position;
     RepaintDropHighlight(drop_highlight_position_);
   }
 }
 
 void AutocompleteEditViewWin::MoveSelectedText(int new_position) {
-  const std::wstring selected_text(GetSelectedText());
+  const string16 selected_text(GetSelectedText());
   CHARRANGE sel;
   GetSel(sel);
   DCHECK((sel.cpMax != sel.cpMin) && (new_position >= 0) &&
          (new_position <= GetTextLength()));
 
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
 
   // Nuke the selected text.
   ReplaceSel(L"", TRUE);
 
   // And insert it into the new location.
   if (new_position >= sel.cpMin)
     new_position -= (sel.cpMax - sel.cpMin);
   PlaceCaretAt(new_position);
   ReplaceSel(selected_text.c_str(), TRUE);
 
   OnAfterPossibleChange();
 }
 
 void AutocompleteEditViewWin::InsertText(int position,
-                                         const std::wstring& text) {
+                                         const string16& text) {
   DCHECK((position >= 0) && (position <= GetTextLength()));
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   SetSelection(position, position);
   ReplaceSel(text.c_str());
   OnAfterPossibleChange();
 }
 
 void AutocompleteEditViewWin::OnTemporaryTextMaybeChanged(
-    const std::wstring& display_text,
+    const string16& display_text,
     bool save_original_selection) {
   if (save_original_selection)
     GetSelection(original_selection_);
 
   // Set new text and cursor position.  Sometimes this does extra work (e.g.
   // when the new text and the old text are identical), but it's only called
   // when the user manually changes the selected line in the popup, so that's
   // not really a problem.  Also, even when the text hasn't changed we'd want to
   // update the caret, because if the user had the cursor in the middle of the
   // text and then arrowed to another entry with the same text, we'd still want
   // to move the caret.
   ScopedFreeze freeze(this, GetTextObjectModel());
   SetWindowTextAndCaretPos(display_text, display_text.length());
   TextChanged();
 }
 
 bool AutocompleteEditViewWin::OnInlineAutocompleteTextMaybeChanged(
-    const std::wstring& display_text,
+    const string16& display_text,
     size_t user_text_length) {
   // Update the text and selection.  Because this can be called repeatedly while
   // typing, we've careful not to freeze the edit unless we really need to.
   // Also, unlike in the temporary text case above, here we don't want to update
   // the caret/selection unless we have to, since this might make the user's
   // caret position change without warning during typing.
   if (display_text == GetText())
     return false;
 
   ScopedFreeze freeze(this, GetTextObjectModel());
@@ skipping 38 matching lines @@
   }
   const bool selection_differs =
       ((new_sel.cpMin != new_sel.cpMax) ||
        (sel_before_change_.cpMin != sel_before_change_.cpMax)) &&
       ((new_sel.cpMin != sel_before_change_.cpMin) ||
        (new_sel.cpMax != sel_before_change_.cpMax));
   const bool at_end_of_edit =
       (new_sel.cpMin == length) && (new_sel.cpMax == length);
 
   // See if the text or selection have changed since OnBeforePossibleChange().
-  const std::wstring new_text(GetText());
+  const string16 new_text(GetText());
   const bool text_differs = (new_text != text_before_change_) ||
       force_text_changed;
 
   // When the user has deleted text, we don't allow inline autocomplete.  Make
   // sure to not flag cases like selecting part of the text and then pasting
   // (or typing) the prefix of that selection.  (We detect these by making
   // sure the caret, which should be after any insertion, hasn't moved
   // forward of the old selection start.)
   const bool just_deleted_text =
       (text_before_change_.length() > new_text.length()) &&
@@ skipping 56 matching lines @@
 
 views::View* AutocompleteEditViewWin::AddToView(views::View* parent) {
   views::NativeViewHost* host = new views::NativeViewHost;
   parent->AddChildView(host);
   host->set_focus_view(parent);
   host->Attach(GetNativeView());
   return host;
 }
 
 bool AutocompleteEditViewWin::CommitInstantSuggestion(
-    const std::wstring& typed_text,
-    const std::wstring& suggested_text) {
+    const string16& typed_text,
+    const string16& suggested_text) {
   model_->FinalizeInstantQuery(typed_text, suggested_text);
   return true;
 }
 
-void AutocompleteEditViewWin::PasteAndGo(const std::wstring& text) {
+void AutocompleteEditViewWin::PasteAndGo(const string16& text) {
   if (CanPasteAndGo(text))
     model_->PasteAndGo();
 }
 
 bool AutocompleteEditViewWin::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& e) {
   ui::KeyboardCode key = e.GetKeyCode();
   // We don't process ALT + numpad digit as accelerators, they are used for
   // entering special characters.  We do translate alt-home.
   if (e.IsAltDown() && (key != ui::VKEY_HOME) &&
@@ skipping 75 matching lines @@
     ui::Accelerator* accelerator) {
   return parent_view_->GetWidget()->GetAccelerator(command_id, accelerator);
 }
 
 bool AutocompleteEditViewWin::IsItemForCommandIdDynamic(int command_id) const {
   // No need to change the default IDS_PASTE_AND_GO label unless this is a
   // search.
   return command_id == IDS_PASTE_AND_GO;
 }
 
-std::wstring AutocompleteEditViewWin::GetLabelForCommandId(
+string16 AutocompleteEditViewWin::GetLabelForCommandId(
     int command_id) const {
   DCHECK(command_id == IDS_PASTE_AND_GO);
   return l10n_util::GetStringUTF16(model_->is_paste_and_search() ?
       IDS_PASTE_AND_SEARCH : IDS_PASTE_AND_GO);
 }
 
 void AutocompleteEditViewWin::ExecuteCommand(int command_id) {
   ScopedFreeze freeze(this, GetTextObjectModel());
   if (command_id == IDS_PASTE_AND_GO) {
     // This case is separate from the switch() below since we don't want to wrap
@@ skipping 191 matching lines @@
     POINT p;
     GetCaretPos(&p);
     MapWindowPoints(HWND_DESKTOP, &p, 1);
     context_menu_->RunContextMenuAt(gfx::Point(p));
   } else {
     context_menu_->RunContextMenuAt(gfx::Point(point));
   }
 }
 
 void AutocompleteEditViewWin::OnCopy() {
-  std::wstring text(GetSelectedText());
+  string16 text(GetSelectedText());
   if (text.empty())
     return;
 
   CHARRANGE sel;
   GURL url;
   bool write_url = false;
   GetSel(sel);
   // GetSel() doesn't preserve selection direction, so sel.cpMin will always be
   // the smaller value.
   model_->AdjustTextForCopy(sel.cpMin, IsSelectAll(), &text, &url, &write_url);
@@ skipping 87 matching lines @@
   // only changes the current reading order, and as soon as the user deletes all
   // the text, or we call SetWindowText(), it reverts to the "default" order.
   // To work around this, if the user hits ctrl+shift, we pass it to
   // DefWindowProc() while the edit is empty, which toggles the default reading
   // order; then we restore the user's input.
   if (!(flags & KF_ALTDOWN) &&
       (((key == VK_CONTROL) && (GetKeyState(VK_SHIFT) < 0)) ||
        ((key == VK_SHIFT) && (GetKeyState(VK_CONTROL) < 0)))) {
     ScopedFreeze freeze(this, GetTextObjectModel());
 
-    std::wstring saved_text(GetText());
+    string16 saved_text(GetText());
     CHARRANGE saved_sel;
     GetSelection(saved_sel);
 
     SetWindowText(L"");
 
     DefWindowProc(WM_KEYUP, key, MAKELPARAM(repeat_count, flags));
 
     SetWindowText(saved_text.c_str());
     SetSelectionRange(saved_sel);
     return;
@@ skipping 301 matching lines @@
 
   // Blit the memory DC to the actual paint DC and clean up.
   BitBlt(paint_dc, rect.left, rect.top, rect.Width(), rect.Height(), memory_dc,
          rect.left, rect.top, SRCCOPY);
   memory_dc.SelectBitmap(old_bitmap);
   edit_hwnd = old_edit_hwnd;
 }
 
 void AutocompleteEditViewWin::OnPaste() {
   // Replace the selection if we have something to paste.
-  const std::wstring text(GetClipboardText());
+  const string16 text(GetClipboardText());
   if (!text.empty()) {
     // Record this paste, so we can do different behavior.
     model_->on_paste();
     // Force a Paste operation to trigger the text_changed code in
     // OnAfterPossibleChange(), even if identical contents are pasted into the
     // text box.
     text_before_change_.clear();
     ReplaceSel(text.c_str(), true);
   }
 }
@@ skipping 321 matching lines @@
     return;
   ScopedComPtr<ITextSelection> selection;
   const HRESULT hr = text_object_model->GetSelection(selection.Receive());
   DCHECK(hr == S_OK);
   long flags;
   selection->GetFlags(&flags);
   if (flags & tomSelStartActive)
     std::swap(sel.cpMin, sel.cpMax);
 }
 
-std::wstring AutocompleteEditViewWin::GetSelectedText() const {
+string16 AutocompleteEditViewWin::GetSelectedText() const {
   // Figure out the length of the selection.
   CHARRANGE sel;
   GetSel(sel);
 
   // Grab the selected text.
-  std::wstring str;
+  string16 str;
   GetSelText(WriteInto(&str, sel.cpMax - sel.cpMin + 1));
   return str;
 }
 
 void AutocompleteEditViewWin::SetSelection(LONG start, LONG end) {
   SetSel(start, end);
 
   if (start <= end)
     return;
 
   // We need to reverse the direction of the selection.
   ITextDocument* const text_object_model = GetTextObjectModel();
   if (!text_object_model)
     return;
   ScopedComPtr<ITextSelection> selection;
   const HRESULT hr = text_object_model->GetSelection(selection.Receive());
   DCHECK(hr == S_OK);
   selection->SetFlags(tomSelStartActive);
 }
 
-void AutocompleteEditViewWin::PlaceCaretAt(std::wstring::size_type pos) {
+void AutocompleteEditViewWin::PlaceCaretAt(string16::size_type pos) {
   SetSelection(static_cast<LONG>(pos), static_cast<LONG>(pos));
 }
 
 bool AutocompleteEditViewWin::IsSelectAllForRange(const CHARRANGE& sel) const {
   const int text_length = GetTextLength();
   return ((sel.cpMin == 0) && (sel.cpMax >= text_length)) ||
       ((sel.cpMax == 0) && (sel.cpMin >= text_length));
 }
 
 LONG AutocompleteEditViewWin::ClipXCoordToVisibleText(
@@ skipping 238 matching lines @@
   LineTo(hdc, clip_rect.left, clip_rect.bottom);
   DeleteObject(SelectObject(hdc, last_pen));
 }
 
 void AutocompleteEditViewWin::TextChanged() {
   ScopedFreeze freeze(this, GetTextObjectModel());
   EmphasizeURLComponents();
   controller_->OnChanged();
 }
 
-std::wstring AutocompleteEditViewWin::GetClipboardText() const {
+string16 AutocompleteEditViewWin::GetClipboardText() const {
   // Try text format.
   ui::Clipboard* clipboard = g_browser_process->clipboard();
   if (clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
                                    ui::Clipboard::BUFFER_STANDARD)) {
-    std::wstring text;
+    string16 text;
     clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &text);
 
     // Note: Unlike in the find popup and textfield view, here we completely
     // remove whitespace strings containing newlines.  We assume users are
     // most likely pasting in URLs that may have been split into multiple
     // lines in terminals, email programs, etc., and so linebreaks indicate
     // completely bogus whitespace that would just cause the input to be
     // invalid.
     return CollapseWhitespace(text, true);
   }
 
   // Try bookmark format.
   //
   // It is tempting to try bookmark format first, but the URL we get out of a
   // bookmark has been cannonicalized via GURL.  This means if a user copies
   // and pastes from the URL bar to itself, the text will get fixed up and
   // cannonicalized, which is not what the user expects.  By pasting in this
   // order, we are sure to paste what the user copied.
   if (clipboard->IsFormatAvailable(ui::Clipboard::GetUrlWFormatType(),
                                    ui::Clipboard::BUFFER_STANDARD)) {
     std::string url_str;
     clipboard->ReadBookmark(NULL, &url_str);
     // pass resulting url string through GURL to normalize
     GURL url(url_str);
     if (url.is_valid())
       return UTF8ToWide(url.spec());
   }
 
-  return std::wstring();
+  return string16();
 }
 
-bool AutocompleteEditViewWin::CanPasteAndGo(const std::wstring& text) const {
+bool AutocompleteEditViewWin::CanPasteAndGo(const string16& text) const {
   return !popup_window_mode_ && model_->CanPasteAndGo(text);
 }
 
 ITextDocument* AutocompleteEditViewWin::GetTextObjectModel() const {
   if (!text_object_model_) {
     // This is lazily initialized, instead of being initialized in the
     // constructor, in order to avoid hurting startup performance.
     ScopedComPtr<IRichEditOle, NULL> ole_interface;
     ole_interface.Attach(GetOleInterface());
     if (ole_interface) {
@@ skipping 23 matching lines @@
   // selection and start the drag.  We always send lbuttonup as otherwise we
   // might trigger a context menu (right up).  This seems scary, but doesn't
   // seem to cause problems.
   {
     ScopedFreeze freeze(this, GetTextObjectModel());
     DefWindowProc(WM_LBUTTONUP, 0,
                   MAKELPARAM(click_point_[kLeft].x, click_point_[kLeft].y));
     SetSelectionRange(sel);
   }
 
-  const std::wstring start_text(GetText());
-  std::wstring text_to_write(GetSelectedText());
+  const string16 start_text(GetText());
+  string16 text_to_write(GetSelectedText());
   GURL url;
   bool write_url;
   const bool is_all_selected = IsSelectAllForRange(sel);
 
   // |sel| was set by GetSelection(), which preserves selection direction, so
   // sel.cpMin may not be the smaller value.
   model()->AdjustTextForCopy(std::min(sel.cpMin, sel.cpMax), is_all_selected,
                              &text_to_write, &url, &write_url);
 
   if (write_url) {
-    std::wstring title;
+    string16 title;
     SkBitmap favicon;
     if (is_all_selected)
       model_->GetDataForURLExport(&url, &title, &favicon);
     drag_utils::SetURLAndDragImage(url, title, favicon, &data);
     supported_modes |= DROPEFFECT_LINK;
     UserMetrics::RecordAction(UserMetricsAction("Omnibox_DragURL"),
                               model_->profile());
   } else {
     supported_modes |= DROPEFFECT_MOVE;
     UserMetrics::RecordAction(UserMetricsAction("Omnibox_DragString"),
@@ skipping 128 matching lines @@
 
 int AutocompleteEditViewWin::GetHorizontalMargin() const {
   RECT rect;
   GetRect(&rect);
   RECT client_rect;
   GetClientRect(&client_rect);
   return (rect.left - client_rect.left) + (client_rect.right - rect.right);
 }
 
 int AutocompleteEditViewWin::WidthNeededToDisplay(
-    const std::wstring& text) const {
+    const string16& text) const {
   // Use font_.GetStringWidth() instead of
   // PosFromChar(location_entry_->GetTextLength()) because PosFromChar() is
   // apparently buggy. In both LTR UI and RTL UI with left-to-right layout,
   // PosFromChar(i) might return 0 when i is greater than 1.
   return font_.GetStringWidth(text) + GetHorizontalMargin();
 }