Remove wstring from autocomplete.

chrome/browser/autocomplete/autocomplete_edit.h

 // 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.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_EDIT_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_EDIT_H_
 #pragma once
 
 #include "base/string16.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
@@ skipping 32 matching lines @@
   virtual void OnAutocompleteLosingFocus(
       gfx::NativeView view_gaining_focus) = 0;
 
   // Sent prior to OnAutoCompleteAccept and before the model has been reverted.
   // This is only invoked if the popup is closed before invoking
   // OnAutoCompleteAccept.
   virtual void OnAutocompleteWillAccept() = 0;
 
   // Commits the suggested text. |typed_text| is the current text showing in the
   // autocomplete. Returns true if the text was committed.
-  virtual bool OnCommitSuggestedText(const std::wstring& typed_text) = 0;
+  virtual bool OnCommitSuggestedText(const string16& typed_text) = 0;
 
   // Accepts the currently showing instant preview, if any, and returns true.
   // Returns false if there is no instant preview showing.
   virtual bool AcceptCurrentInstantPreview() = 0;
 
   // Invoked when the popup is going to change its bounds to |bounds|.
   virtual void OnPopupBoundsChanged(const gfx::Rect& bounds) = 0;
 
   // When the user presses enter or selects a line with the mouse, this
   // function will get called synchronously with the url to open and
@@ skipping 23 matching lines @@
   // Called whenever the autocomplete edit is losing focus.
   virtual void OnKillFocus() = 0;
 
   // Called whenever the autocomplete edit gets focused.
   virtual void OnSetFocus() = 0;
 
   // Returns the favicon of the current page.
   virtual SkBitmap GetFavIcon() const = 0;
 
   // Returns the title of the current page.
-  virtual std::wstring GetTitle() const = 0;
+  virtual string16 GetTitle() const = 0;
 
  protected:
   virtual ~AutocompleteEditController();
 };
 
 class AutocompleteEditModel : public NotificationObserver {
  public:
   struct 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);
     ~State();
 
     bool user_input_in_progress;
-    const std::wstring user_text;
-    const std::wstring keyword;
+    const string16 user_text;
+    const string16 keyword;
     const bool is_keyword_hint;
   };
 
   AutocompleteEditModel(AutocompleteEditView* view,
                         AutocompleteEditController* controller,
                         Profile* profile);
   ~AutocompleteEditModel();
 
   void SetPopupModel(AutocompletePopupModel* popup_model);
 
@@ skipping 12 matching lines @@
 
   // Restores local state from the saved |state|.
   void RestoreState(const State& state);
 
   // Returns the match for the current text. If the user has not edited the text
   // this is the match corresponding to the permanent text.
   AutocompleteMatch CurrentMatch();
 
   // Called when the user wants to export the entire current text as a URL.
   // Sets the url, and if known, the title and favicon.
-  void GetDataForURLExport(GURL* url, std::wstring* title, SkBitmap* favicon);
+  void GetDataForURLExport(GURL* url, string16* title, SkBitmap* favicon);
 
   // Returns true if a verbatim query should be used for instant. A verbatim
   // query is forced in certain situations, such as pressing delete at the end
   // of the edit.
   bool UseVerbatimInstant();
 
   // If the user presses ctrl-enter, it means "add .com to the the end".  The
   // desired TLD is the TLD the user desires to add to the end of the current
   // input, if any, based on their control key state and any other actions
   // they've taken.
