Prefix string16 with base:: in ui/.

ui/views/controls/textfield/native_textfield_views_unittest.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/native_textfield_views.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 69 matching lines @@
   bool key_received_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTextfield);
 };
 
 // A helper class for use with ui::TextInputClient::GetTextFromRange().
 class GetTextHelper {
  public:
   GetTextHelper() {}
 
-  void set_text(const string16& text) { text_ = text; }
-  const string16& text() const { return text_; }
+  void set_text(const base::string16& text) { text_ = text; }
+  const base::string16& text() const { return text_; }
 
  private:
-  string16 text_;
+  base::string16 text_;
 
   DISALLOW_COPY_AND_ASSIGN(GetTextHelper);
 };
 
 // Convenience to make constructing a GestureEvent simpler.
 class GestureEventForTest : public ui::GestureEvent {
  public:
   GestureEventForTest(ui::EventType type, int x, int y, float delta_x,
                       float delta_y)
       : GestureEvent(type, x, y, 0, base::TimeDelta(),
@@ skipping 30 matching lines @@
   }
 
   virtual void TearDown() {
     if (widget_)
       widget_->Close();
     ViewsTestBase::TearDown();
   }
 
   // TextfieldController:
   virtual void ContentsChanged(Textfield* sender,
-                               const string16& new_contents) OVERRIDE {
+                               const base::string16& new_contents) OVERRIDE {
     // Paste calls TextfieldController::ContentsChanged() explicitly even if the
     // paste action did not change the content. So |new_contents| may match
     // |last_contents_|. For more info, see http://crbug.com/79002
     last_contents_ = new_contents;
   }
 
   virtual bool HandleKeyEvent(Textfield* sender,
                               const ui::KeyEvent& key_event) OVERRIDE {
     // TODO(oshima): figure out how to test the keystroke.
     return false;
@@ skipping 83 matching lines @@
           ch == ' ' ? ui::VKEY_SPACE :
           static_cast<ui::KeyboardCode>(ui::VKEY_A + ch - 'a');
       SendKeyEvent(code);
     } else {
       ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, 0, false);
       event.set_character(ch);
       input_method_->DispatchKeyEvent(event);
     }
   }
 
-  string16 GetClipboardText() const {
-    string16 text;
+  base::string16 GetClipboardText() const {
+    base::string16 text;
     ui::Clipboard::GetForCurrentThread()->
         ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &text);
     return text;
   }
 
   void SetClipboardText(const std::string& text) {
     ui::ScopedClipboardWriter clipboard_writer(
         ui::Clipboard::GetForCurrentThread(),
         ui::CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(ASCIIToUTF16(text));
@@ skipping 70 matching lines @@
   }
 
   // We need widget to populate wrapper class.
   Widget* widget_;
 
   TestTextfield* textfield_;
   NativeTextfieldViews* textfield_view_;
   TextfieldViewsModel* model_;
 
   // The string from Controller::ContentsChanged callback.
-  string16 last_contents_;
+  base::string16 last_contents_;
 
   // For testing input method related behaviors.
   MockInputMethod* input_method_;
 
   // Indicates how many times OnBeforeUserAction() is called.
   int on_before_user_action_;
 
   // Indicates how many times OnAfterUserAction() is called.
   int on_after_user_action_;
 
@@ skipping 11 matching lines @@
 
   EXPECT_STR_EQ("this is", model_->GetText());
   EXPECT_STR_EQ("this is", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
 
   textfield_->AppendText(ASCIIToUTF16(" a test"));
   EXPECT_STR_EQ("this is a test", model_->GetText());
   EXPECT_STR_EQ("this is a test", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
 
-  EXPECT_EQ(string16(), textfield_->GetSelectedText());
+  EXPECT_EQ(base::string16(), textfield_->GetSelectedText());
   textfield_->SelectAll(false);
   EXPECT_STR_EQ("this is a test", textfield_->GetSelectedText());
   EXPECT_TRUE(last_contents_.empty());
 }
 
 TEST_F(NativeTextfieldViewsTest, ModelChangesTestLowerCase) {
   // Check if |model_|'s text is properly lowercased for STYLE_LOWERCASE.
   InitTextfield(Textfield::STYLE_LOWERCASE);
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
 
@@ skipping 186 matching lines @@
   SetClipboardText("foo");
 
   // Cut and copy should be disabled.
   EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_view_->ExecuteCommand(IDS_APP_CUT, 0);
   SendKeyEvent(ui::VKEY_X, false, true);
   EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_COPY));
   textfield_view_->ExecuteCommand(IDS_APP_COPY, 0);
   SendKeyEvent(ui::VKEY_C, false, true);
   SendKeyEvent(ui::VKEY_INSERT, false, true);
-  EXPECT_STR_EQ("foo", string16(GetClipboardText()));
+  EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("password", textfield_->text());
   // [Shift]+[Delete] should just delete without copying text to the clipboard.
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_DELETE, true, false);
 
   // Paste should work normally.
   EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_view_->ExecuteCommand(IDS_APP_PASTE, 0);
   SendKeyEvent(ui::VKEY_V, false, true);
   SendKeyEvent(ui::VKEY_INSERT, true, false);
