Convert string16 to base::string16 in content.

content/renderer/render_view_browsertest.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 "base/basictypes.h"
 
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
@@ skipping 126 matching lines @@
   }
 
   RenderViewImpl* view() {
     return static_cast<RenderViewImpl*>(view_);
   }
 
   // Sends IPC messages that emulates a key-press event.
   int SendKeyEvent(MockKeyboard::Layout layout,
                    int key_code,
                    MockKeyboard::Modifiers modifiers,
-                   string16* output) {
+                   base::string16* output) {
 #if defined(OS_WIN)
     // Retrieve the Unicode character for the given tuple (keyboard-layout,
     // key-code, and modifiers).
     // Exit when a keyboard-layout driver cannot assign a Unicode character to
     // the tuple to prevent sending an invalid key code to the RenderView
     // object.
     CHECK(mock_keyboard_.get());
     CHECK(output);
     int length = mock_keyboard_->GetCharacters(layout, key_code, modifiers,
                                                output);
@@ skipping 887 matching lines @@
 
       case IME_CONFIRMCOMPOSITION:
         view()->OnImeConfirmComposition(
             WideToUTF16Hack(ime_message->ime_string),
             gfx::Range::InvalidRange(),
             false);
         break;
 
       case IME_CANCELCOMPOSITION:
         view()->OnImeSetComposition(
-            string16(),
+            base::string16(),
             std::vector<blink::WebCompositionUnderline>(),
             0, 0);
         break;
     }
 
     // Update the status of our IME back-end.
     // TODO(hbono): we should verify messages to be sent from the back-end.
     view()->UpdateTextInputType();
     ProcessPendingMessages();
     render_thread_->sink().ClearMessages();
@@ skipping 167 matching lines @@
 #endif
       };
 
       MockKeyboard::Modifiers modifiers = kModifierData[j].modifiers;
       for (size_t k = 0; k < ARRAYSIZE_UNSAFE(kKeyCodes); ++k) {
         // Send a keyboard event to the RenderView object.
         // We should test a keyboard event only when the given keyboard-layout
         // driver is installed in a PC and the driver can assign a Unicode
         // charcter for the given tuple (key-code and modifiers).
         int key_code = kKeyCodes[k];
-        string16 char_code;
+        base::string16 char_code;
         if (SendKeyEvent(layout, key_code, modifiers, &char_code) < 0)
           continue;
 
         // Create an expected result from the virtual-key code, the character
         // code, and the modifier-key status.
         // We format a string that emulates a DOM-event string produced hy
         // our JavaScript function. (See the above comment for the format.)
         static char expected_result[1024];
         expected_result[0] = 0;
         base::snprintf(&expected_result[0],
@@ skipping 226 matching lines @@
 #endif
       };
 
       MockKeyboard::Modifiers modifiers = kModifiers[j];
       for (size_t k = 0; k < ARRAYSIZE_UNSAFE(kKeyCodes); ++k) {
         // Send a keyboard event to the RenderView object.
         // We should test a keyboard event only when the given keyboard-layout
         // driver is installed in a PC and the driver can assign a Unicode
         // charcter for the given tuple (layout, key-code, and modifiers).
         int key_code = kKeyCodes[k];
-        string16 char_code;
+        base::string16 char_code;
         if (SendKeyEvent(layout, key_code, modifiers, &char_code) < 0)
           continue;
       }
     }
 
     // Retrieve the text in the test page and compare it with the expected
     // text created from a virtual-key code, a character code, and the
     // modifier-key status.
     const int kMaxOutputCharacters = 4096;
     std::wstring output = UTF16ToWideHack(
@@ skipping 237 matching lines @@
   SendWebMouseEvent(mouse_event);
 
   EXPECT_TRUE(render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_ContextMenu::ID));
 }
 
 TEST_F(RenderViewImplTest, TestBackForward) {
   LoadHTML("<div id=pagename>Page A</div>");
   blink::WebHistoryItem page_a_item = GetMainFrame()->currentHistoryItem();
   int was_page_a = -1;
-  string16 check_page_a =
+  base::string16 check_page_a =
       ASCIIToUTF16(
           "Number(document.getElementById('pagename').innerHTML == 'Page A')");
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_a, &was_page_a));
   EXPECT_EQ(1, was_page_a);
 
   LoadHTML("<div id=pagename>Page B</div>");
   int was_page_b = -1;
-  string16 check_page_b =
+  base::string16 check_page_b =
       ASCIIToUTF16(
           "Number(document.getElementById('pagename').innerHTML == 'Page B')");
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
   EXPECT_EQ(1, was_page_b);
 
   LoadHTML("<div id=pagename>Page C</div>");
   int was_page_c = -1;
