Add base:: to string16s in chrome/.

chrome/test/chromedriver/key_converter_unittest.cc

 // Copyright (c) 2013 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 <list>
 #include <string>
 
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/ui_events.h"
 #include "chrome/test/chromedriver/key_converter.h"
 #include "chrome/test/chromedriver/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-void CheckEvents(const string16& keys,
+void CheckEvents(const base::string16& keys,
                  KeyEvent expected_events[],
                  bool release_modifiers,
                  size_t expected_size,
                  int expected_modifiers) {
   int modifiers = 0;
   std::list<KeyEvent> events;
   EXPECT_EQ(kOk, ConvertKeysToKeyEvents(keys, release_modifiers,
                                         &modifiers, &events).code());
   EXPECT_EQ(expected_size, events.size());
   size_t i = 0;
   std::list<KeyEvent>::const_iterator it = events.begin();
   while (i < expected_size && it != events.end()) {
     EXPECT_EQ(expected_events[i].type, it->type);
     EXPECT_EQ(expected_events[i].modifiers, it->modifiers);
     EXPECT_EQ(expected_events[i].modified_text, it->modified_text);
     EXPECT_EQ(expected_events[i].unmodified_text, it->unmodified_text);
     EXPECT_EQ(expected_events[i].key_code, it->key_code);
 
     ++i;
     ++it;
   }
   EXPECT_EQ(expected_modifiers, modifiers);
 }
 
