Prefix string16 with base:: in ui/.

ui/views/controls/textfield/textfield_views_model.cc

 // Copyright (c) 2012 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 "ui/views/controls/textfield/textfield_views_model.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 63 matching lines @@
   void Commit() { merge_type_ = DO_NOT_MERGE; }
 
  private:
   friend class InsertEdit;
   friend class ReplaceEdit;
   friend class DeleteEdit;
 
   Edit(Type type,
        MergeType merge_type,
        size_t old_cursor_pos,
-       const string16& old_text,
+       const base::string16& old_text,
        size_t old_text_start,
        bool delete_backward,
        size_t new_cursor_pos,
-       const string16& new_text,
+       const base::string16& new_text,
        size_t new_text_start)
       : type_(type),
         merge_type_(merge_type),
         old_cursor_pos_(old_cursor_pos),
         old_text_(old_text),
         old_text_start_(old_text_start),
         delete_backward_(delete_backward),
         new_cursor_pos_(new_cursor_pos),
         new_text_(new_text),
         new_text_start_(new_text_start) {
@@ skipping 19 matching lines @@
   // Returns the end index of the |new_text_|.
   size_t new_text_end() const { return new_text_start_ + new_text_.length(); }
 
   // Merge the replace edit into the current edit. This is a special case to
   // handle an omnibox setting autocomplete string after new character is
   // typed in.
   void MergeReplace(const Edit* edit) {
     CHECK_EQ(REPLACE_EDIT, edit->type_);
     CHECK_EQ(0U, edit->old_text_start_);
     CHECK_EQ(0U, edit->new_text_start_);
-    string16 old_text = edit->old_text_;
+    base::string16 old_text = edit->old_text_;
     old_text.erase(new_text_start_, new_text_.length());
     old_text.insert(old_text_start_, old_text_);
     // SetText() replaces entire text. Set |old_text_| to the entire
     // replaced text with |this| edit undone.
     old_text_ = old_text;
     old_text_start_ = edit->old_text_start_;
     delete_backward_ = false;
 
     new_text_ = edit->new_text_;
     new_text_start_ = edit->new_text_start_;
     merge_type_ = DO_NOT_MERGE;
   }
 
   Type type_;
 
   // True if the edit can be marged.
   MergeType merge_type_;
   // Old cursor position.
   size_t old_cursor_pos_;
   // Deleted text by this edit.
-  string16 old_text_;
+  base::string16 old_text_;
   // The index of |old_text_|.
   size_t old_text_start_;
   // True if the deletion is made backward.
   bool delete_backward_;
   // New cursor position.
   size_t new_cursor_pos_;
   // Added text.
-  string16 new_text_;
+  base::string16 new_text_;
   // The index of |new_text_|
   size_t new_text_start_;
 
   DISALLOW_COPY_AND_ASSIGN(Edit);
 };
 
 class InsertEdit : public Edit {
  public:
-  InsertEdit(bool mergeable, const string16& new_text, size_t at)
+  InsertEdit(bool mergeable, const base::string16& new_text, size_t at)
       : Edit(INSERT_EDIT,
              mergeable ? MERGEABLE : DO_NOT_MERGE,
              at  /* old cursor */,
-             string16(),
+             base::string16(),
              at,
              false  /* N/A */,
              at + new_text.length()  /* new cursor */,
              new_text,
              at) {
   }
 
   // Edit implementation.
   virtual bool DoMerge(const Edit* edit) OVERRIDE {
     if (edit->type() != INSERT_EDIT || new_text_end() != edit->new_text_start_)
       return false;
     // If continuous edit, merge it.
     // TODO(oshima): gtk splits edits between whitespace. Find out what
     // we want to here and implement if necessary.
     new_text_ += edit->new_text_;
     new_cursor_pos_ = edit->new_cursor_pos_;
     return true;
   }
 };
 
 class ReplaceEdit : public Edit {
  public:
   ReplaceEdit(MergeType merge_type,
-              const string16& old_text,
+              const base::string16& old_text,
               size_t old_cursor_pos,
               size_t old_text_start,
               bool backward,
               size_t new_cursor_pos,
-              const string16& new_text,
+              const base::string16& new_text,
               size_t new_text_start)
       : Edit(REPLACE_EDIT, merge_type,
              old_cursor_pos,
              old_text,
              old_text_start,
              backward,
              new_cursor_pos,
              new_text,
              new_text_start) {
   }
 
   // Edit implementation.
   virtual bool DoMerge(const Edit* edit) OVERRIDE {
     if (edit->type() == DELETE_EDIT ||
         new_text_end() != edit->old_text_start_ ||
         edit->old_text_start_ != edit->new_text_start_)
       return false;
     old_text_ += edit->old_text_;
     new_text_ += edit->new_text_;
     new_cursor_pos_ = edit->new_cursor_pos_;
     return true;
   }
 };
 
 class DeleteEdit : public Edit {
  public:
   DeleteEdit(bool mergeable,
-             const string16& text,
+             const base::string16& text,
              size_t text_start,
              bool backward)
       : Edit(DELETE_EDIT,
              mergeable ? MERGEABLE : DO_NOT_MERGE,
              (backward ? text_start + text.length() : text_start),
              text,
              text_start,
              backward,
              text_start,
-             string16(),
+             base::string16(),
              text_start) {
   }
 
   // Edit implementation.
   virtual bool DoMerge(const Edit* edit) OVERRIDE {
     if (edit->type() != DELETE_EDIT)
       return false;
 
     if (delete_backward_) {
       // backspace can be merged only with backspace at the
@@ skipping 51 matching lines @@
     : delegate_(delegate),
       render_text_(gfx::RenderText::CreateInstance()),
       current_edit_(edit_history_.end()) {
 }
 
 TextfieldViewsModel::~TextfieldViewsModel() {
   ClearEditHistory();
   ClearComposition();
 }
 
-const string16& TextfieldViewsModel::GetText() const {
+const base::string16& TextfieldViewsModel::GetText() const {
   return render_text_->text();
 }
 
-bool TextfieldViewsModel::SetText(const string16& text) {
+bool TextfieldViewsModel::SetText(const base::string16& text) {
   bool changed = false;
   if (HasCompositionText()) {
     ConfirmCompositionText();
     changed = true;
   }
   if (GetText() != text) {
     if (changed)  // No need to remember composition.
       Undo();
     size_t old_cursor = GetCursorPosition();
     // SetText moves the cursor to the end.
     size_t new_cursor = text.length();
     SelectAll(false);
     // If there is a composition text, don't merge with previous edit.
     // Otherwise, force merge the edits.
     ExecuteAndRecordReplace(
         changed ? DO_NOT_MERGE : MERGE_WITH_PREVIOUS,
         old_cursor,
         new_cursor,
         text,
         0U);
     render_text_->SetCursorPosition(new_cursor);
   }
   ClearSelection();
   return changed;
 }
 
-void TextfieldViewsModel::Append(const string16& text) {
+void TextfieldViewsModel::Append(const base::string16& text) {
   if (HasCompositionText())
     ConfirmCompositionText();
   size_t save = GetCursorPosition();
   MoveCursor(gfx::LINE_BREAK,
              render_text_->GetVisualDirectionOfLogicalEnd(),
              false);
   InsertText(text);
   render_text_->SetCursorPosition(save);
   ClearSelection();
 }
@@ skipping 65 matching lines @@
   }
   return render_text_->MoveCursorTo(model);
 }
 
 bool TextfieldViewsModel::MoveCursorTo(const gfx::Point& point, bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   return render_text_->MoveCursorTo(point, select);
 }
 
-string16 TextfieldViewsModel::GetSelectedText() const {
+base::string16 TextfieldViewsModel::GetSelectedText() const {
   return GetText().substr(render_text_->selection().GetMin(),
                           render_text_->selection().length());
 }
 
 void TextfieldViewsModel::SelectRange(const gfx::Range& range) {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->SelectRange(range);
 }
 
@@ skipping 35 matching lines @@
       ++iter != edit_history_.end();
 }
 
 bool TextfieldViewsModel::Undo() {
   if (!CanUndo())
     return false;
   DCHECK(!HasCompositionText());
   if (HasCompositionText())  // safe guard for release build.
     CancelCompositionText();
 
-  string16 old = GetText();
+  base::string16 old = GetText();
   size_t old_cursor = GetCursorPosition();
   (*current_edit_)->Commit();
   (*current_edit_)->Undo(this);
 
   if (current_edit_ == edit_history_.begin())
     current_edit_ = edit_history_.end();
   else
     current_edit_--;
   return old != GetText() || old_cursor != GetCursorPosition();
 }
 
 bool TextfieldViewsModel::Redo() {
   if (!CanRedo())
     return false;
   DCHECK(!HasCompositionText());
   if (HasCompositionText()) // safe guard for release build.
     CancelCompositionText();
 
   if (current_edit_ == edit_history_.end())
     current_edit_ = edit_history_.begin();
   else
     current_edit_ ++;
-  string16 old = GetText();
+  base::string16 old = GetText();
   size_t old_cursor = GetCursorPosition();
   (*current_edit_)->Redo(this);
   return old != GetText() || old_cursor != GetCursorPosition();
 }
 
 bool TextfieldViewsModel::Cut() {
   if (!HasCompositionText() && HasSelection() && !render_text_->obscured()) {
     ui::ScopedClipboardWriter(
         ui::Clipboard::GetForCurrentThread(),
         ui::CLIPBOARD_TYPE_COPY_PASTE).WriteText(GetSelectedText());
@@ skipping 14 matching lines @@
   if (!HasCompositionText() && HasSelection() && !render_text_->obscured()) {
     ui::ScopedClipboardWriter(
         ui::Clipboard::GetForCurrentThread(),
         ui::CLIPBOARD_TYPE_COPY_PASTE).WriteText(GetSelectedText());
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Paste() {
-  string16 result;
+  base::string16 result;
   ui::Clipboard::GetForCurrentThread()->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE,
                                                  &result);
   if (!result.empty()) {
     InsertTextInternal(result, false);
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::HasSelection() const {
   return !render_text_->selection().is_empty();
 }
 
 void TextfieldViewsModel::DeleteSelection() {
   DCHECK(!HasCompositionText());
   DCHECK(HasSelection());
   ExecuteAndRecordDelete(render_text_->selection(), false);
 }
 
 void TextfieldViewsModel::DeleteSelectionAndInsertTextAt(
-    const string16& text, size_t position) {
+    const base::string16& text, size_t position) {
   if (HasCompositionText())
     CancelCompositionText();
   ExecuteAndRecordReplace(DO_NOT_MERGE,
                           GetCursorPosition(),
                           position + text.length(),
                           text,
                           position);
 }
 
-string16 TextfieldViewsModel::GetTextFromRange(const gfx::Range& range) const {
+base::string16 TextfieldViewsModel::GetTextFromRange(
+    const gfx::Range& range) const {
   if (range.IsValid() && range.GetMin() < GetText().length())
     return GetText().substr(range.GetMin(), range.length());
-  return string16();
+  return base::string16();
 }
 
 void TextfieldViewsModel::GetTextRange(gfx::Range* range) const {
   *range = gfx::Range(0, GetText().length());
 }
 
 void TextfieldViewsModel::SetCompositionText(
     const ui::CompositionText& composition) {
   if (HasCompositionText())
     CancelCompositionText();
   else if (HasSelection())
     DeleteSelection();
 
   if (composition.text.empty())
     return;
 
   size_t cursor = GetCursorPosition();
-  string16 new_text = GetText();
+  base::string16 new_text = GetText();
   render_text_->SetText(new_text.insert(cursor, composition.text));
   gfx::Range range(cursor, cursor + composition.text.length());
   render_text_->SetCompositionRange(range);
   gfx::Range emphasized_range = GetFirstEmphasizedRange(composition);
   if (emphasized_range.IsValid()) {
     // This is a workaround due to the lack of support in RenderText to draw
     // a thick underline. In a composition returned from an IME, the segment
     // emphasized by a thick underline usually represents the target clause.
     // Because the target clause is more important than the actual selection
     // range (or caret position) in the composition here we use a selection-like
     // marker instead to show this range.
     // TODO(yukawa, msw): Support thick underline in RenderText and remove
     // this workaround.
     render_text_->SelectRange(gfx::Range(
         cursor + emphasized_range.GetMin(),
         cursor + emphasized_range.GetMax()));
   } else if (!composition.selection.is_empty()) {
     render_text_->SelectRange(gfx::Range(
         cursor + composition.selection.GetMin(),
         cursor + composition.selection.GetMax()));
   } else {
     render_text_->SetCursorPosition(cursor + composition.selection.end());
   }
 }
 
 void TextfieldViewsModel::ConfirmCompositionText() {
   DCHECK(HasCompositionText());
   gfx::Range range = render_text_->GetCompositionRange();
-  string16 text = GetText().substr(range.start(), range.length());
+  base::string16 text = GetText().substr(range.start(), range.length());
   // TODO(oshima): current behavior on ChromeOS is a bit weird and not
   // sure exactly how this should work. Find out and fix if necessary.
   AddOrMergeEditHistory(new InsertEdit(false, text, range.start()));
   render_text_->SetCursorPosition(range.end());
   ClearComposition();
   if (delegate_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldViewsModel::CancelCompositionText() {
   DCHECK(HasCompositionText());
   gfx::Range range = render_text_->GetCompositionRange();
   ClearComposition();
-  string16 new_text = GetText();
+  base::string16 new_text = GetText();
   render_text_->SetText(new_text.erase(range.start(), range.length()));
   render_text_->SetCursorPosition(range.start());
   if (delegate_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldViewsModel::ClearComposition() {
   render_text_->SetCompositionRange(gfx::Range::InvalidRange());
 }
 
 void TextfieldViewsModel::GetCompositionTextRange(gfx::Range* range) const {
   *range = gfx::Range(render_text_->GetCompositionRange());
 }
 
 bool TextfieldViewsModel::HasCompositionText() const {
   return !render_text_->GetCompositionRange().is_empty();
 }
 
 /////////////////////////////////////////////////////////////////
 // TextfieldViewsModel: private
 
-void TextfieldViewsModel::InsertTextInternal(const string16& text,
+void TextfieldViewsModel::InsertTextInternal(const base::string16& text,
                                              bool mergeable) {
   if (HasCompositionText()) {
     CancelCompositionText();
     ExecuteAndRecordInsert(text, mergeable);
   } else if (HasSelection()) {
     ExecuteAndRecordReplaceSelection(mergeable ? MERGEABLE : DO_NOT_MERGE,
                                      text);
   } else {
     ExecuteAndRecordInsert(text, mergeable);
   }
 }
 
-void TextfieldViewsModel::ReplaceTextInternal(const string16& text,
+void TextfieldViewsModel::ReplaceTextInternal(const base::string16& text,
                                               bool mergeable) {
   if (HasCompositionText()) {
     CancelCompositionText();
   } else if (!HasSelection()) {
     size_t cursor = GetCursorPosition();
     const gfx::SelectionModel& model = render_text_->selection_model();
     // When there is no selection, the default is to replace the next grapheme
     // with |text|. So, need to find the index of next grapheme first.
     size_t next =
         render_text_->IndexOfAdjacentGrapheme(cursor, gfx::CURSOR_FORWARD);
@@ skipping 20 matching lines @@
   }
   EditHistory::iterator delete_start = current_edit_;
   delete_start++;
   STLDeleteContainerPointers(delete_start, edit_history_.end());
   edit_history_.erase(delete_start, edit_history_.end());
 }
 
 void TextfieldViewsModel::ExecuteAndRecordDelete(gfx::Range range,
                                                  bool mergeable) {
   size_t old_text_start = range.GetMin();
-  const string16 text = GetText().substr(old_text_start, range.length());
+  const base::string16 text = GetText().substr(old_text_start, range.length());
   bool backward = range.is_reversed();
   Edit* edit = new DeleteEdit(mergeable, text, old_text_start, backward);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
   if (delete_edit)
     delete edit;
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplaceSelection(
-    MergeType merge_type, const string16& new_text) {
+    MergeType merge_type, const base::string16& new_text) {
   size_t new_text_start = render_text_->selection().GetMin();
   size_t new_cursor_pos = new_text_start + new_text.length();
   ExecuteAndRecordReplace(merge_type,
                           GetCursorPosition(),
                           new_cursor_pos,
                           new_text,
                           new_text_start);
 }
 
-void TextfieldViewsModel::ExecuteAndRecordReplace(MergeType merge_type,
-                                                  size_t old_cursor_pos,
-                                                  size_t new_cursor_pos,
-                                                  const string16& new_text,
-                                                  size_t new_text_start) {
+void TextfieldViewsModel::ExecuteAndRecordReplace(
+    MergeType merge_type,
+    size_t old_cursor_pos,
+    size_t new_cursor_pos,
+    const base::string16& new_text,
+    size_t new_text_start) {
   size_t old_text_start = render_text_->selection().GetMin();
   bool backward = render_text_->selection().is_reversed();
   Edit* edit = new ReplaceEdit(merge_type,
                                GetSelectedText(),
                                old_cursor_pos,
                                old_text_start,
                                backward,
                                new_cursor_pos,
                                new_text,
                                new_text_start);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
   if (delete_edit)
     delete edit;
 }
 
-void TextfieldViewsModel::ExecuteAndRecordInsert(const string16& text,
+void TextfieldViewsModel::ExecuteAndRecordInsert(const base::string16& text,
                                                  bool mergeable) {
   Edit* edit = new InsertEdit(mergeable, text, GetCursorPosition());
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
   if (delete_edit)
     delete edit;
 }
 
 bool TextfieldViewsModel::AddOrMergeEditHistory(Edit* edit) {
   ClearRedoHistory();
@@ skipping 11 matching lines @@
     DCHECK_EQ(1u, edit_history_.size());
     current_edit_ = edit_history_.begin();
   } else {
     current_edit_++;
   }
   return false;
 }
 
 void TextfieldViewsModel::ModifyText(size_t delete_from,
                                      size_t delete_to,
-                                     const string16& new_text,
+                                     const base::string16& new_text,
                                      size_t new_text_insert_at,
                                      size_t new_cursor_pos) {
   DCHECK_LE(delete_from, delete_to);
-  string16 text = GetText();
+  base::string16 text = GetText();
   ClearComposition();
   if (delete_from != delete_to)
     render_text_->SetText(text.erase(delete_from, delete_to - delete_from));
   if (!new_text.empty())
     render_text_->SetText(text.insert(new_text_insert_at, new_text));
   render_text_->SetCursorPosition(new_cursor_pos);
   // TODO(oshima): mac selects the text that is just undone (but gtk doesn't).
   // This looks fine feature and we may want to do the same.
 }
 
 }  // namespace views