-  std::wstring GetDesiredTLD() const;
+  string16 GetDesiredTLD() const;
 
   // Returns true if the current edit contents will be treated as a
   // URL/navigation, as opposed to a search.
   bool CurrentTextIsURL() const;
 
   // Returns the match type for the current edit contents.
   AutocompleteMatch::Type CurrentTextType() const;
 
   // Invoked to adjust the text before writting to the clipboard for a copy
   // (e.g. by adding 'http' to the front). |sel_min| gives the minimum position
   // of the selection e.g. min(selection_start, selection_end). |text| is the
   // currently selected text. If |is_all_selected| is true all the text in the
   // edit is selected. If the url should be copied to the clipboard |write_url|
   // is set to true and |url| set to the url to write.
   void AdjustTextForCopy(int sel_min,
                          bool is_all_selected,
-                         std::wstring* text,
+                         string16* text,
                          GURL* url,
                          bool* write_url);
 
   bool user_input_in_progress() const { return user_input_in_progress_; }
 
   // Sets the state of user_input_in_progress_, and notifies the observer if
   // that state has changed.
   void SetInputInProgress(bool in_progress);
 
   // Updates permanent_text_ to |new_permanent_text|.  Returns true if this
   // change should be immediately user-visible, because either the user is not
   // editing or the edit does not have focus.
-  bool UpdatePermanentText(const std::wstring& new_permanent_text);
+  bool UpdatePermanentText(const string16& new_permanent_text);
 
   // Sets the user_text_ to |text|.  Only the View should call this.
-  void SetUserText(const std::wstring& text);
+  void SetUserText(const string16& text);
 
   // Calls through to SearchProvider::FinalizeInstantQuery.
-  void FinalizeInstantQuery(const std::wstring& input_text,
-                            const std::wstring& suggest_text);
+  void FinalizeInstantQuery(const string16& input_text,
+                            const string16& suggest_text);
 
   // Reverts the edit model back to its unedited state (permanent text showing,
   // no user input in progress).
   void Revert();
 
   // Directs the popup to start autocomplete.
   void StartAutocomplete(bool has_selected_text,
                          bool prevent_inline_autocomplete) const;
 
   // Determines whether the user can "paste and go", given the specified text.
   // This also updates the internal paste-and-go-related state variables as
   // appropriate so that the controller doesn't need to be repeatedly queried
   // for the same text in every clipboard-related function.
-  bool CanPasteAndGo(const std::wstring& text) const;
+  bool CanPasteAndGo(const string16& text) const;
 
   // Navigates to the destination last supplied to CanPasteAndGo.
   void PasteAndGo();
 
   // Returns the url set by way of CanPasteAndGo.
   const GURL& paste_and_go_url() const { return paste_and_go_url_; }
 
   // Returns true if this is a paste-and-search rather than paste-and-go (or
   // nothing).
   bool is_paste_and_search() const {
     return (paste_and_go_transition_ != PageTransition::TYPED);
   }
 
   // Asks the browser to load the popup's currently selected item, using the
   // supplied disposition.  This may close the popup. If |for_drop| is true,
   // it indicates the input is being accepted as part of a drop operation and
   // the transition should be treated as LINK (so that it won't trigger the
   // URL to be autocompleted).
   void AcceptInput(WindowOpenDisposition disposition,
                    bool for_drop);
 
   // Asks the browser to load the item at |index|, with the given properties.
   void OpenURL(const GURL& url,
                WindowOpenDisposition disposition,
                PageTransition::Type transition,
                const GURL& alternate_nav_url,
                size_t index,
-               const std::wstring& keyword);
+               const string16& keyword);
 
   bool has_focus() const { return has_focus_; }
 
   // Accessors for keyword-related state (see comments on keyword_ and
   // is_keyword_hint_).
-  const std::wstring& keyword() const { return keyword_; }
+  const string16& keyword() const { return keyword_; }
   bool is_keyword_hint() const { return is_keyword_hint_; }
 
   // Accepts the current keyword hint as a keyword. It always returns true for
   // caller convenience.
   bool AcceptKeyword();
 
   // Clears the current keyword.  |visible_text| is the (non-keyword) text
   // currently visible in the edit.