-  EXPECT_STR_EQ("foo", string16(GetClipboardText()));
+  EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("foofoofoo", textfield_->text());
 }
 
 TEST_F(NativeTextfieldViewsTest, InputTypeSetsObscured) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   // Defaults to TEXT
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
 
   // Setting to TEXT_INPUT_TYPE_PASSWORD also sets obscured state of textfield.
@@ skipping 62 matching lines @@
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   SendKeyEvent(ui::VKEY_DOWN);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   // Empty Textfield does not handle left/right.
-  textfield_->SetText(string16());
+  textfield_->SetText(base::string16());
   SendKeyEvent(ui::VKEY_LEFT);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   SendKeyEvent(ui::VKEY_RIGHT);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
@@ skipping 171 matching lines @@
   ui::MouseEvent drag_left(ui::ET_MOUSE_DRAGGED, gfx::Point(), gfx::Point(),
                            ui::EF_LEFT_MOUSE_BUTTON, 0);
   ui::MouseEvent drag_right(ui::ET_MOUSE_DRAGGED, end_point, end_point,
                             ui::EF_LEFT_MOUSE_BUTTON, 0);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, end_point, end_point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   textfield_view_->OnMousePressed(click_a);
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
   // Check that dragging left selects the beginning of the string.
   textfield_view_->OnMouseDragged(drag_left);
-  string16 text_left = textfield_->GetSelectedText();
+  base::string16 text_left = textfield_->GetSelectedText();
   EXPECT_STR_EQ("hello", text_left);
   // Check that dragging right selects the rest of the string.
   textfield_view_->OnMouseDragged(drag_right);
-  string16 text_right = textfield_->GetSelectedText();
+  base::string16 text_right = textfield_->GetSelectedText();
   EXPECT_STR_EQ(" world", text_right);
   // Check that releasing in the same location does not alter the selection.
   textfield_view_->OnMouseReleased(release);
   EXPECT_EQ(text_right, textfield_->GetSelectedText());
   // Check that dragging from beyond the text length works too.
   textfield_view_->OnMousePressed(click_b);
   textfield_view_->OnMouseDragged(drag_left);
   textfield_view_->OnMouseReleased(release);
   EXPECT_EQ(textfield_->text(), textfield_->GetSelectedText());
 }
 
 #if defined(OS_WIN)
 TEST_F(NativeTextfieldViewsTest, DragAndDrop_AcceptDrop) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   ui::OSExchangeData data;
-  string16 string(ASCIIToUTF16("string "));
+  base::string16 string(ASCIIToUTF16("string "));
   data.SetString(string);
   int formats = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Ensure that disabled textfields do not accept drops.
   textfield_->SetEnabled(false);
   EXPECT_FALSE(textfield_view_->GetDropFormats(&formats, &custom_formats));
   EXPECT_EQ(0, formats);
   EXPECT_TRUE(custom_formats.empty());
   EXPECT_FALSE(textfield_view_->CanDrop(data));
@@ skipping 20 matching lines @@
   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, textfield_view_->OnPerformDrop(drop));
   EXPECT_STR_EQ("hello string world", textfield_->text());
 
   // Ensure that textfields do not accept non-OSExchangeData::STRING types.
   ui::OSExchangeData bad_data;
   bad_data.SetFilename(base::FilePath(FILE_PATH_LITERAL("x")));
 #if defined(OS_WIN)
   ui::OSExchangeData::CustomFormat fmt = ui::Clipboard::GetBitmapFormatType();
   bad_data.SetPickledData(fmt, Pickle());
   bad_data.SetFileContents(base::FilePath(L"x"), "x");
-  bad_data.SetHtml(string16(ASCIIToUTF16("x")), GURL("x.org"));
+  bad_data.SetHtml(base::string16(ASCIIToUTF16("x")), GURL("x.org"));
   ui::OSExchangeData::DownloadFileInfo download(base::FilePath(), NULL);
   bad_data.SetDownloadFileInfo(download);
 #endif
   EXPECT_FALSE(textfield_view_->CanDrop(bad_data));
 }
 #endif
 
 TEST_F(NativeTextfieldViewsTest, DragAndDrop_InitiateDrag) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello string world"));
 
   // Ensure the textfield will provide selected text for drag data.
