Switch to standard integer types in sandbox/.

sandbox/win/src/policy_low_level.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_low_level.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
 #include <string>
-#include <map>
-
-#include "base/basictypes.h"
 
 namespace {
 
   // A single rule can use at most this amount of memory.
   const size_t kRuleBufferSize = 1024*4;
 
   // The possible states of the string matching opcode generator.
   enum {
     PENDING_NONE,
     PENDING_ASTERISK,    // Have seen an '*' but have not generated an opcode.
     PENDING_QMARK,       // Have seen an '?' but have not generated an opcode.
   };
 
   // The category of the last character seen by the string matching opcode
   // generator.
-  const uint32 kLastCharIsNone = 0;
-  const uint32 kLastCharIsAlpha = 1;
-  const uint32 kLastCharIsWild = 2;
-  const uint32 kLastCharIsAsterisk = kLastCharIsWild + 4;
-  const uint32 kLastCharIsQuestionM = kLastCharIsWild + 8;
+  const uint32_t kLastCharIsNone = 0;
+  const uint32_t kLastCharIsAlpha = 1;
+  const uint32_t kLastCharIsWild = 2;
+  const uint32_t kLastCharIsAsterisk = kLastCharIsWild + 4;
+  const uint32_t kLastCharIsQuestionM = kLastCharIsWild + 8;
 }
 
 namespace sandbox {
 
 LowLevelPolicy::LowLevelPolicy(PolicyGlobal* policy_store)
     : policy_store_(policy_store) {
 }
 
 // Adding a rule is nothing more than pushing it into an stl container. Done()
 // is called for the rule in case the code that made the rule in the first
@@ skipping 20 matching lines @@
 // Here is where the heavy byte shuffling is done. We take all the rules and
 // 'compile' them into a single memory region. Now, the rules are in random
 // order so the first step is to reorganize them into a stl map that is keyed
 // by the service id and as a value contains a list with all the rules that
 // belong to that service. Then we enter the big for-loop where we carve a
 // memory zone for the opcodes and the data and call RebindCopy on each rule
 // so they all end up nicely packed in the policy_store_.
 bool LowLevelPolicy::Done() {
   typedef std::list<RuleNode> RuleNodes;
   typedef std::list<const PolicyRule*> RuleList;
-  typedef std::map<uint32, RuleList> Mmap;
+  typedef std::map<uint32_t, RuleList> Mmap;
   Mmap mmap;
 
   for (RuleNodes::iterator it = rules_.begin(); it != rules_.end(); ++it) {
     mmap[it->service].push_back(it->rule);
   }
 
   PolicyBuffer* current_buffer = &policy_store_->data[0];
   char* buffer_end = reinterpret_cast<char*>(current_buffer) +
     policy_store_->data_size;
   size_t avail_size =  policy_store_->data_size;
 
   for (Mmap::iterator it = mmap.begin(); it != mmap.end(); ++it) {
-    uint32 service = (*it).first;
+    uint32_t service = (*it).first;
     if (service >= kMaxServiceCount) {
       return false;
     }
     policy_store_->entry[service] = current_buffer;
 
     RuleList::iterator rules_it = (*it).second.begin();
     RuleList::iterator rules_it_end = (*it).second.end();
 
     size_t svc_opcode_count = 0;
 
@@ skipping 53 matching lines @@
 
 // This function get called from a simple state machine implemented in
 // AddStringMatch() which passes the current state (in state) and it passes
 // true in last_call if AddStringMatch() has finished processing the input
 // pattern string and this would be the last call to generate any pending
 // opcode. The skip_count is the currently accumulated number of '?' seen so
 // far and once the associated opcode is generated this function sets it back
 // to zero.
 bool PolicyRule::GenStringOpcode(RuleType rule_type,
                                  StringMatchOptions match_opts,
-                                 uint16 parameter, int state, bool last_call,
-                                 int* skip_count, base::string16* fragment) {
-
+                                 uint16_t parameter,
+                                 int state,
+                                 bool last_call,
+                                 int* skip_count,
+                                 base::string16* fragment) {
   // The last opcode must:
   //   1) Always clear the context.
   //   2) Preserve the negation.
   //   3) Remove the 'OR' mode flag.
-  uint32 options = kPolNone;
+  uint32_t options = kPolNone;
   if (last_call) {
     if (IF_NOT == rule_type) {
       options = kPolClearContext | kPolNegateEval;
     } else {
       options = kPolClearContext;
     }
   } else if (IF_NOT == rule_type) {
     options = kPolUseOREval | kPolNegateEval;
   }
 
@@ skipping 36 matching lines @@
                                              match_opts, options);
   }
   if (NULL == op) {
     return false;
   }
   ++buffer_->opcode_count;
   fragment->clear();
   return true;
 }
 
-bool PolicyRule::AddStringMatch(RuleType rule_type, int16 parameter,
+bool PolicyRule::AddStringMatch(RuleType rule_type,
+                                int16_t parameter,
                                 const wchar_t* string,
                                 StringMatchOptions match_opts) {
   if (done_) {
     // Do not allow to add more rules after generating the action opcode.
     return false;
   }
 
   const wchar_t* current_char = string;
-  uint32 last_char = kLastCharIsNone;
+  uint32_t last_char = kLastCharIsNone;
   int state = PENDING_NONE;
   int skip_count = 0;       // counts how many '?' we have seen in a row.
   base::string16 fragment;  // accumulates the non-wildcard part.
 
   while (L'\0' != *current_char) {
     switch (*current_char) {
       case L'*':
         if (kLastCharIsWild & last_char) {
           // '**' and '&*' is an error.
           return false;
@@ skipping 31 matching lines @@
   }
 
   if (!GenStringOpcode(rule_type, match_opts, parameter,
                        state, true, &skip_count, &fragment)) {
     return false;
   }
   return true;
 }
 
 bool PolicyRule::AddNumberMatch(RuleType rule_type,
-                                int16 parameter,
-                                uint32 number,
+                                int16_t parameter,
+                                uint32_t number,
                                 RuleOp comparison_op) {
   if (done_) {
     // Do not allow to add more rules after generating the action opcode.
     return false;
   }
-  uint32 opts = (rule_type == IF_NOT)? kPolNegateEval : kPolNone;
+  uint32_t opts = (rule_type == IF_NOT) ? kPolNegateEval : kPolNone;
 
   if (EQUAL == comparison_op) {
     if (NULL == opcode_factory_->MakeOpNumberMatch(parameter, number, opts)) {
       return false;
     }
   } else if (AND == comparison_op) {
     if (NULL == opcode_factory_->MakeOpNumberAndMatch(parameter, number,
                                                       opts)) {
       return false;
     }
@@ skipping 46 matching lines @@
 
   return true;
 }
 
 PolicyRule::~PolicyRule() {
   delete [] reinterpret_cast<char*>(buffer_);
   delete opcode_factory_;
 }
 
 }  // namespace sandbox