Switch to standard integer types in sandbox/.

sandbox/win/src/policy_engine_opcodes.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_WIN_SRC_POLICY_ENGINE_OPCODES_H_
 #define SANDBOX_WIN_SRC_POLICY_ENGINE_OPCODES_H_
 
-#include "base/basictypes.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "sandbox/win/src/policy_engine_params.h"
 
 // The low-level policy is implemented using the concept of policy 'opcodes'.
 // An opcode is a structure that contains enough information to perform one
 // comparison against one single input parameter. For example, an opcode can
 // encode just one of the following comparison:
 //
 // - Is input parameter 3 not equal to NULL?
 // - Does input parameter 2 start with L"c:\\"?
@@ skipping 58 matching lines @@
   OP_NUMBER_MATCH,  // Match a 32-bit integer as n == a.
   OP_NUMBER_MATCH_RANGE,  // Match a 32-bit integer as a <= n <= b.
   OP_NUMBER_AND_MATCH,  // Match using bitwise AND; as in: n & a != 0.
   OP_WSTRING_MATCH,  // Match a string for equality.
   OP_ACTION  // Evaluates to an action opcode.
 };
 
 // Options that apply to every opcode. They are specified when creating
 // each opcode using OpcodeFactory::MakeOpXXXXX() family of functions
 // Do nothing special.
-const uint32 kPolNone = 0;
+const uint32_t kPolNone = 0;
 
 // Convert EVAL_TRUE into EVAL_FALSE and vice-versa. This allows to express
 // negated conditions such as if ( a && !b).
-const uint32 kPolNegateEval = 1;
+const uint32_t kPolNegateEval = 1;
 
 // Zero the MatchContext context structure. This happens after the opcode
 // is evaluated.
-const uint32 kPolClearContext = 2;
+const uint32_t kPolClearContext = 2;
 
 // Use OR when evaluating this set of opcodes. The policy evaluator by default
 // uses AND when evaluating. Very helpful when
 // used with kPolNegateEval. For example if you have a condition best expressed
 // as if(! (a && b && c)), the use of this flags allows it to be expressed as
 // if ((!a) || (!b) || (!c)).
-const uint32 kPolUseOREval = 4;
+const uint32_t kPolUseOREval = 4;
 
 // Keeps the evaluation state between opcode evaluations. This is used
 // for string matching where the next opcode needs to continue matching
 // from the last character position from the current opcode. The match
 // context is preserved across opcode evaluation unless an opcode specifies
 // as an option kPolClearContext.
 struct MatchContext {
   size_t position;
-  uint32 options;
+  uint32_t options;
 
   MatchContext() {
     Clear();
   }
 
   void Clear() {
     position = 0;
     options = 0;
   }
 };
@@ skipping 61 matching lines @@
   bool IsAction() const {
     return (OP_ACTION == opcode_id_);
   };
 
   // Returns the opcode type.
   OpcodeID GetID() const {
     return opcode_id_;
   }
 
   // Returns the stored options such as kPolNegateEval and others.
-  uint32 GetOptions() const {
-    return options_;
-  }
+  uint32_t GetOptions() const { return options_; }
 
   // Sets the stored options such as kPolNegateEval.
-  void SetOptions(uint32 options) {
-    options_ = base::checked_cast<uint16>(options);
+  void SetOptions(uint32_t options) {
+    options_ = base::checked_cast<uint16_t>(options);
   }
 
  private:
 
   static const size_t kArgumentCount = 4;  // The number of supported argument.
 
   struct OpcodeArgument {
     UINT_PTR mem;
   };
 
   // Better define placement new in the class instead of relying on the
   // global definition which seems to be fubared.
   void* operator new(size_t, void* location) {
     return location;
   }
 
   // Helper function to evaluate the opcode. The parameters have the same
   // meaning that in Evaluate().
   EvalResult EvaluateHelper(const ParameterSet* parameters,
                            MatchContext* match);
   OpcodeID opcode_id_;
-  int16 parameter_;
-  // TODO(cpu): Making |options_| a uint32 would avoid casting, but causes test
-  // failures.  Somewhere code is relying on the size of this struct.
+  int16_t parameter_;
+  // TODO(cpu): Making |options_| a uint32_t would avoid casting, but causes
+  // test failures.  Somewhere code is relying on the size of this struct.
   // http://crbug.com/420296
-  uint16 options_;
+  uint16_t options_;
   OpcodeArgument arguments_[PolicyOpcode::kArgumentCount];
 };
 
 enum StringMatchOptions {
   CASE_SENSITIVE = 0,      // Pay or Not attention to the case as defined by
   CASE_INSENSITIVE = 1,    // RtlCompareUnicodeString windows API.
   EXACT_LENGHT = 2         // Don't do substring match. Do full string match.
 };
 
 // Opcodes that do string comparisons take a parameter that is the starting
@@ skipping 54 matching lines @@
     memory_top_ = reinterpret_cast<char*>(&policy->opcodes[0]);
     memory_bottom_ = &memory_top_[memory_size];
   }
 
   // Returns the available memory to make opcodes.
   size_t memory_size() const {
     return memory_bottom_ - memory_top_;
   }
 
   // Creates an OpAlwaysFalse opcode.