-void CheckEventsReleaseModifiers(const string16& keys,
+void CheckEventsReleaseModifiers(const base::string16& keys,
                                  KeyEvent expected_events[],
                                  size_t expected_size) {
   CheckEvents(keys, expected_events, true /* release_modifier */,
       expected_size, 0 /* expected_modifiers */);
 }
 
 void CheckEventsReleaseModifiers(const std::string& keys,
                                  KeyEvent expected_events[],
                                  size_t expected_size) {
   CheckEventsReleaseModifiers(UTF8ToUTF16(keys),
@@ skipping 74 matching lines @@
       CreateCharEvent("y", "y", 0),
       CreateKeyUpEvent(ui::VKEY_Y, 0)};
   CheckEventsReleaseModifiers("hey", event_array, arraysize(event_array));
 }
 
 TEST(KeyConverter, WebDriverSpecialChar) {
   KeyEvent event_array[] = {
       CreateKeyDownEvent(ui::VKEY_SPACE, 0),
       CreateCharEvent(" ", " ", 0),
       CreateKeyUpEvent(ui::VKEY_SPACE, 0)};
-  string16 keys;
+  base::string16 keys;
   keys.push_back(static_cast<char16>(0xE00DU));
   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 }
 
 TEST(KeyConverter, WebDriverSpecialNonCharKey) {
   KeyEvent event_array[] = {
       CreateKeyDownEvent(ui::VKEY_F1, 0),
       CreateKeyUpEvent(ui::VKEY_F1, 0)};
-  string16 keys;
+  base::string16 keys;
   keys.push_back(static_cast<char16>(0xE031U));
   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 }
 
 TEST(KeyConverter, FrenchKeyOnEnglishLayout) {
   KeyEvent event_array[] = {
       CreateKeyDownEvent(ui::VKEY_UNKNOWN, 0),
       CreateCharEvent(WideToUTF8(L"\u00E9"), WideToUTF8(L"\u00E9"), 0),
       CreateKeyUpEvent(ui::VKEY_UNKNOWN, 0)};
   CheckEventsReleaseModifiers(WideToUTF16(L"\u00E9"),
@@ skipping 43 matching lines @@
       CreateKeyDownEvent(ui::VKEY_A, kShiftKeyModifierMask),
       CreateCharEvent("a", "A", kShiftKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_A, kShiftKeyModifierMask),
       CreateKeyDownEvent(ui::VKEY_B, kShiftKeyModifierMask),
       CreateCharEvent("b", "B", kShiftKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_B, kShiftKeyModifierMask),
       CreateKeyDownEvent(ui::VKEY_C, kShiftKeyModifierMask),
       CreateCharEvent("c", "C", kShiftKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_C, kShiftKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_SHIFT, 0)};
-  string16 keys;
+  base::string16 keys;
   keys.push_back(static_cast<char16>(0xE008U));
   keys.append(UTF8ToUTF16("aBc"));
   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 }
 
 TEST(KeyConverter, ToggleModifiers) {
   KeyEvent event_array[] = {
       CreateKeyDownEvent(ui::VKEY_SHIFT, kShiftKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_SHIFT, 0),
       CreateKeyDownEvent(ui::VKEY_CONTROL, kControlKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_CONTROL, 0),
       CreateKeyDownEvent(ui::VKEY_MENU, kAltKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_MENU, 0),
       CreateKeyDownEvent(ui::VKEY_COMMAND, kMetaKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_COMMAND, 0)};
-  string16 keys;
+  base::string16 keys;
   keys.push_back(static_cast<char16>(0xE008U));
   keys.push_back(static_cast<char16>(0xE008U));
   keys.push_back(static_cast<char16>(0xE009U));
   keys.push_back(static_cast<char16>(0xE009U));
   keys.push_back(static_cast<char16>(0xE00AU));
   keys.push_back(static_cast<char16>(0xE00AU));
   keys.push_back(static_cast<char16>(0xE03DU));
   keys.push_back(static_cast<char16>(0xE03DU));
   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 }
@@ skipping 31 matching lines @@
 }
 
 #if defined(OS_LINUX)
 // Fails on bots: crbug.com/174962
 #define MAYBE_AllEnglishKeyboardSymbols DISABLED_AllEnglishKeyboardSymbols
 #else
 #define MAYBE_AllEnglishKeyboardSymbols AllEnglishKeyboardSymbols
 #endif
 
 TEST(KeyConverter, MAYBE_AllEnglishKeyboardSymbols) {
-  string16 keys;
+  base::string16 keys;
   const ui::KeyboardCode kSymbolKeyCodes[] = {
       ui::VKEY_OEM_3,
       ui::VKEY_OEM_MINUS,
       ui::VKEY_OEM_PLUS,
       ui::VKEY_OEM_4,
       ui::VKEY_OEM_6,
       ui::VKEY_OEM_5,
       ui::VKEY_OEM_1,
       ui::VKEY_OEM_7,
       ui::VKEY_OEM_COMMA,
@@ skipping 47 matching lines @@
       ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x7F, ';', '=',
 #else
       0, 0, 0, 0, 0, 0, '\r', '\r', 0, 0, 0, 0, 0,
       ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ';', '=',
 #endif
       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
       '*', '+', ',', '-', '.', '/'};
   for (size_t i = 0; i <= 0x3D; ++i) {
     if (i > 0x29 && i < 0x31)
       continue;
-    string16 keys;
+    base::string16 keys;
     int modifiers = 0;
     keys.push_back(0xE000U + i);
     std::list<KeyEvent> events;
     if (i == 1) {
       EXPECT_NE(kOk, ConvertKeysToKeyEvents(keys,
                                             true /* release_modifiers*/,
                                             &modifiers, &events).code())
           << "Index: " << i;
       EXPECT_EQ(0u, events.size()) << "Index: " << i;
     } else {
@@ skipping 20 matching lines @@
 TEST(KeyConverter, ModifiersState) {
   int shift_key_modifier = kShiftKeyModifierMask;
   int control_key_modifier = shift_key_modifier | kControlKeyModifierMask;
   int alt_key_modifier = control_key_modifier | kAltKeyModifierMask;
   int meta_key_modifier = alt_key_modifier | kMetaKeyModifierMask;
   KeyEvent event_array[] = {
       CreateKeyDownEvent(ui::VKEY_SHIFT, shift_key_modifier),
       CreateKeyDownEvent(ui::VKEY_CONTROL, control_key_modifier),
       CreateKeyDownEvent(ui::VKEY_MENU, alt_key_modifier),
       CreateKeyDownEvent(ui::VKEY_COMMAND, meta_key_modifier)};
-  string16 keys;
+  base::string16 keys;
   keys.push_back(static_cast<char16>(0xE008U));
   keys.push_back(static_cast<char16>(0xE009U));
   keys.push_back(static_cast<char16>(0xE00AU));
   keys.push_back(static_cast<char16>(0xE03DU));
 
   CheckEvents(keys, event_array, false /* release_modifiers */,
       arraysize(event_array), meta_key_modifier);
 }
 
 TEST(KeyConverter, ReleaseModifiers) {
   KeyEvent event_array[] = {
       CreateKeyDownEvent(ui::VKEY_SHIFT, kShiftKeyModifierMask),
       CreateKeyDownEvent(ui::VKEY_CONTROL,
           kShiftKeyModifierMask | kControlKeyModifierMask),
       CreateKeyUpEvent(ui::VKEY_SHIFT, 0),
       CreateKeyUpEvent(ui::VKEY_CONTROL, 0)};
-  string16 keys;
+  base::string16 keys;
   keys.push_back(static_cast<char16>(0xE008U));
   keys.push_back(static_cast<char16>(0xE009U));
 
   CheckEvents(keys, event_array, true /* release_modifiers */,
       arraysize(event_array), 0);
 }