Remove wstring from autocomplete.

chrome/browser/autocomplete/autocomplete_edit_view_mac.mm

 // Copyright (c) 2010 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_mac.h"
 
 #include <Carbon/Carbon.h>  // kVK_Return
 
 #include "app/mac/nsimage_cache.h"
 #include "base/string_util.h"
@@ skipping 214 matching lines @@
 }
 
 void AutocompleteEditViewMac::Update(
     const TabContents* tab_for_state_restoring) {
   // TODO(shess): It seems like if the tab is non-NULL, then this code
   // shouldn't need to be called at all.  When coded that way, I find
   // that the field isn't always updated correctly.  Figure out why
   // this is.  Maybe this method should be refactored into more
   // specific cases.
   const bool user_visible =
-      model_->UpdatePermanentText(toolbar_model_->GetText());
+      model_->UpdatePermanentText(WideToUTF16Hack(toolbar_model_->GetText()));
 
   if (tab_for_state_restoring) {
     RevertAll();
 
     const AutocompleteEditViewMacState* state =
         GetStateFromTab(tab_for_state_restoring);
     if (state) {
       // Should restore the user's text via SetUserText().
       model_->RestoreState(state->model_state);
 
@@ skipping 26 matching lines @@
     // that should go away.
     EmphasizeURLComponents();
   }
 }
 
 void AutocompleteEditViewMac::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) {
   // TODO(shess): Why is the caller passing an invalid url in the
   // first place?  Make sure that case isn't being dropped on the
   // floor.
   if (!url.is_valid()) {
     return;
   }
 
   model_->OpenURL(url, disposition, transition, alternate_nav_url,
                   selected_line, keyword);
 }
 
-std::wstring AutocompleteEditViewMac::GetText() const {
-  return base::SysNSStringToWide(GetNonSuggestTextSubstring());
+string16 AutocompleteEditViewMac::GetText() const {
+  return base::SysNSStringToUTF16(GetNonSuggestTextSubstring());
 }
 
 bool AutocompleteEditViewMac::IsEditingOrEmpty() const {
   return model_->user_input_in_progress() ||
       ([[field_ stringValue] length] == 0);
 }
 
 int AutocompleteEditViewMac::GetIcon() const {
   return IsEditingOrEmpty() ?
       AutocompleteMatch::TypeToIcon(model_->CurrentTextType()) :
       toolbar_model_->GetIcon();
 }
 
-void AutocompleteEditViewMac::SetUserText(const std::wstring& text) {
+void AutocompleteEditViewMac::SetUserText(const string16& text) {
   SetUserText(text, text, true);
 }
 
-void AutocompleteEditViewMac::SetUserText(const std::wstring& text,
-                                          const std::wstring& display_text,
+void AutocompleteEditViewMac::SetUserText(const string16& text,
+                                          const string16& display_text,
                                           bool update_popup) {
   model_->SetUserText(text);
   // TODO(shess): TODO below from gtk.
   // TODO(deanm): something about selection / focus change here.
   SetText(display_text);
   if (update_popup) {
     UpdatePopup();
   }
   controller_->OnChanged();
 }
@@ skipping 19 matching lines @@
     }
 
     // TODO(shess): What if it didn't get first responder, and there is
     // no field editor?  This will do nothing.  Well, at least it won't
     // crash.  Think of something more productive to do, or prove that
     // it cannot occur and DCHECK appropriately.
     [[field_ currentEditor] setSelectedRange:range];
   }
 }
 
