ui/gfx: Use base::string16 now that string16 was moved into base namespace.

ui/gfx/render_text_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/gfx/render_text.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/break_list.h"
@@ skipping 175 matching lines @@
   rt_linux->EnsureLayout();
   PangoAttrList* attributes = pango_layout_get_attributes(rt_linux->layout_);
   PangoAttrIterator* iter = pango_attr_list_get_iterator(attributes);
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     pango_attr_iterator_range(iter, &start, &end);
     EXPECT_EQ(cases[i].start, start);
     EXPECT_EQ(cases[i].end, end);
     PangoFontDescription* font = pango_font_description_new();
     pango_attr_iterator_get_font(iter, font, NULL, NULL);
     char* description_string = pango_font_description_to_string(font);
-    const string16 desc = ASCIIToUTF16(description_string);
+    const base::string16 desc = ASCIIToUTF16(description_string);
     const bool bold = desc.find(ASCIIToUTF16("Bold")) != std::string::npos;
     EXPECT_EQ(cases[i].bold, bold);
     const bool italic = desc.find(ASCIIToUTF16("Italic")) != std::string::npos;
     EXPECT_EQ(cases[i].italic, italic);
     pango_attr_iterator_next(iter);
     pango_font_description_free(font);
     g_free(description_string);
   }
   EXPECT_FALSE(pango_attr_iterator_next(iter));
   pango_attr_iterator_destroy(iter);
 }
 #endif
 
 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
 //                  does not implement this yet. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 void TestVisualCursorMotionInObscuredField(RenderText* render_text,
