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

components/policy/core/common/preg_parser_win.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 "components/policy/core/common/preg_parser_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 15 matching lines @@
 namespace policy {
 namespace preg_parser {
 
 const char kPRegFileHeader[8] =
     { 'P', 'R', 'e', 'g', '\x01', '\x00', '\x00', '\x00' };
 
 // Maximum PReg file size we're willing to accept.
 const int64 kMaxPRegFileSize = 1024 * 1024 * 16;
 
 // Constants for PReg file delimiters.
-const char16 kDelimBracketOpen = L'[';
-const char16 kDelimBracketClose = L']';
-const char16 kDelimSemicolon = L';';
+const base::char16 kDelimBracketOpen = L'[';
+const base::char16 kDelimBracketClose = L']';
+const base::char16 kDelimSemicolon = L';';
 
 // Registry path separator.
-const char16 kRegistryPathSeparator[] = L"\\";
+const base::char16 kRegistryPathSeparator[] = L"\\";
 
 // Magic strings for the PReg value field to trigger special actions.
 const char kActionTriggerPrefix[] = "**";
 const char kActionTriggerDeleteValues[] = "deletevalues";
 const char kActionTriggerDel[] = "del.";
 const char kActionTriggerDelVals[] = "delvals";
 const char kActionTriggerDeleteKeys[] = "deletekeys";
 const char kActionTriggerSecureKey[] = "securekey";
 const char kActionTriggerSoft[] = "soft";
 
 // Returns the character at |cursor| and increments it, unless the end is here
 // in which case -1 is returned.
 int NextChar(const uint8** cursor, const uint8* end) {
-  // Only read the character if a full char16 is available.
-  if (*cursor + sizeof(char16) > end)
+  // Only read the character if a full base::char16 is available.
+  if (*cursor + sizeof(base::char16) > end)
     return -1;
 
   int result = **cursor | (*(*cursor + 1) << 8);
-  *cursor += sizeof(char16);
+  *cursor += sizeof(base::char16);
   return result;
 }
 
 // Reads a fixed-size field from a PReg file.
 bool ReadFieldBinary(const uint8** cursor,
                      const uint8* end,
                      uint32 size,
                      uint8* data) {
   if (size == 0)
     return true;
@@ skipping 21 matching lines @@
                      const uint8* end,
                      base::string16* str) {
   int current = -1;
   while ((current = NextChar(cursor, end)) > 0x0000)
     *str += current;
 
   return current == L'\0';
 }
 
 std::string DecodePRegStringValue(const std::vector<uint8>& data) {
-  size_t len = data.size() / sizeof(char16);
+  size_t len = data.size() / sizeof(base::char16);
   if (len <= 0)
     return std::string();
 
-  const char16* chars = reinterpret_cast<const char16*>(vector_as_array(&data));
+  const base::char16* chars =
+      reinterpret_cast<const base::char16*>(vector_as_array(&data));
   base::string16 result;
   std::transform(chars, chars + len - 1, std::back_inserter(result),
                  std::ptr_fun(base::ByteSwapToLE16));
   return base::UTF16ToUTF8(result);
 }
 
 // Decodes a value from a PReg file given as a uint8 vector.
 bool DecodePRegValue(uint32 type,
                      const std::vector<uint8>& data,
                      scoped_ptr<base::Value>* value) {
@@ skipping 182 matching lines @@
   }
 
   LOG(ERROR) << "Error parsing " << file_path.value() << " at offset "
              << reinterpret_cast<const uint8*>(cursor - 1) - mapped_file.data();
   status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
   return false;
 }
 
 }  // namespace preg_parser
 }  // namespace policy