-  string16 check_page_c =
+  base::string16 check_page_c =
       ASCIIToUTF16(
           "Number(document.getElementById('pagename').innerHTML == 'Page C')");
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_c, &was_page_c));
   EXPECT_EQ(1, was_page_b);
 
   blink::WebHistoryItem forward_item = GetMainFrame()->currentHistoryItem();
   GoBack(GetMainFrame()->previousHistoryItem());
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
   EXPECT_EQ(1, was_page_b);
 
@@ skipping 20 matching lines @@
 
 #if defined(OS_WIN)
   // http://crbug.com/304193
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   LoadHTML("<textarea id=\"test\"></textarea>");
   ExecuteJavaScript("document.getElementById('test').focus();");
 
-  const string16 empty_string = UTF8ToUTF16("");
+  const base::string16 empty_string = UTF8ToUTF16("");
   const std::vector<blink::WebCompositionUnderline> empty_underline;
   std::vector<gfx::Rect> bounds;
   view()->OnSetFocus(true);
   view()->OnSetInputMethodActive(true);
 
   // ASCII composition
-  const string16 ascii_composition = UTF8ToUTF16("aiueo");
+  const base::string16 ascii_composition = UTF8ToUTF16("aiueo");
   view()->OnImeSetComposition(ascii_composition, empty_underline, 0, 0);
   view()->GetCompositionCharacterBounds(&bounds);
   ASSERT_EQ(ascii_composition.size(), bounds.size());
   for (size_t i = 0; i < bounds.size(); ++i)
     EXPECT_LT(0, bounds[i].width());
   view()->OnImeConfirmComposition(
       empty_string, gfx::Range::InvalidRange(), false);
 
   // Non surrogate pair unicode character.
-  const string16 unicode_composition = UTF8ToUTF16(
+  const base::string16 unicode_composition = UTF8ToUTF16(
       "\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86\xE3\x81\x88\xE3\x81\x8A");
   view()->OnImeSetComposition(unicode_composition, empty_underline, 0, 0);
   view()->GetCompositionCharacterBounds(&bounds);
   ASSERT_EQ(unicode_composition.size(), bounds.size());
   for (size_t i = 0; i < bounds.size(); ++i)
     EXPECT_LT(0, bounds[i].width());
   view()->OnImeConfirmComposition(
       empty_string, gfx::Range::InvalidRange(), false);
 
   // Surrogate pair character.
-  const string16 surrogate_pair_char = UTF8ToUTF16("\xF0\xA0\xAE\x9F");
+  const base::string16 surrogate_pair_char = UTF8ToUTF16("\xF0\xA0\xAE\x9F");
   view()->OnImeSetComposition(surrogate_pair_char,
                               empty_underline,
                               0,
                               0);
   view()->GetCompositionCharacterBounds(&bounds);
   ASSERT_EQ(surrogate_pair_char.size(), bounds.size());
   EXPECT_LT(0, bounds[0].width());
   EXPECT_EQ(0, bounds[1].width());
   view()->OnImeConfirmComposition(
       empty_string, gfx::Range::InvalidRange(), false);
 
   // Mixed string.
-  const string16 surrogate_pair_mixed_composition =
+  const base::string16 surrogate_pair_mixed_composition =
       surrogate_pair_char + UTF8ToUTF16("\xE3\x81\x82") + surrogate_pair_char +
       UTF8ToUTF16("b") + surrogate_pair_char;
   const size_t utf16_length = 8UL;
   const bool is_surrogate_pair_empty_rect[8] = {
     false, true, false, false, true, false, false, true };
   view()->OnImeSetComposition(surrogate_pair_mixed_composition,
                               empty_underline,
                               0,
                               0);
   view()->GetCompositionCharacterBounds(&bounds);
@@ skipping 181 matching lines @@
     virtual bool ShouldSuppressErrorPage(const GURL& url) OVERRIDE {
       return url == GURL("http://example.com/suppress");
     }
 
     virtual void GetNavigationErrorStrings(
         blink::WebFrame* frame,
         const blink::WebURLRequest& failed_request,
         const blink::WebURLError& error,
         const std::string& accept_languages,
         std::string* error_html,
-        string16* error_description) OVERRIDE {
+        base::string16* error_description) OVERRIDE {
       if (error_html)
         *error_html = "A suffusion of yellow.";
     }
   };
 
   TestContentRendererClient client_;
 };
 
 #if defined(OS_ANDROID)
 // Crashing on Android: http://crbug.com/311341
@@ skipping 85 matching lines @@
   view()->OnCandidateWindowHidden();
 
   // Retrieve the content and check if it is expected.
   const int kMaxOutputCharacters = 50;
   std::string output = UTF16ToUTF8(
       GetMainFrame()->contentAsText(kMaxOutputCharacters));
   EXPECT_EQ(output, "\nResult:showupdatehide");
 }
 
 }  // namespace content