-                                           const string16& text,
+                                           const base::string16& text,
                                            bool select) {
   ASSERT_TRUE(render_text->obscured());
   render_text->SetText(text);
   int len = text.length();
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
   EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, select);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
   for (int j = 1; j <= len; ++j) {
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, select);
     EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : j, j), CURSOR_BACKWARD),
               render_text->selection_model());
   }
   for (int j = len - 1; j >= 0; --j) {
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, select);
     EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : j, j), CURSOR_FORWARD),
               render_text->selection_model());
   }
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, select);
   EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, select);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 }
 
 TEST_F(RenderTextTest, ObscuredText) {
-  const string16 seuss = ASCIIToUTF16("hop on pop");
-  const string16 no_seuss = ASCIIToUTF16("**********");
+  const base::string16 seuss = ASCIIToUTF16("hop on pop");
+  const base::string16 no_seuss = ASCIIToUTF16("**********");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   // GetLayoutText() returns asterisks when the obscured bit is set.
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
   render_text->SetObscured(false);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(seuss, render_text->GetLayoutText());
@@ skipping 34 matching lines @@
   EXPECT_EQ(render_text->GetStringSize().width(),
             static_cast<int>(render_text->GetGlyphBounds(0U).length()));
 
   // Cursoring is independent of underlying characters when text is obscured.
   const wchar_t* const texts[] = {
     kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl,
     L"hop on pop",                              // Check LTR word boundaries.
     L"\x05d0\x05d1 \x05d0\x05d2 \x05d1\x05d2",  // Check RTL word boundaries.
   };
   for (size_t i = 0; i < arraysize(texts); ++i) {
-    string16 text = WideToUTF16(texts[i]);
+    base::string16 text = WideToUTF16(texts[i]);
     TestVisualCursorMotionInObscuredField(render_text.get(), text, false);
     TestVisualCursorMotionInObscuredField(render_text.get(), text, true);
   }
 }
 
 TEST_F(RenderTextTest, RevealObscuredText) {
-  const string16 seuss = ASCIIToUTF16("hop on pop");
-  const string16 no_seuss = ASCIIToUTF16("**********");
+  const base::string16 seuss = ASCIIToUTF16("hop on pop");
+  const base::string16 no_seuss = ASCIIToUTF16("**********");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
 
   // Valid reveal index and new revealed index clears previous one.
   render_text->RenderText::SetObscuredRevealIndex(0);
   EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
@@ skipping 292 matching lines @@
   EXPECT_EQ(2U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
   EXPECT_EQ(0U, render_text->cursor_position());
 }
 #endif
 
 TEST_F(RenderTextTest, GraphemePositions) {
   // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
-  const string16 kText1 = WideToUTF16(L"\x0915\x093f"L"abc"L"\x0915\x093f");
+  const base::string16 kText1 =
+      WideToUTF16(L"\x0915\x093f"L"abc"L"\x0915\x093f");
 
   // LTR ab, LTR 2-character grapheme, LTR cd.
-  const string16 kText2 = WideToUTF16(L"ab"L"\x0915\x093f"L"cd");
+  const base::string16 kText2 = WideToUTF16(L"ab"L"\x0915\x093f"L"cd");
 
   // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
   // two characters forming the surrogate pair 0x0001D11E.
   const std::string kSurrogate = "\xF0\x9D\x84\x9E";
 
   // LTR ab, UTF16 surrogate pair, LTR cd.
-  const string16 kText3 = UTF8ToUTF16("ab" + kSurrogate + "cd");
+  const base::string16 kText3 = UTF8ToUTF16("ab" + kSurrogate + "cd");
 
   struct {
-    string16 text;
+    base::string16 text;
     size_t index;
     size_t expected_previous;
     size_t expected_next;
   } cases[] = {
-    { string16(), 0, 0, 0 },
-    { string16(), 1, 0, 0 },
-    { string16(), 50, 0, 0 },
+    { base::string16(), 0, 0, 0 },
+    { base::string16(), 1, 0, 0 },
+    { base::string16(), 50, 0, 0 },
     { kText1, 0, 0, 2 },
     { kText1, 1, 0, 2 },
     { kText1, 2, 0, 3 },
     { kText1, 3, 2, 4 },
     { kText1, 4, 3, 5 },
     { kText1, 5, 4, 7 },
     { kText1, 6, 5, 7 },
     { kText1, 7, 5, 7 },
     { kText1, 8, 7, 7 },
     { kText1, 50, 7, 7 },
@@ skipping 35 matching lines @@
 
     size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
                                                            CURSOR_BACKWARD);
     EXPECT_EQ(cases[i].expected_previous, previous);
     EXPECT_TRUE(render_text->IsCursorablePosition(previous));
   }
 }
 
 TEST_F(RenderTextTest, EdgeSelectionModels) {
   // Simple Latin text.
-  const string16 kLatin = WideToUTF16(L"abc");
+  const base::string16 kLatin = WideToUTF16(L"abc");
   // LTR 2-character grapheme.
-  const string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
+  const base::string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
   // LTR 2-character grapheme, LTR a, LTR 2-character grapheme.
-  const string16 kHindiLatin = WideToUTF16(L"\x0915\x093f"L"a"L"\x0915\x093f");
+  const base::string16 kHindiLatin =
+      WideToUTF16(L"\x0915\x093f"L"a"L"\x0915\x093f");
   // RTL 2-character grapheme.
-  const string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
+  const base::string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
   // RTL 2-character grapheme, LTR a, RTL 2-character grapheme.
-  const string16 kHebrewLatin = WideToUTF16(L"\x05e0\x05b8"L"a"L"\x05e0\x05b8");
+  const base::string16 kHebrewLatin =
+      WideToUTF16(L"\x05e0\x05b8"L"a"L"\x05e0\x05b8");
 
   struct {
-    string16 text;
+    base::string16 text;
     base::i18n::TextDirection expected_text_direction;
   } cases[] = {
-    { string16(),   base::i18n::LEFT_TO_RIGHT },
+    { base::string16(), base::i18n::LEFT_TO_RIGHT },
     { kLatin,       base::i18n::LEFT_TO_RIGHT },
     { kLTRGrapheme, base::i18n::LEFT_TO_RIGHT },
     { kHindiLatin,  base::i18n::LEFT_TO_RIGHT },
     { kRTLGrapheme, base::i18n::RIGHT_TO_LEFT },
     { kHebrewLatin, base::i18n::RIGHT_TO_LEFT },
   };
 
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
 #if defined(OS_WIN)
@@ skipping 23 matching lines @@
   // Ensure that SelectAll respects the |reversed| argument regardless of
   // application locale and text content directionality.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   const SelectionModel expected_reversed(ui::Range(3, 0), CURSOR_FORWARD);
   const SelectionModel expected_forwards(ui::Range(0, 3), CURSOR_BACKWARD);
   const bool was_rtl = base::i18n::IsRTL();
 
   for (size_t i = 0; i < 2; ++i) {
     SetRTL(!base::i18n::IsRTL());
     // Test that an empty string produces an empty selection model.
-    render_text->SetText(string16());
+    render_text->SetText(base::string16());
     EXPECT_EQ(render_text->selection_model(), SelectionModel());
 
     // Test the weak, LTR, RTL, and Bidi string cases.
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases); j++) {
       render_text->SetText(WideToUTF16(cases[j]));
       render_text->SelectAll(false);
       EXPECT_EQ(render_text->selection_model(), expected_forwards);
       render_text->SelectAll(true);
       EXPECT_EQ(render_text->selection_model(), expected_reversed);
     }