-void AutocompleteEditViewMac::SetWindowTextAndCaretPos(const std::wstring& text,
+void AutocompleteEditViewMac::SetWindowTextAndCaretPos(const string16& text,
                                                        size_t caret_pos) {
   DCHECK_LE(caret_pos, text.size());
   SetTextAndSelectedRange(text, NSMakeRange(caret_pos, caret_pos));
 }
 
 void AutocompleteEditViewMac::SetForcedQuery() {
   // We need to do this first, else |SetSelectedRange()| won't work.
   FocusLocation(true);
 
-  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 {
     NSRange range = NSMakeRange(start + 1, current_text.size() - start - 1);
     [[field_ currentEditor] setSelectedRange:range];
   }
 }
 
 bool AutocompleteEditViewMac::IsSelectAll() {
   if (![field_ currentEditor])
     return true;
   const NSRange all_range = NSMakeRange(0, GetText().length());
   return NSEqualRanges(all_range, GetSelectedRange());
 }
 
 bool AutocompleteEditViewMac::DeleteAtEndPressed() {
   return delete_at_end_pressed_;
 }
 
-void AutocompleteEditViewMac::GetSelectionBounds(std::wstring::size_type* start,
-                                                 std::wstring::size_type* end) {
+void AutocompleteEditViewMac::GetSelectionBounds(string16::size_type* start,
+                                                 string16::size_type* end) {
   if (![field_ currentEditor]) {
     *start = *end = 0;
     return;
   }
 
   const NSRange selected_range = GetSelectedRange();
   *start = static_cast<size_t>(selected_range.location);
   *end = static_cast<size_t>(NSMaxRange(selected_range));
 }
 
@@ skipping 44 matching lines @@
   popup_view_->GetModel()->StopAutocomplete();
 }
 
 void AutocompleteEditViewMac::SetFocus() {
 }
 
 bool AutocompleteEditViewMac::CommitSuggestText() {
   if (suggest_text_length_ == 0)
     return false;
 
-  std::wstring input_text(GetText());
+  string16 input_text(GetText());
   suggest_text_length_ = 0;
-  std::wstring text(GetText());
+  string16 text(GetText());
   // Call SetText() to force a redraw and move the cursor to the end.
   SetText(text);
   model()->FinalizeInstantQuery(input_text, text.substr(input_text.size()));
   return true;
 }
 
-void AutocompleteEditViewMac::SetText(const std::wstring& display_text) {
+void AutocompleteEditViewMac::SetText(const string16& display_text) {
   // If we are setting the text directly, there cannot be any suggest text.
   suggest_text_length_ = 0;
   SetTextInternal(display_text);
 }
 
 void AutocompleteEditViewMac::SetTextInternal(
-    const std::wstring& display_text) {
-  NSString* ss = base::SysWideToNSString(display_text);
+    const string16& display_text) {
+  NSString* ss = base::SysUTF16ToNSString(display_text);
   NSMutableAttributedString* as =
       [[[NSMutableAttributedString alloc] initWithString:ss] autorelease];
 
   ApplyTextAttributes(display_text, as);
 
   [field_ setAttributedStringValue:as];
 
   // TODO(shess): This may be an appropriate place to call:
   //   controller_->OnChanged();
   // In the current implementation, this tells LocationBarViewMac to
   // mess around with |model_| and update |field_|.  Unfortunately,
   // when I look at our peer implementations, it's not entirely clear
   // to me if this is safe.  SetTextInternal() is sort of an utility method,
   // and different callers sometimes have different needs.  Research
   // this issue so that it can be added safely.
 
   // TODO(shess): Also, consider whether this code couldn't just
   // manage things directly.  Windows uses a series of overlaid view
   // objects to accomplish the hinting stuff that OnChanged() does, so
   // it makes sense to have it in the controller that lays those
   // things out.  Mac instead pushes the support into a custom
   // text-field implementation.
 }
 
 void AutocompleteEditViewMac::SetTextAndSelectedRange(
-    const std::wstring& display_text, const NSRange range) {
+    const string16& display_text, const NSRange range) {
   SetText(display_text);
   SetSelectedRange(range);
 }
 
 NSString* AutocompleteEditViewMac::GetNonSuggestTextSubstring() const {
   NSString* text = [field_ stringValue];
   if (suggest_text_length_ > 0) {
     NSUInteger length = [text length];
 
     DCHECK_LE(suggest_text_length_, length);
@@ skipping 16 matching lines @@
                      range:NSMakeRange(0, [storage length])];
     ApplyTextAttributes(GetText(), storage);
 
     [storage endEditing];
   } else {
     SetText(GetText());
   }
 }
 
 void AutocompleteEditViewMac::ApplyTextAttributes(
-    const std::wstring& display_text, NSMutableAttributedString* as) {
+    const string16& display_text, NSMutableAttributedString* as) {
   [as addAttribute:NSFontAttributeName value:GetFieldFont()
              range:NSMakeRange(0, [as length])];
 
   // Make a paragraph style locking in the standard line height as the maximum,
   // otherwise the baseline may shift "downwards".
   scoped_nsobject<NSMutableParagraphStyle>
       paragraph_style([[NSMutableParagraphStyle alloc] init]);
   [paragraph_style setMaximumLineHeight:line_height_];
   [as addAttribute:NSParagraphStyleAttributeName value:paragraph_style
              range:NSMakeRange(0, [as length])];
@@ skipping 39 matching lines @@
     } else {
       NOTREACHED();
       color = BaseTextColor();
     }
     [as addAttribute:NSForegroundColorAttributeName value:color
                range:ComponentToNSRange(scheme)];
   }
 }
 
 void AutocompleteEditViewMac::OnTemporaryTextMaybeChanged(
-    const std::wstring& display_text, bool save_original_selection) {
+    const string16& display_text, bool save_original_selection) {
   if (save_original_selection)
     saved_temporary_selection_ = GetSelectedRange();
 
   suggest_text_length_ = 0;
   SetWindowTextAndCaretPos(display_text, display_text.size());
   controller_->OnChanged();
   [field_ clearUndoChain];
 }
 
 void AutocompleteEditViewMac::OnStartingIME() {
   // Reset the suggest text just before starting an IME composition session,
   // otherwise the IME composition may be interrupted when the suggest text
   // gets reset by the IME composition change.
   SetInstantSuggestion(string16());
 }
 
 bool AutocompleteEditViewMac::OnInlineAutocompleteTextMaybeChanged(
-    const std::wstring& display_text, size_t user_text_length) {
+    const string16& display_text, size_t user_text_length) {
   // TODO(shess): Make sure that this actually works.  The round trip
   // to native form and back may mean that it's the same but not the
   // same.
   if (display_text == GetText())
     return false;
 
   DCHECK_LE(user_text_length, display_text.size());
   const NSRange range =
       NSMakeRange(user_text_length, display_text.size() - user_text_length);
   SetTextAndSelectedRange(display_text, range);
@@ skipping 18 matching lines @@
   selection_before_change_ = GetSelectedRange();
   text_before_change_ = GetText();
   marked_range_before_change_ = GetMarkedRange();
 }
 
 bool AutocompleteEditViewMac::OnAfterPossibleChange() {
   // We should only arrive here when the field is focussed.
   DCHECK(IsFirstResponder());
 
   const NSRange new_selection(GetSelectedRange());
-  const std::wstring new_text(GetText());
+  const string16 new_text(GetText());
   const size_t length = new_text.length();
 
   const bool selection_differs =
       (new_selection.length || selection_before_change_.length) &&
       !NSEqualRanges(new_selection, selection_before_change_);
   const bool at_end_of_edit = (length == new_selection.location);
   const bool text_differs = (new_text != text_before_change_) ||
       !NSEqualRanges(marked_range_before_change_, GetMarkedRange());
 
   // When the user has deleted text, we don't allow inline
@@ skipping 49 matching lines @@
   // Append the new suggest text.
   suggest_text_length_ = suggest_text.length();
   if (suggest_text_length_ > 0) {
     text = [text stringByAppendingString:base::SysUTF16ToNSString(
                suggest_text)];
     needs_update = true;
   }
 
   if (needs_update) {
     NSRange current_range = GetSelectedRange();
-    SetTextInternal(base::SysNSStringToWide(text));
+    SetTextInternal(base::SysNSStringToUTF16(text));
     if (NSMaxRange(current_range) <= [text length] - suggest_text_length_)
       SetSelectedRange(current_range);
     else
       SetSelectedRange(NSMakeRange([text length] - suggest_text_length_, 0));
   }
 }
 
 int AutocompleteEditViewMac::TextWidth() const {
   // Not used on mac.
   NOTREACHED();
@@ skipping 165 matching lines @@
 
 bool AutocompleteEditViewMac::CanCopy() {
   const NSRange selection = GetSelectedRange();
   return selection.length > 0;
 }
 
 void AutocompleteEditViewMac::CopyToPasteboard(NSPasteboard* pb) {
   DCHECK(CanCopy());
 
   const NSRange selection = GetSelectedRange();
-  std::wstring text = base::SysNSStringToWide(
+  string16 text = base::SysNSStringToUTF16(
       [[field_ stringValue] substringWithRange:selection]);
 
   GURL url;
   bool write_url = false;
   model_->AdjustTextForCopy(selection.location, IsSelectAll(), &text, &url,
                             &write_url);
 
-  NSString* nstext = base::SysWideToNSString(text);
+  NSString* nstext = base::SysUTF16ToNSString(text);
   [pb declareTypes:[NSArray arrayWithObject:NSStringPboardType] owner:nil];
   [pb setString:nstext forType:NSStringPboardType];
 
   if (write_url) {
     [pb declareURLPasteboardWithAdditionalTypes:[NSArray array] owner:nil];
     [pb setDataForURL:base::SysUTF8ToNSString(url.spec()) title:nstext];
   }
 }
 
 void AutocompleteEditViewMac::OnPaste() {
   // This code currently expects |field_| to be focussed.
   DCHECK([field_ currentEditor]);
 
-  std::wstring text = GetClipboardText(g_browser_process->clipboard());
+  string16 text = GetClipboardText(g_browser_process->clipboard());
   if (text.empty()) {
     return;
   }
-  NSString* s = base::SysWideToNSString(text);
+  NSString* s = base::SysUTF16ToNSString(text);
 
   // -shouldChangeTextInRange:* and -didChangeText are documented in
   // NSTextView as things you need to do if you write additional
   // user-initiated editing functions.  They cause the appropriate
   // delegate methods to be called.
   // TODO(shess): It would be nice to separate the Cocoa-specific code
   // from the Chrome-specific code.
   NSTextView* editor = static_cast<NSTextView*>([field_ currentEditor]);
   const NSRange selectedRange = GetSelectedRange();
   if ([editor shouldChangeTextInRange:selectedRange replacementString:s]) {
@@ skipping 100 matching lines @@
     // that it's already focused. makeFirstResponder: will select all, so only
     // call it if this behavior is desired.
     if (select_all || ![field_ currentEditor])
       [[field_ window] makeFirstResponder:field_];
     DCHECK_EQ([field_ currentEditor], [[field_ window] firstResponder]);
   }
 }
 
 // TODO(shess): Copied from autocomplete_edit_view_win.cc.  Could this
 // be pushed into the model?
-std::wstring AutocompleteEditViewMac::GetClipboardText(
+string16 AutocompleteEditViewMac::GetClipboardText(
     ui::Clipboard* clipboard) {
   // autocomplete_edit_view_win.cc assumes this can never happen, we
   // will too.
   DCHECK(clipboard);
 
   if (clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
                                    ui::Clipboard::BUFFER_STANDARD)) {
     string16 text16;
     clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &text16);
 
     // 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(UTF16ToWide(text16), true);
+    return CollapseWhitespace(text16, 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 UTF8ToUTF16(url.spec());
     }
   }
 
-  return std::wstring();
+  return string16();
 }
 
 // static
 NSFont* AutocompleteEditViewMac::GetFieldFont() {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   return rb.GetFont(ResourceBundle::BaseFont).GetNativeFont();
 }