Revert of Switch to standard integer types in sandbox/.

sandbox/win/src/policy_opcodes_unittest.cc

 // Copyright (c) 2006-2008 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 <stddef.h>
-#include <stdint.h>
-
+#include "sandbox/win/src/sandbox_types.h"
+#include "sandbox/win/src/sandbox_nt_types.h"
+#include "sandbox/win/src/policy_engine_params.h"
 #include "sandbox/win/src/policy_engine_opcodes.h"
-#include "sandbox/win/src/policy_engine_params.h"
-#include "sandbox/win/src/sandbox_nt_types.h"
-#include "sandbox/win/src/sandbox_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 
 #define INIT_GLOBAL_RTL(member) \
   g_nt.member = reinterpret_cast<member##Function>( \
   ::GetProcAddress(ntdll, #member)); \
   if (NULL == g_nt.member) \
   return false
 
 namespace sandbox {
@@ skipping 19 matching lines @@
 }
 
 TEST(PolicyEngineTest, ParameterSetTest) {
   void* pv1 = reinterpret_cast<void*>(0x477EAA5);
   const void* pv2 = reinterpret_cast<void*>(0x987654);
   ParameterSet pset1 = ParamPickerMake(pv1);
   ParameterSet pset2 = ParamPickerMake(pv2);
 
   // Test that we can store and retrieve a void pointer:
   const void* result1 =0;
-  uint32_t result2 = 0;
+  uint32 result2 = 0;
   EXPECT_TRUE(pset1.Get(&result1));
   EXPECT_TRUE(pv1 == result1);
   EXPECT_FALSE(pset1.Get(&result2));
   EXPECT_TRUE(pset2.Get(&result1));
   EXPECT_TRUE(pv2 == result1);
   EXPECT_FALSE(pset2.Get(&result2));
 
-  // Test that we can store and retrieve a uint32_t:
-  uint32_t number = 12747;
+  // Test that we can store and retrieve a uint32:
+  uint32 number = 12747;
   ParameterSet pset3 = ParamPickerMake(number);
   EXPECT_FALSE(pset3.Get(&result1));
   EXPECT_TRUE(pset3.Get(&result2));
   EXPECT_EQ(number, result2);
 
   // Test that we can store and retrieve a string:
   const wchar_t* txt = L"S231L";
   ParameterSet pset4 = ParamPickerMake(txt);
   const wchar_t* result3 = NULL;
   EXPECT_TRUE(pset4.Get(&result3));
@@ skipping 106 matching lines @@
 
   // There should be no room more another opcode:
   PolicyOpcode* op1 = opcode_maker.MakeOpWStringMatch(0, txt2, 0,
                                                       CASE_SENSITIVE,
                                                       kPolNone);
   ASSERT_EQ(nullptr, op1);
 }
 
 TEST(PolicyEngineTest, IntegerOpcodes) {
   const wchar_t* txt = L"abcdef";
-  uint32_t num1 = 42;
-  uint32_t num2 = 113377;
+  uint32 num1 = 42;
+  uint32 num2 = 113377;
 
   ParameterSet pp_wrong1 = ParamPickerMake(txt);
   ParameterSet pp_num1 = ParamPickerMake(num1);
   ParameterSet pp_num2 = ParamPickerMake(num2);
 
   char memory[kOpcodeMemory];
   OpcodeFactory opcode_maker(memory, sizeof(memory));
 
   // Test basic match for uint32s 42 == 42 and 42 != 113377.
   PolicyOpcode* op_m42 = opcode_maker.MakeOpNumberMatch(0, 42UL, kPolNone);
@@ skipping 18 matching lines @@
   ASSERT_NE(nullptr, op_range1);
   EXPECT_EQ(EVAL_TRUE, op_range1->Evaluate(&pp_num1, 1, NULL));
   EXPECT_EQ(EVAL_FALSE, op_range1->Evaluate(&pp_num2, 1, NULL));
   EXPECT_EQ(EVAL_ERROR, op_range1->Evaluate(&pp_wrong1, 1, NULL));
 }
 
 TEST(PolicyEngineTest, LogicalOpcodes) {
   char memory[kOpcodeMemory];
   OpcodeFactory opcode_maker(memory, sizeof(memory));
 
-  uint32_t num1 = 0x10100702;
+  uint32 num1 = 0x10100702;
   ParameterSet pp_num1 = ParamPickerMake(num1);
 
   PolicyOpcode* op_and1 =
       opcode_maker.MakeOpNumberAndMatch(0, 0x00100000, kPolNone);
   ASSERT_NE(nullptr, op_and1);
   EXPECT_EQ(EVAL_TRUE, op_and1->Evaluate(&pp_num1, 1, NULL));
   PolicyOpcode* op_and2 =
       opcode_maker.MakeOpNumberAndMatch(0, 0x00000001, kPolNone);
   ASSERT_NE(nullptr, op_and2);
   EXPECT_EQ(EVAL_FALSE, op_and2->Evaluate(&pp_num1, 1, NULL));
@@ skipping 125 matching lines @@
   void* dummy = NULL;
   ParameterSet ppb1 = ParamPickerMake(dummy);
 
   PolicyOpcode* op1 = opcode_maker.MakeOpAction(ASK_BROKER, kPolNone);
   ASSERT_NE(nullptr, op1);
   EXPECT_TRUE(op1->IsAction());
   EXPECT_EQ(ASK_BROKER, op1->Evaluate(&ppb1, 1, &mc1));
 }
 
 }  // namespace sandbox