@@ skipping 214 matching lines @@
 }
 
 // TODO(asvitkine): This test fails because PlatformFontMac uses point font
 //                  sizes instead of pixel sizes like other implementations.
 #if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, StringSizeEmptyString) {
   const Font font;
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFont(font);
 
-  render_text->SetText(string16());
+  render_text->SetText(base::string16());
   EXPECT_EQ(font.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(0, render_text->GetStringSize().width());
 
   render_text->SetText(UTF8ToUTF16(" "));
   EXPECT_EQ(font.GetHeight(), render_text->GetStringSize().height());
 }
 #endif  // !defined(OS_MACOSX)
 
 TEST_F(RenderTextTest, SetFont) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
@@ skipping 15 matching lines @@
   EXPECT_GT(bold_width, plain_width);
 
   // Now, apply a plain style over the first word only.
   render_text->ApplyStyle(gfx::BOLD, false, ui::Range(0, 5));
   const int plain_bold_width = render_text->GetStringSize().width();
   EXPECT_GT(plain_bold_width, plain_width);
   EXPECT_LT(plain_bold_width, bold_width);
 }
 
 TEST_F(RenderTextTest, StringSizeHeight) {
-  string16 cases[] = {
+  base::string16 cases[] = {
     WideToUTF16(L"Hello World!"),  // English
     WideToUTF16(L"\x6328\x62f6"),  // Japanese
     WideToUTF16(L"\x0915\x093f"),  // Hindi
     WideToUTF16(L"\x05e0\x05b8"),  // Hebrew
   };
 
   Font default_font;
   Font larger_font = default_font.DeriveFont(24, default_font.GetStyle());
   EXPECT_GT(larger_font.GetHeight(), default_font.GetHeight());
 
@@ skipping 107 matching lines @@
 TEST_F(RenderTextTest, SameFontForParentheses) {
   struct {
     const char16 left_char;
     const char16 right_char;
   } punctuation_pairs[] = {
     { '(', ')' },
     { '{', '}' },
     { '<', '>' },
   };
   struct {
-    string16 text;
+    base::string16 text;
   } cases[] = {
     // English(English)
     { WideToUTF16(L"Hello World(a)") },
     // English(English)English
     { WideToUTF16(L"Hello World(a)Hello World") },
 
     // Japanese(English)
     { WideToUTF16(L"\x6328\x62f6(a)") },
     // Japanese(English)Japanese
     { WideToUTF16(L"\x6328\x62f6(a)\x6328\x62f6") },
@@ skipping 10 matching lines @@
     // Hebrew(English)
     { WideToUTF16(L"\x05e0\x05b8(a)") },
     // Hebrew(English)Hebrew
     { WideToUTF16(L"\x05e0\x05b8(a)\x05e0\x05b8") },
     // English(Hebrew)English
     { WideToUTF16(L"Hello World(\x05e0\x05b8)Hello World") },
   };
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
-    string16 text = cases[i].text;
+    base::string16 text = cases[i].text;
     const size_t start_paren_char_index = text.find('(');
-    ASSERT_NE(string16::npos, start_paren_char_index);
+    ASSERT_NE(base::string16::npos, start_paren_char_index);
     const size_t end_paren_char_index = text.find(')');
-    ASSERT_NE(string16::npos, end_paren_char_index);
+    ASSERT_NE(base::string16::npos, end_paren_char_index);
 
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(punctuation_pairs); ++j) {
       text[start_paren_char_index] = punctuation_pairs[j].left_char;
       text[end_paren_char_index] = punctuation_pairs[j].right_char;
       render_text->SetText(text);
 
       const std::vector<RenderText::FontSpan> spans =
           render_text->GetFontSpansForTesting();
 
       int start_paren_span_index = -1;
@@ skipping 180 matching lines @@
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Reset the application default text direction to LTR.
   SetRTL(was_rtl);
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 }
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace gfx