Switch to standard integer types in sandbox/.

sandbox/win/src/policy_engine_opcodes.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 "sandbox/win/src/policy_engine_opcodes.h"
 
-#include "base/basictypes.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "sandbox/win/src/sandbox_nt_types.h"
 #include "sandbox/win/src/sandbox_types.h"
 
 namespace {
 const unsigned short kMaxUniStrSize = 0xfffc / sizeof(wchar_t);
 
 bool InitStringUnicode(const wchar_t* source, size_t length,
                        UNICODE_STRING* ustring) {
   if (length > kMaxUniStrSize) {
     return false;
@@ skipping 23 matching lines @@
 // order and meaning.
 
 template <int>
 EvalResult OpcodeEval(PolicyOpcode* opcode, const ParameterSet* pp,
                       MatchContext* match);
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpAlwaysFalse:
 // Does not require input parameter.
 
-PolicyOpcode* OpcodeFactory::MakeOpAlwaysFalse(uint32 options) {
+PolicyOpcode* OpcodeFactory::MakeOpAlwaysFalse(uint32_t options) {
   return MakeBase(OP_ALWAYS_FALSE, options, -1);
 }
 
 template <>
 EvalResult OpcodeEval<OP_ALWAYS_FALSE>(PolicyOpcode* opcode,
                                        const ParameterSet* param,
                                        MatchContext* context) {
   return EVAL_FALSE;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpAlwaysTrue:
 // Does not require input parameter.
 
-PolicyOpcode* OpcodeFactory::MakeOpAlwaysTrue(uint32 options) {
+PolicyOpcode* OpcodeFactory::MakeOpAlwaysTrue(uint32_t options) {
   return MakeBase(OP_ALWAYS_TRUE, options, -1);
 }
 
 template <>
 EvalResult OpcodeEval<OP_ALWAYS_TRUE>(PolicyOpcode* opcode,
                                       const ParameterSet* param,
                                       MatchContext* context) {
   return EVAL_TRUE;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpAction:
 // Does not require input parameter.
 // Argument 0 contains the actual action to return.
 
-PolicyOpcode* OpcodeFactory::MakeOpAction(EvalResult action,
-                                          uint32 options) {
+PolicyOpcode* OpcodeFactory::MakeOpAction(EvalResult action, uint32_t options) {
   PolicyOpcode* opcode = MakeBase(OP_ACTION, options, 0);
   if (NULL == opcode) return NULL;
   opcode->SetArgument(0, action);
   return opcode;
 }
 
 template <>
 EvalResult OpcodeEval<OP_ACTION>(PolicyOpcode* opcode,
                                  const ParameterSet* param,
                                  MatchContext* context) {
   int action = 0;
   opcode->GetArgument(0, &action);
   return static_cast<EvalResult>(action);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpNumberMatch:
-// Requires a uint32 or void* in selected_param
+// Requires a uint32_t or void* in selected_param
 // Argument 0 is the stored number to match.
 // Argument 1 is the C++ type of the 0th argument.
 
-PolicyOpcode* OpcodeFactory::MakeOpNumberMatch(int16 selected_param,
-                                               uint32 match,
-                                               uint32 options) {
+PolicyOpcode* OpcodeFactory::MakeOpNumberMatch(int16_t selected_param,
+                                               uint32_t match,
+                                               uint32_t options) {
   PolicyOpcode* opcode = MakeBase(OP_NUMBER_MATCH, options, selected_param);
   if (NULL == opcode) return NULL;
   opcode->SetArgument(0, match);
   opcode->SetArgument(1, UINT32_TYPE);
   return opcode;
 }
 
-PolicyOpcode* OpcodeFactory::MakeOpVoidPtrMatch(int16 selected_param,
+PolicyOpcode* OpcodeFactory::MakeOpVoidPtrMatch(int16_t selected_param,
                                                 const void* match,
-                                                uint32 options) {
+                                                uint32_t options) {
   PolicyOpcode* opcode = MakeBase(OP_NUMBER_MATCH, options, selected_param);
   if (NULL == opcode) return NULL;
   opcode->SetArgument(0, match);
   opcode->SetArgument(1, VOIDPTR_TYPE);
   return opcode;
 }
 
 template <>
 EvalResult OpcodeEval<OP_NUMBER_MATCH>(PolicyOpcode* opcode,
                                        const ParameterSet* param,
                                        MatchContext* context) {
-  uint32 value_uint32 = 0;
+  uint32_t value_uint32 = 0;
   if (param->Get(&value_uint32)) {
-    uint32 match_uint32 = 0;
+    uint32_t match_uint32 = 0;
     opcode->GetArgument(0, &match_uint32);
     return (match_uint32 != value_uint32)? EVAL_FALSE : EVAL_TRUE;
   } else {
     const void* value_ptr = NULL;
     if (param->Get(&value_ptr)) {
       const void* match_ptr = NULL;
       opcode->GetArgument(0, &match_ptr);
       return (match_ptr != value_ptr)? EVAL_FALSE : EVAL_TRUE;
     }
   }
   return EVAL_ERROR;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpNumberMatchRange
-// Requires a uint32 in selected_param.
+// Requires a uint32_t in selected_param.
 // Argument 0 is the stored lower bound to match.
 // Argument 1 is the stored upper bound to match.
 
-PolicyOpcode* OpcodeFactory::MakeOpNumberMatchRange(int16 selected_param,
-                                                    uint32 lower_bound,
-                                                    uint32 upper_bound,
-                                                    uint32 options) {
+PolicyOpcode* OpcodeFactory::MakeOpNumberMatchRange(int16_t selected_param,
+                                                    uint32_t lower_bound,
+                                                    uint32_t upper_bound,
+                                                    uint32_t options) {
   if (lower_bound > upper_bound) {
     return NULL;
   }
   PolicyOpcode* opcode = MakeBase(OP_NUMBER_MATCH_RANGE, options,
                                   selected_param);
   if (NULL == opcode) return NULL;
   opcode->SetArgument(0, lower_bound);
   opcode->SetArgument(1, upper_bound);
   return opcode;
 }
 
 template <>
 EvalResult OpcodeEval<OP_NUMBER_MATCH_RANGE>(PolicyOpcode* opcode,
                                              const ParameterSet* param,
                                              MatchContext* context) {
-  uint32 value = 0;
+  uint32_t value = 0;
   if (!param->Get(&value)) return EVAL_ERROR;
 
-  uint32 lower_bound = 0;
-  uint32 upper_bound = 0;
+  uint32_t lower_bound = 0;
+  uint32_t upper_bound = 0;
   opcode->GetArgument(0, &lower_bound);
   opcode->GetArgument(1, &upper_bound);
   return((lower_bound <= value) && (upper_bound >= value))?
     EVAL_TRUE : EVAL_FALSE;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpNumberAndMatch:
-// Requires a uint32 in selected_param.
+// Requires a uint32_t in selected_param.
 // Argument 0 is the stored number to match.
 
-PolicyOpcode* OpcodeFactory::MakeOpNumberAndMatch(int16 selected_param,
-                                                  uint32 match,
-                                                  uint32 options) {
+PolicyOpcode* OpcodeFactory::MakeOpNumberAndMatch(int16_t selected_param,
+                                                  uint32_t match,
+                                                  uint32_t options) {
   PolicyOpcode* opcode = MakeBase(OP_NUMBER_AND_MATCH, options, selected_param);
   if (NULL == opcode) return NULL;
   opcode->SetArgument(0, match);
   return opcode;
 }
 
 template <>
 EvalResult OpcodeEval<OP_NUMBER_AND_MATCH>(PolicyOpcode* opcode,
                                            const ParameterSet* param,
                                            MatchContext* context) {
-  uint32 value = 0;
+  uint32_t value = 0;
   if (!param->Get(&value)) return EVAL_ERROR;
 
-  uint32 number = 0;
+  uint32_t number = 0;
   opcode->GetArgument(0, &number);
   return (number & value)? EVAL_TRUE : EVAL_FALSE;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Opcode OpWStringMatch:
 // Requires a wchar_t* in selected_param.
 // Argument 0 is the byte displacement of the stored string.
 // Argument 1 is the lenght in chars of the stored string.
 // Argument 2 is the offset to apply on the input string. It has special values.
 // as noted in the header file.
 // Argument 3 is the string matching options.
 
-PolicyOpcode* OpcodeFactory::MakeOpWStringMatch(int16 selected_param,
+PolicyOpcode* OpcodeFactory::MakeOpWStringMatch(int16_t selected_param,
                                                 const wchar_t* match_str,
                                                 int start_position,
                                                 StringMatchOptions match_opts,
-                                                uint32 options) {
+                                                uint32_t options) {
   if (NULL == match_str) {
     return NULL;
   }
   if ('\0' == match_str[0]) {
     return NULL;
   }
 
   int lenght = lstrlenW(match_str);
 
   PolicyOpcode* opcode = MakeBase(OP_WSTRING_MATCH, options, selected_param);
@@ skipping 103 matching lines @@
       --source_len;
     } while (source_len >= match_len);
   }
   return EVAL_FALSE;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // OpcodeMaker (other member functions).
 
 PolicyOpcode* OpcodeFactory::MakeBase(OpcodeID opcode_id,
-                                      uint32 options,
-                                      int16 selected_param) {
+                                      uint32_t options,
+                                      int16_t selected_param) {
   if (memory_size() < sizeof(PolicyOpcode)) {
     return NULL;
   }
 
   // Create opcode using placement-new on the buffer memory.
   PolicyOpcode* opcode = new(memory_top_) PolicyOpcode();
 
   // Fill in the standard fields, that every opcode has.
   memory_top_ += sizeof(PolicyOpcode);
   opcode->opcode_id_ = opcode_id;
@@ skipping 80 matching lines @@
     OPCODE_EVAL(OP_WSTRING_MATCH, this, parameters, match);
     OPCODE_EVAL(OP_ACTION, this, parameters, match);
     default:
       return EVAL_ERROR;
   }
 }
 
 #undef OPCODE_EVAL
 
 }  // namespace sandbox