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

sandbox/win/src/handle_closer.cc

 // Copyright (c) 2011 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 "sandbox/win/src/handle_closer.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/windows_version.h"
 #include "sandbox/win/src/interceptors.h"
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 namespace sandbox {
 
 // Memory buffer mapped from the parent, with the list of handles.
 SANDBOX_INTERCEPT HandleCloserInfo* g_handles_to_close;
 
 HandleCloser::HandleCloser() {}
 
-ResultCode HandleCloser::AddHandle(const char16* handle_type,
-                                   const char16* handle_name) {
+ResultCode HandleCloser::AddHandle(const base::char16* handle_type,
+                                   const base::char16* handle_name) {
   if (!handle_type)
     return SBOX_ERROR_BAD_PARAMS;
 
   HandleMap::iterator names = handles_to_close_.find(handle_type);
   if (names == handles_to_close_.end()) {  // We have no entries for this type.
     std::pair<HandleMap::iterator, bool> result = handles_to_close_.insert(
         HandleMap::value_type(handle_type, HandleMap::mapped_type()));
     names = result.first;
     if (handle_name)
       names->second.insert(handle_name);
   } else if (!handle_name) {  // Now we need to close all handles of this type.
     names->second.clear();
   } else if (!names->second.empty()) {  // Add another name for this type.
     names->second.insert(handle_name);
   }  // If we're already closing all handles of type then we're done.
 
   return SBOX_ALL_OK;
 }
 
 size_t HandleCloser::GetBufferSize() {
   size_t bytes_total = offsetof(HandleCloserInfo, handle_entries);
 
   for (HandleMap::iterator i = handles_to_close_.begin();
        i != handles_to_close_.end(); ++i) {
     size_t bytes_entry = offsetof(HandleListEntry, handle_type) +
-        (i->first.size() + 1) * sizeof(char16);
+        (i->first.size() + 1) * sizeof(base::char16);
     for (HandleMap::mapped_type::iterator j = i->second.begin();
          j != i->second.end(); ++j) {
-      bytes_entry += ((*j).size() + 1) * sizeof(char16);
+      bytes_entry += ((*j).size() + 1) * sizeof(base::char16);
     }
 
     // Round up to the nearest multiple of word size.
     bytes_entry = RoundUpToWordSize(bytes_entry);
     bytes_total += bytes_entry;
   }
 
   return bytes_total;
 }
 
@@ skipping 34 matching lines @@
 
   return (SBOX_ALL_OK == rc);
 }
 
 bool HandleCloser::SetupHandleList(void* buffer, size_t buffer_bytes) {
   ::ZeroMemory(buffer, buffer_bytes);
   HandleCloserInfo* handle_info = reinterpret_cast<HandleCloserInfo*>(buffer);
   handle_info->record_bytes = buffer_bytes;
   handle_info->num_handle_types = handles_to_close_.size();
 
-  char16* output = reinterpret_cast<char16*>(&handle_info->handle_entries[0]);
-  char16* end = reinterpret_cast<char16*>(
+  base::char16* output = reinterpret_cast<base::char16*>(
+      &handle_info->handle_entries[0]);
+  base::char16* end = reinterpret_cast<base::char16*>(
       reinterpret_cast<char*>(buffer) + buffer_bytes);
   for (HandleMap::iterator i = handles_to_close_.begin();
        i != handles_to_close_.end(); ++i) {
     if (output >= end)
       return false;
     HandleListEntry* list_entry = reinterpret_cast<HandleListEntry*>(output);
     output = &list_entry->handle_type[0];
 
     // Copy the typename and set the offset and count.
     i->first._Copy_s(output, i->first.size(), i->first.size());
@@ skipping 59 matching lines @@
 
   if (NT_SUCCESS(result) && name->Buffer && name->Length)
     handle_name->assign(name->Buffer, name->Length / sizeof(wchar_t));
   else
     handle_name->clear();
 
   return NT_SUCCESS(result);
 }
 
 }  // namespace sandbox