-  void ClearKeyword(const std::wstring& visible_text);
+  void ClearKeyword(const string16& visible_text);
 
   // Returns true if a query to an autocomplete provider is currently
   // in progress.  This logic should in the future live in
   // AutocompleteController but resides here for now.  This method is used by
   // AutomationProvider::AutocompleteEditIsQueryInProgress.
   bool query_in_progress() const;
 
   // Returns the current autocomplete result.  This logic should in the future
   // live in AutocompleteController but resides here for now.  This method is
   // used by AutomationProvider::AutocompleteEditGetMatches.
@@ skipping 27 matching lines @@
   //   |text| is either the new temporary text from the user manually selecting
   //     a different match, or the inline autocomplete text.  We distinguish by
   //     checking if |destination_for_temporary_text_change| is NULL.
   //   |destination_for_temporary_text_change| is NULL (if temporary text should
   //     not change) or the pre-change destination URL (if temporary text should
   //     change) so we can save it off to restore later.
   //   |keyword| is the keyword to show a hint for if |is_keyword_hint| is true,
   //     or the currently selected keyword if |is_keyword_hint| is false (see
   //     comments on keyword_ and is_keyword_hint_).
   void 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);
 
   // Called by the AutocompleteEditView after something changes, with details
   // about what state changes occured.  Updates internal state, updates the
   // popup if necessary, and returns true if any significant changes occurred.
   // If |allow_keyword_ui_change| is false then the change should not affect
   // keyword ui state, even if the text matches a keyword exactly. This value
   // may be false when:
   // 1) The insert caret is not at the end of the edit box
   // 2) The user is composing a text with an IME
