Switch to standard integer types in components/policy/.

components/policy/core/common/policy_loader_win_unittest.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 "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <userenv.h>
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <iterator>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_writer.h"
+#include "base/macros.h"
 #include "base/path_service.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
@@ skipping 216 matching lines @@
                           LPCTSTR machine_name,
                           PSID sid_user,
                           GUID* extension_guid,
                           PGROUP_POLICY_OBJECT* gpo_list) override;
   BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override;
 
   // Creates a harness instance.
   static PolicyProviderTestHarness* Create();
 
  private:
-  // Helper to append a base::string16 to an uint8 buffer.
-  static void AppendChars(std::vector<uint8>* buffer,
+  // Helper to append a base::string16 to an uint8_t buffer.
+  static void AppendChars(std::vector<uint8_t>* buffer,
                           const base::string16& chars);
 
   // Appends a record with the given fields to the PReg file.
   void AppendRecordToPRegFile(const base::string16& path,
                               const std::string& key,
                               DWORD type,
                               DWORD size,
-                              uint8* data);
+                              uint8_t* data);
 
   // Appends the given DWORD |value| for |path| + |key| to the PReg file.
   void AppendDWORDToPRegFile(const base::string16& path,
                              const std::string& key,
                              DWORD value);
 
   // Appends the given string |value| for |path| + |key| to the PReg file.
   void AppendStringToPRegFile(const base::string16& path,
                               const std::string& key,
                               const std::string& value);
@@ skipping 274 matching lines @@
 BOOL PRegTestHarness::FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) {
   return TRUE;
 }
 
 // static
 PolicyProviderTestHarness* PRegTestHarness::Create() {
   return new PRegTestHarness();
 }
 
 // static
-void PRegTestHarness::AppendChars(std::vector<uint8>* buffer,
+void PRegTestHarness::AppendChars(std::vector<uint8_t>* buffer,
                                   const base::string16& chars) {
   for (base::string16::const_iterator c(chars.begin()); c != chars.end(); ++c) {
     buffer->push_back(*c & 0xff);
     buffer->push_back((*c >> 8) & 0xff);
   }
 }
 
 void PRegTestHarness::AppendRecordToPRegFile(const base::string16& path,
                                              const std::string& key,
                                              DWORD type,
                                              DWORD size,
-                                             uint8* data) {
-  std::vector<uint8> buffer;
+                                             uint8_t* data) {
+  std::vector<uint8_t> buffer;
   AppendChars(&buffer, L"[");
   AppendChars(&buffer, path);
   AppendChars(&buffer, base::string16(L"\0;", 2));
   AppendChars(&buffer, UTF8ToUTF16(key));
   AppendChars(&buffer, base::string16(L"\0;", 2));
   type = base::ByteSwapToLE32(type);
-  uint8* type_data = reinterpret_cast<uint8*>(&type);
+  uint8_t* type_data = reinterpret_cast<uint8_t*>(&type);
   buffer.insert(buffer.end(), type_data, type_data + sizeof(DWORD));
   AppendChars(&buffer, L";");
   size = base::ByteSwapToLE32(size);
-  uint8* size_data = reinterpret_cast<uint8*>(&size);
+  uint8_t* size_data = reinterpret_cast<uint8_t*>(&size);
   buffer.insert(buffer.end(), size_data, size_data + sizeof(DWORD));
   AppendChars(&buffer, L";");
   buffer.insert(buffer.end(), data, data + size);
   AppendChars(&buffer, L"]");
 
   ASSERT_TRUE(base::AppendToFile(preg_file_path_,
                                  reinterpret_cast<const char*>(buffer.data()),
                                  buffer.size()));
 }
 
 void PRegTestHarness::AppendDWORDToPRegFile(const base::string16& path,
                                             const std::string& key,
                                             DWORD value) {
   value = base::ByteSwapToLE32(value);
   AppendRecordToPRegFile(path, key, REG_DWORD, sizeof(DWORD),
-                         reinterpret_cast<uint8*>(&value));
+                         reinterpret_cast<uint8_t*>(&value));
 }
 
 void PRegTestHarness::AppendStringToPRegFile(const base::string16& path,
                                              const std::string& key,
                                              const std::string& value) {
   base::string16 string16_value(UTF8ToUTF16(value));
   std::vector<base::char16> data;
   std::transform(string16_value.begin(), string16_value.end(),
                  std::back_inserter(data), std::ptr_fun(base::ByteSwapToLE16));
   data.push_back(base::ByteSwapToLE16(L'\0'));
 
   AppendRecordToPRegFile(path, key, REG_SZ, data.size() * sizeof(base::char16),
-                         reinterpret_cast<uint8*>(data.data()));
+                         reinterpret_cast<uint8_t*>(data.data()));
 }
 
 void PRegTestHarness::AppendPolicyToPRegFile(const base::string16& path,
                                              const std::string& key,
                                              const base::Value* value) {
   switch (value->GetType()) {
     case base::Value::TYPE_BOOLEAN: {
       bool boolean_value = false;
       ASSERT_TRUE(value->GetAsBoolean(&boolean_value));
       AppendDWORDToPRegFile(path, key, boolean_value);
@@ skipping 607 matching lines @@
   expected_policy.Set("alternative_browser_path",
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       POLICY_SOURCE_PLATFORM,
                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       POLICY_SOURCE_PLATFORM, list.DeepCopy(), nullptr);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy