Switch to standard integer types in sandbox/.

sandbox/win/src/policy_engine_processor.h

 // Copyright (c) 2010 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_ENGINE_PROCESSOR_H__
 #define SANDBOX_SRC_POLICY_ENGINE_PROCESSOR_H__
 
-#include "base/basictypes.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.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"
 
 namespace sandbox {
 
 // This header contains the core policy evaluator. In its simplest form
 // it evaluates a stream of opcodes assuming that they are laid out in
 // memory as opcode groups.
 //
 // An opcode group has N comparison opcodes plus 1 action opcode. For
 // example here we have 3 opcode groups (A, B,C):
 //
@@ skipping 38 matching lines @@
 enum PolicyResult {
   NO_POLICY_MATCH,
   POLICY_MATCH,
   POLICY_ERROR
 };
 
 // Policy evaluation flags
 // TODO(cpu): implement the options kStopOnErrors & kRankedEval.
 //
 // Stop evaluating as soon as an error is encountered.
-const uint32 kStopOnErrors = 1;
+const uint32_t kStopOnErrors = 1;
 // Ignore all non fatal opcode evaluation errors.
-const uint32 kIgnoreErrors = 2;
+const uint32_t kIgnoreErrors = 2;
 // Short-circuit evaluation: Only evaluate until opcode group that
 // evaluated to true has been found.
-const uint32 kShortEval = 4;
+const uint32_t kShortEval = 4;
 // Discussed briefly at the policy design meeting. It will evaluate
 // all rules and then return the 'best' rule that evaluated true.
-const uint32 kRankedEval = 8;
+const uint32_t kRankedEval = 8;
 
 // This class evaluates a policy-opcode stream given the memory where the
 // opcodes are and an input 'parameter set'.
 //
 // This class is designed to be callable from interception points
 // as low as the NtXXXX service level (it is not currently safe, but
 // it is designed to be made safe).
 //
 // Its usage in an interception is:
 //
@@ skipping 24 matching lines @@
 
   // This constructor is just a variant of the previous constructor.
   explicit PolicyProcessor(PolicyBuffer* policy)
       : policy_(policy) {
     SetInternalState(0, EVAL_FALSE);
   }
 
   // Evaluates a policy-opcode stream. See the comments at the top of this
   // class for more info. Returns POLICY_MATCH if a rule set was found that
   // matches an active policy.
-  PolicyResult Evaluate(uint32 options,
+  PolicyResult Evaluate(uint32_t options,
                         ParameterSet* parameters,
                         size_t parameter_count);
 
   // If the result of Evaluate() was POLICY_MATCH, calling this function returns
   // the recommended policy action.
   EvalResult GetAction() const;
 
  private:
   struct {
     size_t current_index_;
     EvalResult current_result_;
   } state_;
 
   // Sets the currently matching action result.
   void SetInternalState(size_t index, EvalResult result);
 
   PolicyBuffer* policy_;
   DISALLOW_COPY_AND_ASSIGN(PolicyProcessor);
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_SRC_POLICY_ENGINE_PROCESSOR_H__