-  bool OnAfterPossibleChange(const std::wstring& new_text,
+  bool OnAfterPossibleChange(const string16& new_text,
                              bool selection_differs,
                              bool text_differs,
                              bool just_deleted_text,
                              bool allow_keyword_ui_change);
 
   // Invoked when the popup is going to change its bounds to |bounds|.
   void PopupBoundsChangedTo(const gfx::Rect& bounds);
 
  private:
   enum PasteState {
@@ skipping 20 matching lines @@
                           // he simply hasn't released the key, rather than that
                           // he intended to hit "ctrl-enter".
   };
 
   // NotificationObserver
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Called whenever user_text_ should change.
-  void InternalSetUserText(const std::wstring& text);
+  void InternalSetUserText(const string16& text);
 
   // Returns true if a keyword is selected.
   bool KeywordIsSelected() const;
 
   // Conversion between user text and display text. User text is the text the
   // user has input. Display text is the text being shown in the edit. The
   // two are different if a keyword is selected.
-  std::wstring DisplayTextFromUserText(const std::wstring& text) const;
-  std::wstring UserTextFromDisplayText(const std::wstring& text) const;
+  string16 DisplayTextFromUserText(const string16& text) const;
+  string16 UserTextFromDisplayText(const string16& text) const;
 
   // Returns the default match for the current text, as well as the alternate
   // nav URL, if |alternate_nav_url| is non-NULL and there is such a URL.
   void GetInfoForCurrentText(AutocompleteMatch* match,
                              GURL* alternate_nav_url) const;
 
   // Returns true if |text| (which is display text in the current context)
   // parses as a URL, and in that case sets |url| to the calculated URL.
   // Subtle note: This ignores the desired_tld_ (unlike GetDataForURLExport()
   // and CurrentTextIsURL()).  The view needs this because it calls this
   // function during copy handling, when the control key is down to trigger the
   // copy.
-  bool GetURLForText(const std::wstring& text, GURL* url) const;
+  bool GetURLForText(const string16& text, GURL* url) const;
 
   // Accepts current keyword if the user only typed a space at the end of
   // |new_user_text|. Returns true if the current keyword is accepted.
-  bool MaybeAcceptKeywordBySpace(const std::wstring& new_user_text);
+  bool MaybeAcceptKeywordBySpace(const string16& new_user_text);
 
   // Checks if a given character is a valid space character for accepting
   // keyword.
   static bool IsSpaceCharForAcceptingKeyword(wchar_t c);
 
   AutocompleteEditView* view_;
 
   AutocompletePopupModel* popup_;
 
   AutocompleteEditController* controller_;
 
   NotificationRegistrar registrar_;
 
   // Whether the edit has focus.
   bool has_focus_;
 
   // The URL of the currently displayed page.
-  std::wstring permanent_text_;
+  string16 permanent_text_;
 
   // This flag is true when the user has modified the contents of the edit, but
   // not yet accepted them.  We use this to determine when we need to save
   // state (on switching tabs) and whether changes to the page URL should be
   // immediately displayed.
   // This flag will be true in a superset of the cases where the popup is open.
   bool user_input_in_progress_;
 
   // The text that the user has entered.  This does not include inline
   // autocomplete text that has not yet been accepted.
-  std::wstring user_text_;
+  string16 user_text_;
 
   // When the user closes the popup, we need to remember the URL for their
   // desired choice, so that if they hit enter without reopening the popup we
   // know where to go.  We could simply rerun autocomplete in this case, but
   // we'd need to either wait for all results to come in (unacceptably slow) or
   // do the wrong thing when the user had chosen some provider whose results
   // were not returned instantaneously.
   //
   // This variable is only valid when user_input_in_progress_ is true, since
   // when it is false the user has either never input anything (so there won't
   // be a value here anyway) or has canceled their input, which should be
   // treated the same way.  Also, since this is for preserving a desired URL
   // after the popup has been closed, we ignore this if the popup is open, and
   // simply ask the popup for the desired URL directly.  As a result, the
   // contents of this variable only need to be updated when the popup is closed
   // but user_input_in_progress_ is not being cleared.
-  std::wstring url_for_remembered_user_selection_;
+  string16 url_for_remembered_user_selection_;
 
   // Inline autocomplete is allowed if the user has not just deleted text, and
   // no temporary text is showing.  In this case, inline_autocomplete_text_ is
   // appended to the user_text_ and displayed selected (at least initially).
   //
   // NOTE: When the popup is closed there should never be inline autocomplete
   // text (actions that close the popup should either accept the text, convert
   // it to a normal selection, or change the edit entirely).
   bool just_deleted_text_;
-  std::wstring inline_autocomplete_text_;
+  string16 inline_autocomplete_text_;
 
   // Used by OnPopupDataChanged to keep track of whether there is currently a
   // temporary text.
   //
   // Example of use: If the user types "goog", then arrows down in the
   // autocomplete popup until, say, "google.com" appears in the edit box, then
   // the user_text_ is still "goog", and "google.com" is "temporary text".
   // When the user hits <esc>, the edit box reverts to "goog".  Hit <esc> again
   // and the popup is closed and "goog" is replaced by the permanent_text_,
   // which is the URL of the current page.
@@ skipping 12 matching lines @@
 
   // Whether the control key is depressed.  We track this to avoid calling
   // UpdatePopup() repeatedly if the user holds down the key, and to know
   // whether to trigger "ctrl-enter" behavior.
   ControlKeyState control_key_state_;
 
   // The keyword associated with the current match.  The user may have an actual
   // selected keyword, or just some input text that looks like a keyword (so we
   // can show a hint to press <tab>).  This is the keyword in either case;
   // is_keyword_hint_ (below) distinguishes the two cases.
-  std::wstring keyword_;
+  string16 keyword_;
 
   // True if the keyword associated with this match is merely a hint, i.e. the
   // user hasn't actually selected a keyword yet.  When this is true, we can use
   // keyword_ to show a "Press <tab> to search" sort of hint.
   bool is_keyword_hint_;
 
   // Paste And Go-related state.  See CanPasteAndGo().
   mutable GURL paste_and_go_url_;
   mutable PageTransition::Type paste_and_go_transition_;
   mutable GURL paste_and_go_alternate_nav_url_;
 
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(AutocompleteEditModel);
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_EDIT_H_