Switch to standard integer types in components/policy/.

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 <stddef.h>
+#include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/values.h"
 #include "components/policy/core/common/policy_load_status.h"
 #include "components/policy/core/common/registry_dict_win.h"
 
 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;
+const int64_t kMaxPRegFileSize = 1024 * 1024 * 16;
 
 // Constants for PReg file delimiters.
 const base::char16 kDelimBracketOpen = L'[';
 const base::char16 kDelimBracketClose = L']';
 const base::char16 kDelimSemicolon = L';';
 
 // Registry path separator.
 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) {
+int NextChar(const uint8_t** cursor, const uint8_t* 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(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) {
+bool ReadFieldBinary(const uint8_t** cursor,
+                     const uint8_t* end,
+                     uint32_t size,
+                     uint8_t* data) {
   if (size == 0)
     return true;
 
-  const uint8* field_end = *cursor + size;
+  const uint8_t* field_end = *cursor + size;
   if (field_end <= *cursor || field_end > end)
     return false;
   std::copy(*cursor, field_end, data);
   *cursor = field_end;
   return true;
 }
 
-bool ReadField32(const uint8** cursor, const uint8* end, uint32* data) {
-  uint32 value = 0;
-  if (!ReadFieldBinary(cursor, end, sizeof(uint32),
-                       reinterpret_cast<uint8*>(&value))) {
+bool ReadField32(const uint8_t** cursor, const uint8_t* end, uint32_t* data) {
+  uint32_t value = 0;
+  if (!ReadFieldBinary(cursor, end, sizeof(uint32_t),
+                       reinterpret_cast<uint8_t*>(&value))) {
     return false;
   }
   *data = base::ByteSwapToLE32(value);
   return true;
 }
 
 // Reads a string field from a file.
-bool ReadFieldString(const uint8** cursor,
-                     const uint8* end,
+bool ReadFieldString(const uint8_t** cursor,
+                     const uint8_t* 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) {
+std::string DecodePRegStringValue(const std::vector<uint8_t>& data) {
   size_t len = data.size() / sizeof(base::char16);
   if (len <= 0)
     return std::string();
 
   const base::char16* chars =
       reinterpret_cast<const base::char16*>(data.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,
+// Decodes a value from a PReg file given as a uint8_t vector.
+bool DecodePRegValue(uint32_t type,
+                     const std::vector<uint8_t>& data,
                      scoped_ptr<base::Value>* value) {
   switch (type) {
     case REG_SZ:
     case REG_EXPAND_SZ:
       value->reset(new base::StringValue(DecodePRegStringValue(data)));
       return true;
     case REG_DWORD_LITTLE_ENDIAN:
     case REG_DWORD_BIG_ENDIAN:
-      if (data.size() == sizeof(uint32)) {
-        uint32 val = *reinterpret_cast<const uint32*>(data.data());
+      if (data.size() == sizeof(uint32_t)) {
+        uint32_t val = *reinterpret_cast<const uint32_t*>(data.data());
         if (type == REG_DWORD_BIG_ENDIAN)
           val = base::NetToHost32(val);
         else
           val = base::ByteSwapToLE32(val);
         value->reset(new base::FundamentalValue(static_cast<int>(val)));
         return true;
       } else {
         LOG(ERROR) << "Bad data size " << data.size();
       }
       break;
     case REG_NONE:
     case REG_LINK:
     case REG_MULTI_SZ:
     case REG_RESOURCE_LIST:
     case REG_FULL_RESOURCE_DESCRIPTOR:
     case REG_RESOURCE_REQUIREMENTS_LIST:
     case REG_QWORD_LITTLE_ENDIAN:
     default:
       LOG(ERROR) << "Unsupported registry data type " << type;
   }
 
   return false;
 }
 
 // Adds the record data passed via parameters to |dict| in case the data is
 // relevant policy for Chromium.
 void HandleRecord(const base::string16& key_name,
                   const base::string16& value,
-                  uint32 type,
-                  const std::vector<uint8>& data,
+                  uint32_t type,
+                  const std::vector<uint8_t>& data,
                   RegistryDict* dict) {
   // Locate/create the dictionary to place the value in.
   std::vector<base::string16> path;
 
   for (const base::string16& entry :
        base::SplitString(key_name, kRegistryPathSeparator,
                          base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
     if (entry.empty())
       continue;
     const std::string name = base::UTF16ToUTF8(entry);
@@ skipping 72 matching lines @@
   if (mapped_file.length() < kHeaderSize ||
       memcmp(kPRegFileHeader, mapped_file.data(), kHeaderSize) != 0) {
     LOG(ERROR) << "Bad policy file " << file_path.value();
     status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
     return false;
   }
 
   // Parse file contents, which is UCS-2 and little-endian. The latter I
   // couldn't find documentation on, but the example I saw were all
   // little-endian. It'd be interesting to check on big-endian hardware.
-  const uint8* cursor = mapped_file.data() + kHeaderSize;
-  const uint8* end = mapped_file.data() + mapped_file.length();
+  const uint8_t* cursor = mapped_file.data() + kHeaderSize;
+  const uint8_t* end = mapped_file.data() + mapped_file.length();
   while (true) {
     if (cursor == end)
       return true;
 
     if (NextChar(&cursor, end) != kDelimBracketOpen)
       break;
 
     // Read the record fields.
     base::string16 key_name;
     base::string16 value;
-    uint32 type = 0;
-    uint32 size = 0;
-    std::vector<uint8> data;
+    uint32_t type = 0;
+    uint32_t size = 0;
+    std::vector<uint8_t> data;
 
     if (!ReadFieldString(&cursor, end, &key_name))
       break;
 
     int current = NextChar(&cursor, end);
     if (current == kDelimSemicolon) {
       if (!ReadFieldString(&cursor, end, &value))
         break;
       current = NextChar(&cursor, end);
     }
@@ skipping 23 matching lines @@
       break;
 
     // Process the record if it is within the |root| subtree.
     if (base::StartsWith(base::i18n::ToLower(key_name),
                          base::i18n::ToLower(root),
                          base::CompareCase::SENSITIVE))
       HandleRecord(key_name.substr(root.size()), value, type, data, dict);
   }
 
   LOG(ERROR) << "Error parsing " << file_path.value() << " at offset "
-             << reinterpret_cast<const uint8*>(cursor - 1) - mapped_file.data();
+             << reinterpret_cast<const uint8_t*>(cursor - 1) -
+                    mapped_file.data();
   status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
   return false;
 }
 
 }  // namespace preg_parser
 }  // namespace policy