-  string16 string;
+  base::string16 string;
   ui::OSExchangeData data;
   const gfx::Range kStringRange(6, 12);
   textfield_->SelectRange(kStringRange);
   const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
   textfield_view_->WriteDragDataForView(NULL, kStringPoint, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
 
   // Ensure that disabled textfields do not support drag operations.
   textfield_->SetEnabled(false);
@@ skipping 25 matching lines @@
                                                    gfx::Point()));
   // Ensure that textfields support local moves.
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
       textfield_view_->GetDragOperationsForView(textfield_view_, kStringPoint));
 }
 
 TEST_F(NativeTextfieldViewsTest, DragAndDrop_ToTheRight) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
-  string16 string;
+  base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Start dragging "ello".
   textfield_->SelectRange(gfx::Range(1, 5));
   gfx::Point point(GetCursorPositionX(3), 0);
   ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
@@ skipping 34 matching lines @@
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
 }
 
 TEST_F(NativeTextfieldViewsTest, DragAndDrop_ToTheLeft) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
-  string16 string;
+  base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Start dragging " worl".
   textfield_->SelectRange(gfx::Range(5, 10));
   gfx::Point point(GetCursorPositionX(7), 0);
   ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
@@ skipping 88 matching lines @@
   EXPECT_STR_EQ("read ", textfield_->GetSelectedText());
   textfield_->SelectAll(false);
   EXPECT_STR_EQ("read only", textfield_->GetSelectedText());
 
   // Cut should be disabled.
   SetClipboardText("Test");
   EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_view_->ExecuteCommand(IDS_APP_CUT, 0);
   SendKeyEvent(ui::VKEY_X, false, true);
   SendKeyEvent(ui::VKEY_DELETE, true, false);
-  EXPECT_STR_EQ("Test", string16(GetClipboardText()));
+  EXPECT_STR_EQ("Test", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("read only", textfield_->text());
 
   // Paste should be disabled.
   EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_view_->ExecuteCommand(IDS_APP_PASTE, 0);
   SendKeyEvent(ui::VKEY_V, false, true);
   SendKeyEvent(ui::VKEY_INSERT, true, false);
   EXPECT_STR_EQ("read only", textfield_->text());
 
   // Copy should work normally.
   SetClipboardText("Test");
   EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_COPY));
   textfield_view_->ExecuteCommand(IDS_APP_COPY, 0);
-  EXPECT_STR_EQ("read only", string16(GetClipboardText()));
+  EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
   SetClipboardText("Test");
   SendKeyEvent(ui::VKEY_C, false, true);
-  EXPECT_STR_EQ("read only", string16(GetClipboardText()));
+  EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
   SetClipboardText("Test");
   SendKeyEvent(ui::VKEY_INSERT, false, true);
-  EXPECT_STR_EQ("read only", string16(GetClipboardText()));
+  EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
 
   // SetText should work even in read only mode.
   textfield_->SetText(ASCIIToUTF16(" four five six "));
   EXPECT_STR_EQ(" four five six ", textfield_->text());
 
   textfield_->SelectAll(false);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 
   // Text field is unmodifiable and selection shouldn't change.
   SendKeyEvent(ui::VKEY_DELETE);
@@ skipping 16 matching lines @@
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(10U, range.end());
 
   EXPECT_TRUE(client->SetSelectionRange(gfx::Range(1, 4)));
   EXPECT_TRUE(client->GetSelectionRange(&range));
   EXPECT_EQ(gfx::Range(1, 4), range);
 
   // This code can't be compiled because of a bug in base::Callback.
 #if 0
   GetTextHelper helper;
-  base::Callback<void(string16)> callback =
+  base::Callback<void(base::string16)> callback =
       base::Bind(&GetTextHelper::set_text, base::Unretained(&helper));
 
   EXPECT_TRUE(client->GetTextFromRange(range, callback));
   EXPECT_STR_EQ("123", helper.text());
 #endif
 
   EXPECT_TRUE(client->DeleteRange(range));
   EXPECT_STR_EQ("0456789", textfield_->text());
 
   ui::CompositionText composition;
@@ skipping 168 matching lines @@
 }
 
 TEST_F(NativeTextfieldViewsTest, CutCopyPaste) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   // Ensure IDS_APP_CUT cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
   EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_view_->ExecuteCommand(IDS_APP_CUT, 0);