-  PolicyOpcode* MakeOpAlwaysFalse(uint32 options);
+  PolicyOpcode* MakeOpAlwaysFalse(uint32_t options);
 
   // Creates an OpAlwaysFalse opcode.
-  PolicyOpcode* MakeOpAlwaysTrue(uint32 options);
+  PolicyOpcode* MakeOpAlwaysTrue(uint32_t options);
 
   // Creates an OpAction opcode.
   // action: The action to return when Evaluate() is called.
-  PolicyOpcode* MakeOpAction(EvalResult action, uint32 options);
+  PolicyOpcode* MakeOpAction(EvalResult action, uint32_t options);
 
   // Creates an OpNumberMatch opcode.
-  // selected_param: index of the input argument. It must be a uint32 or the
+  // selected_param: index of the input argument. It must be a uint32_t or the
   // evaluation result will generate a EVAL_ERROR.
   // match: the number to compare against the selected_param.
-  PolicyOpcode* MakeOpNumberMatch(int16 selected_param,
-                                  uint32 match,
-                                  uint32 options);
+  PolicyOpcode* MakeOpNumberMatch(int16_t selected_param,
+                                  uint32_t match,
+                                  uint32_t options);
 
   // Creates an OpNumberMatch opcode (void pointers are cast to numbers).
   // selected_param: index of the input argument. It must be an void* or the
   // evaluation result will generate a EVAL_ERROR.
   // match: the pointer numeric value to compare against selected_param.
-  PolicyOpcode* MakeOpVoidPtrMatch(int16 selected_param,
+  PolicyOpcode* MakeOpVoidPtrMatch(int16_t selected_param,
                                    const void* match,
-                                   uint32 options);
+                                   uint32_t options);
 
   // Creates an OpNumberMatchRange opcode using the memory passed in the ctor.
-  // selected_param: index of the input argument. It must be a uint32 or the
+  // selected_param: index of the input argument. It must be a uint32_t or the
   // evaluation result will generate a EVAL_ERROR.
   // lower_bound, upper_bound: the range to compare against selected_param.
-  PolicyOpcode* MakeOpNumberMatchRange(int16 selected_param,
-                                       uint32 lower_bound,
-                                       uint32 upper_bound,
-                                       uint32 options);
+  PolicyOpcode* MakeOpNumberMatchRange(int16_t selected_param,
+                                       uint32_t lower_bound,
+                                       uint32_t upper_bound,
+                                       uint32_t options);
 
   // Creates an OpWStringMatch opcode using the raw memory passed in the ctor.
   // selected_param: index of the input argument. It must be a wide string
   // pointer or the evaluation result will generate a EVAL_ERROR.
   // match_str: string to compare against selected_param.
   // start_position: when its value is from 0 to < 0x7fff it indicates an
   // offset from the selected_param string where to perform the comparison. If
   // the value is SeekForward  then a substring search is performed. If the
   // value is SeekToEnd the comparison is performed against the last part of
   // the selected_param string.
   // Note that the range in the position (0 to 0x7fff) is dictated by the
   // current implementation.
   // match_opts: Indicates additional matching flags. Currently CaseInsensitive
   // is supported.
-  PolicyOpcode* MakeOpWStringMatch(int16 selected_param,
+  PolicyOpcode* MakeOpWStringMatch(int16_t selected_param,
                                    const wchar_t* match_str,
                                    int start_position,
                                    StringMatchOptions match_opts,
-                                   uint32 options);
+                                   uint32_t options);
 
   // Creates an OpNumberAndMatch opcode using the raw memory passed in the ctor.
-  // selected_param: index of the input argument. It must be uint32 or the
+  // selected_param: index of the input argument. It must be uint32_t or the
   // evaluation result will generate a EVAL_ERROR.
   // match: the value to bitwise AND against selected_param.
-  PolicyOpcode* MakeOpNumberAndMatch(int16 selected_param,
-                                     uint32 match,
-                                     uint32 options);
+  PolicyOpcode* MakeOpNumberAndMatch(int16_t selected_param,
+                                     uint32_t match,
+                                     uint32_t options);
 
  private:
   // Constructs the common part of every opcode. selected_param is the index
   // of the input param to use when evaluating the opcode. Pass -1 in
   // selected_param to indicate that no input parameter is required.
-  PolicyOpcode* MakeBase(OpcodeID opcode_id, uint32 options,
-                         int16 selected_param);
+  PolicyOpcode* MakeBase(OpcodeID opcode_id,
+                         uint32_t options,
+                         int16_t selected_param);
 
   // Allocates (and copies) a string (of size length) inside the buffer and
   // returns the displacement with respect to start.
   ptrdiff_t AllocRelative(void* start, const wchar_t* str, size_t lenght);
 
   // Points to the lowest currently available address of the memory
   // used to make the opcodes. This pointer increments as opcodes are made.
   char* memory_top_;
 
   // Points to the highest currently available address of the memory
   // used to make the opcodes. This pointer decrements as opcode strings are
   // allocated.
   char* memory_bottom_;
 
   DISALLOW_COPY_AND_ASSIGN(OpcodeFactory);
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_WIN_SRC_POLICY_ENGINE_OPCODES_H_