Switch to standard integer types in sandbox/.

sandbox/win/src/policy_low_level.h

 // 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.
 
 #ifndef SANDBOX_SRC_POLICY_LOW_LEVEL_H__
 #define SANDBOX_SRC_POLICY_LOW_LEVEL_H__
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/strings/string16.h"
 #include "sandbox/win/src/ipc_tags.h"
+#include "sandbox/win/src/policy_engine_opcodes.h"
 #include "sandbox/win/src/policy_engine_params.h"
-#include "sandbox/win/src/policy_engine_opcodes.h"
 
 // Low level policy classes.
 // Built on top of the PolicyOpcode and OpcodeFatory, the low level policy
 // provides a way to define rules on strings and numbers but it is unaware
 // of Windows specific details or how the Interceptions must be set up.
 // To use these classes you construct one or more rules and add them to the
 // LowLevelPolicy object like this:
 //
 //   PolicyRule rule1(ASK_BROKER);
 //   rule1.AddStringMatch(IF, 0, L"\\\\/?/?\\c:\\*Microsoft*\\*.exe", true);
@@ skipping 104 matching lines @@
   explicit PolicyRule(EvalResult action);
   PolicyRule(const PolicyRule& other);
   ~PolicyRule();
 
   // Adds a string comparison to the rule.
   // rule_type: possible values are IF and IF_NOT.
   // parameter: the expected index of the argument for this rule. For example
   // in a 'create file' service the file name argument can be at index 0.
   // string: is the desired matching pattern.
   // match_opts: if the pattern matching is case sensitive or not.
-  bool AddStringMatch(RuleType rule_type, int16 parameter,
-                      const wchar_t* string, StringMatchOptions match_opts);
+  bool AddStringMatch(RuleType rule_type,
+                      int16_t parameter,
+                      const wchar_t* string,
+                      StringMatchOptions match_opts);
 
   // Adds a number match comparison to the rule.
   // rule_type: possible values are IF and IF_NOT.
   // parameter: the expected index of the argument for this rule.
   // number: the value to compare the input to.
   // comparison_op: the comparison kind (equal, logical and, etc).
   bool AddNumberMatch(RuleType rule_type,
-                      int16 parameter,
-                      uint32 number,
+                      int16_t parameter,
+                      uint32_t number,
                       RuleOp comparison_op);
 
   // Returns the number of opcodes generated so far.
   size_t GetOpcodeCount() const {
     return buffer_->opcode_count;
   }
 
   // Called when there is no more comparisons to add. Internally it generates
   // the last opcode (the action opcode). Returns false if this operation fails.
   bool Done();
 
  private:
   void operator=(const PolicyRule&);
   // Called in a loop from AddStringMatch to generate the required string
   // match opcodes. rule_type, match_opts and parameter are the same as
   // in AddStringMatch.
-  bool GenStringOpcode(RuleType rule_type, StringMatchOptions match_opts,
-                       uint16 parameter, int state, bool last_call,
-                       int* skip_count, base::string16* fragment);
+  bool GenStringOpcode(RuleType rule_type,
+                       StringMatchOptions match_opts,
+                       uint16_t parameter,
+                       int state,
+                       bool last_call,
+                       int* skip_count,
+                       base::string16* fragment);
 
   // Loop over all generated opcodes and copy them to increasing memory
   // addresses from opcode_start and copy the extra data (strings usually) into
   // decreasing addresses from data_start. Extra data is only present in the
   // string evaluation opcodes.
   bool RebindCopy(PolicyOpcode* opcode_start, size_t opcode_size,
                   char* data_start, size_t* data_size) const;
   PolicyBuffer* buffer_;
   OpcodeFactory* opcode_factory_;
   EvalResult action_;
   bool done_;
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_SRC_POLICY_LOW_LEVEL_H__