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

net/http/http_auth_handler_ntlm_portable.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 "net/http/http_auth_handler_ntlm.h"
 
 #include <stdlib.h>
 // For gethostname
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 193 matching lines @@
 }
 
 #ifdef IS_BIG_ENDIAN
 /**
  * WriteUnicodeLE copies a unicode string from one buffer to another.  The
  * resulting unicode string is in little-endian format.  The input string is
  * assumed to be in the native endianness of the local machine.  It is safe
  * to pass the same buffer as both input and output, which is a handy way to
  * convert the unicode buffer to little-endian on big-endian platforms.
  */
-static void* WriteUnicodeLE(void* buf, const char16* str, uint32 str_len) {
+static void* WriteUnicodeLE(
+    void* buf, const base::char16* str, uint32 str_len) {
   // Convert input string from BE to LE.
   uint8* cursor = static_cast<uint8*>(buf);
   const uint8* input  = reinterpret_cast<const uint8*>(str);
   for (uint32 i = 0; i < str_len; ++i, input += 2, cursor += 2) {
     // Allow for the case where |buf == str|.
     uint8 temp = input[0];
     cursor[0] = input[1];
     cursor[1] = temp;
   }
   return buf;
@@ skipping 248 matching lines @@
   uint32 domain_len, user_len, host_len;
 
   //
   // Get domain name.
   //
   if (unicode) {
 #ifdef IS_BIG_ENDIAN
     ucs_domain_buf = domain;
     domain_ptr = ucs_domain_buf.data();
     domain_len = ucs_domain_buf.length() * 2;
-    WriteUnicodeLE(const_cast<void*>(domain_ptr), (const char16*) domain_ptr,
+    WriteUnicodeLE(const_cast<void*>(domain_ptr),
+                   (const base::char16*) domain_ptr,
                    ucs_domain_buf.length());
 #else
     domain_ptr = domain.data();
     domain_len = domain.length() * 2;
 #endif
   } else {
     oem_domain_buf = base::SysWideToNativeMB(base::UTF16ToWide(domain));
     domain_ptr = oem_domain_buf.data();
     domain_len = oem_domain_buf.length();
   }
 
   //
   // Get user name.
   //
   if (unicode) {
 #ifdef IS_BIG_ENDIAN
     ucs_user_buf = username;
     user_ptr = ucs_user_buf.data();
     user_len = ucs_user_buf.length() * 2;
-    WriteUnicodeLE(const_cast<void*>(user_ptr), (const char16*) user_ptr,
+    WriteUnicodeLE(const_cast<void*>(user_ptr), (const base::char16*) user_ptr,
                    ucs_user_buf.length());
 #else
     user_ptr = username.data();
     user_len = username.length() * 2;
 #endif
   } else {
     oem_user_buf = base::SysWideToNativeMB(base::UTF16ToWide(username));
     user_ptr = oem_user_buf.data();
     user_len = oem_user_buf.length();
   }
 
   //
   // Get workstation name (use local machine's hostname).
   //
   if (unicode) {
     // hostname is ASCII, so we can do a simple zero-pad expansion:
     ucs_host_buf.assign(hostname.begin(), hostname.end());
     host_ptr = ucs_host_buf.data();
     host_len = ucs_host_buf.length() * 2;
 #ifdef IS_BIG_ENDIAN
-    WriteUnicodeLE(const_cast<void*>(host_ptr), (const char16*) host_ptr,
+    WriteUnicodeLE(const_cast<void*>(host_ptr), (const base::char16*) host_ptr,
                    ucs_host_buf.length());
 #endif
   } else {
     host_ptr = hostname.data();
     host_len = hostname.length();
   }
 
   //
   // Now that we have generated all of the strings, we can allocate out_buf.
   //
@@ skipping 186 matching lines @@
   // NOTE: Default credentials are not supported for the portable implementation
   // of NTLM.
   scoped_ptr<HttpAuthHandler> tmp_handler(new HttpAuthHandlerNTLM);
   if (!tmp_handler->InitFromChallenge(challenge, target, origin, net_log))
     return ERR_INVALID_RESPONSE;
   handler->swap(tmp_handler);
   return OK;
 }
 
 }  // namespace net