-  EXPECT_STR_EQ("123", string16(GetClipboardText()));
+  EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("", textfield_->text());
 
   // Ensure [Ctrl]+[x] cuts and [Ctrl]+[Alt][x] does nothing.
   textfield_->SetText(ASCIIToUTF16("456"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_X, true, false, true, false);
-  EXPECT_STR_EQ("123", string16(GetClipboardText()));
+  EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("456", textfield_->text());
   SendKeyEvent(ui::VKEY_X, false, true);
-  EXPECT_STR_EQ("456", string16(GetClipboardText()));
+  EXPECT_STR_EQ("456", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("", textfield_->text());
 
   // Ensure [Shift]+[Delete] cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_DELETE, true, false);
-  EXPECT_STR_EQ("123", string16(GetClipboardText()));
+  EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("", textfield_->text());
 
   // Ensure IDS_APP_COPY copies.
   textfield_->SetText(ASCIIToUTF16("789"));
   textfield_->SelectAll(false);
   EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_COPY));
   textfield_view_->ExecuteCommand(IDS_APP_COPY, 0);
-  EXPECT_STR_EQ("789", string16(GetClipboardText()));
+  EXPECT_STR_EQ("789", base::string16(GetClipboardText()));
 
   // Ensure [Ctrl]+[c] copies and [Ctrl]+[Alt][c] does nothing.
   textfield_->SetText(ASCIIToUTF16("012"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_C, true, false, true, false);
-  EXPECT_STR_EQ("789", string16(GetClipboardText()));
+  EXPECT_STR_EQ("789", base::string16(GetClipboardText()));
   SendKeyEvent(ui::VKEY_C, false, true);
-  EXPECT_STR_EQ("012", string16(GetClipboardText()));
+  EXPECT_STR_EQ("012", base::string16(GetClipboardText()));
 
   // Ensure [Ctrl]+[Insert] copies.
   textfield_->SetText(ASCIIToUTF16("345"));
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_INSERT, false, true);
-  EXPECT_STR_EQ("345", string16(GetClipboardText()));
+  EXPECT_STR_EQ("345", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("345", textfield_->text());
 
   // Ensure IDS_APP_PASTE, [Ctrl]+[V], and [Shift]+[Insert] pastes;
   // also ensure that [Ctrl]+[Alt]+[V] does nothing.
   SetClipboardText("abc");
-  textfield_->SetText(string16());
+  textfield_->SetText(base::string16());
   EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_view_->ExecuteCommand(IDS_APP_PASTE, 0);
   EXPECT_STR_EQ("abc", textfield_->text());
   SendKeyEvent(ui::VKEY_V, false, true);
   EXPECT_STR_EQ("abcabc", textfield_->text());
   SendKeyEvent(ui::VKEY_INSERT, true, false);
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
   SendKeyEvent(ui::VKEY_V, true, false, true, false);
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
 
   // Ensure [Ctrl]+[Shift]+[Insert] is a no-op.
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_INSERT, true, true);
-  EXPECT_STR_EQ("abc", string16(GetClipboardText()));
+  EXPECT_STR_EQ("abc", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
 }
 
 TEST_F(NativeTextfieldViewsTest, OvertypeMode) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   // Overtype mode should be disabled (no-op [Insert]).
   textfield_->SetText(ASCIIToUTF16("2"));
   SendKeyEvent(ui::VKEY_HOME);
   SendKeyEvent(ui::VKEY_INSERT);
   SendKeyEvent(ui::VKEY_1, false, false);
@@ skipping 229 matching lines @@
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(NativeTextfieldViewsTest, OverflowTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
-  string16 str;
+  base::string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   // Test mouse pointing.
   MouseClick(GetCursorBounds(), -1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
   SendKeyEvent('\n');
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), -1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 }
 
 TEST_F(NativeTextfieldViewsTest, OverflowInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   InitTextfield(Textfield::STYLE_DEFAULT);
 
-  string16 str;
+  base::string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), 1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
   SendKeyEvent('\n');
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), 1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(NativeTextfieldViewsTest, GetCompositionCharacterBoundsTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
-  string16 str;
+  base::string16 str;
   const uint32 char_count = 10UL;
   ui::CompositionText composition;
   composition.text = UTF8ToUTF16("0123456789");
   ui::TextInputClient* client = textfield_->GetTextInputClient();
 
   // Return false if there is no composition text.
   gfx::Rect rect;
   EXPECT_FALSE(client->GetCompositionCharacterBounds(0, &rect));
 
   // Get each character boundary by cursor.
@@ skipping 213 matching lines @@
   // Set text which may fall back to a font which has taller baseline than
   // the default font.
   textfield_->SetText(UTF8ToUTF16("\xE0\xB9\x91"));
   const int new_baseline = textfield_->GetBaseline();
 
   // Regardless of the text, the baseline must be the same.
   EXPECT_EQ(new_baseline, old_baseline);
 }
 
 }  // namespace views