Update some uses of char16 to use the base:: namespace.

chrome/test/chromedriver/key_converter.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 "chrome/test/chromedriver/key_converter.h"
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/chromedriver/chrome/status.h"
@@ skipping 73 matching lines @@
     ui::VKEY_F4,
     ui::VKEY_F5,
     ui::VKEY_F6,
     ui::VKEY_F7,
     ui::VKEY_F8,
     ui::VKEY_F9,
     ui::VKEY_F10,
     ui::VKEY_F11,
     ui::VKEY_F12};
 
-const char16 kWebDriverNullKey = 0xE000U;
-const char16 kWebDriverShiftKey = 0xE008U;
-const char16 kWebDriverControlKey = 0xE009U;
-const char16 kWebDriverAltKey = 0xE00AU;
-const char16 kWebDriverCommandKey = 0xE03DU;
+const base::char16 kWebDriverNullKey = 0xE000U;
+const base::char16 kWebDriverShiftKey = 0xE008U;
+const base::char16 kWebDriverControlKey = 0xE009U;
+const base::char16 kWebDriverAltKey = 0xE00AU;
+const base::char16 kWebDriverCommandKey = 0xE03DU;
 
 // Returns whether the given key code has a corresponding printable char.
 // Notice: The given key code should be a special WebDriver key code.
 bool IsSpecialKeyPrintable(ui::KeyboardCode key_code) {
   return key_code == ui::VKEY_TAB || key_code == ui::VKEY_SPACE ||
       key_code == ui::VKEY_OEM_1 || key_code == ui::VKEY_OEM_PLUS ||
       key_code == ui::VKEY_OEM_COMMA ||
       (key_code >= ui::VKEY_NUMPAD0 && key_code <= ui::VKEY_DIVIDE);
 }
 
 // Returns whether the given key is a WebDriver key modifier.
-bool IsModifierKey(char16 key) {
+bool IsModifierKey(base::char16 key) {
   switch (key) {
     case kWebDriverShiftKey:
     case kWebDriverControlKey:
     case kWebDriverAltKey:
     case kWebDriverCommandKey:
       return true;
     default:
       return false;
   }
 }
 
 // Gets the key code associated with |key|, if it is a special WebDriver key.
 // Returns whether |key| is a special WebDriver key. If true, |key_code| will
 // be set.
-bool KeyCodeFromSpecialWebDriverKey(char16 key, ui::KeyboardCode* key_code) {
+bool KeyCodeFromSpecialWebDriverKey(base::char16 key,
+                                    ui::KeyboardCode* key_code) {
   int index = static_cast<int>(key) - 0xE000U;
   bool is_special_key = index >= 0 &&
       index < static_cast<int>(arraysize(kSpecialWebDriverKeys));
   if (is_special_key)
     *key_code = kSpecialWebDriverKeys[index];
   return is_special_key;
 }
 
 // Gets the key code associated with |key_utf16|, if it is a special shorthand
 // key. Shorthand keys are common text equivalents for keys, such as the newline
 // character, which is shorthand for the return key. Returns whether |key| is
 // a shorthand key. If true, |key_code| will be set and |client_should_skip|
 // will be set to whether the key should be skipped.
-bool KeyCodeFromShorthandKey(char16 key_utf16,
+bool KeyCodeFromShorthandKey(base::char16 key_utf16,
                              ui::KeyboardCode* key_code,
                              bool* client_should_skip) {
   base::string16 key_str_utf16;
   key_str_utf16.push_back(key_utf16);
   std::string key_str_utf8 = base::UTF16ToUTF8(key_str_utf16);
   if (key_str_utf8.length() != 1)
     return false;
   bool should_skip = false;
   char key = key_str_utf8[0];
   if (key == '\n') {
@@ skipping 43 matching lines @@
   std::list<KeyEvent> key_events;
 
   base::string16 keys = client_keys;
   // Add an implicit NULL character to the end of the input to depress all
   // modifiers.
   if (release_modifiers)
     keys.push_back(kWebDriverNullKey);
 
   int sticky_modifiers = *modifiers;
   for (size_t i = 0; i < keys.size(); ++i) {
-    char16 key = keys[i];
+    base::char16 key = keys[i];
 
     if (key == kWebDriverNullKey) {
       // Release all modifier keys and clear |stick_modifiers|.
       if (sticky_modifiers & kShiftKeyModifierMask)
         key_events.push_back(CreateKeyUpEvent(ui::VKEY_SHIFT, 0));
       if (sticky_modifiers & kControlKeyModifierMask)
         key_events.push_back(CreateKeyUpEvent(ui::VKEY_CONTROL, 0));
       if (sticky_modifiers & kAltKeyModifierMask)
         key_events.push_back(CreateKeyUpEvent(ui::VKEY_MENU, 0));
       if (sticky_modifiers & kMetaKeyModifierMask)
@@ skipping 117 matching lines @@
       if (necessary_modifiers[i]) {
         key_events.push_back(
             CreateKeyUpEvent(kModifiers[i].key_code, sticky_modifiers));
       }
     }
   }
   client_key_events->swap(key_events);
   *modifiers = sticky_modifiers;
   return Status(kOk);
 }