Switch to standard integer types in extensions/browser/.

extensions/browser/quota_service.h

 // Copyright 2013 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.
 
 // The QuotaService uses heuristics to limit abusive requests
 // made by extensions.  In this model 'items' (e.g individual bookmarks) are
 // represented by a 'Bucket' that holds state for that item for one single
 // interval of time.  The interval of time is defined as 'how long we need to
 // watch an item (for a particular heuristic) before making a decision about
 // quota violations'.  A heuristic is two functions: one mapping input
 // arguments to a unique Bucket (the BucketMapper), and another to determine
 // if a new request involving such an item at a given time is a violation.
 
 #ifndef EXTENSIONS_BROWSER_QUOTA_SERVICE_H_
 #define EXTENSIONS_BROWSER_QUOTA_SERVICE_H_
 
+#include <stdint.h>
+
 #include <list>
 #include <map>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 
 class ExtensionFunction;
 
 namespace extensions {
 class QuotaLimitHeuristic;
@@ skipping 52 matching lines @@
 // function arguments to corresponding Buckets for each input arg, and 2) a
 // heuristic for determining if a new event involving a particular item
 // (represented by its Bucket) constitutes a quota violation.
 class QuotaLimitHeuristic {
  public:
   // Parameters to configure the amount of tokens allotted to individual
   // Bucket objects (see Below) and how often they are replenished.
   struct Config {
     // The maximum number of tokens a bucket can contain, and is refilled to
     // every epoch.
-    int64 refill_token_count;
+    int64_t refill_token_count;
 
     // Specifies how frequently the bucket is logically refilled with tokens.
     base::TimeDelta refill_interval;
   };
 
   // A Bucket is how the heuristic portrays an individual item (since quota
   // limits are per item) and all associated state for an item that needs to
   // carry through multiple calls to Apply.  It "holds" tokens, which are
   // debited and credited in response to new events involving the item being
   // being represented.  For convenience, instead of actually periodically
@@ skipping 13 matching lines @@
     // valid from |start| until the first refill interval elapses and it needs
     // to be reset again.
     void Reset(const Config& config, const base::TimeTicks& start);
 
     // The time at which the token count and next expiration should be reset,
     // via a call to Reset.
     const base::TimeTicks& expiration() { return expiration_; }
 
    private:
     base::TimeTicks expiration_;
-    int64 num_tokens_;
+    int64_t num_tokens_;
     DISALLOW_COPY_AND_ASSIGN(Bucket);
   };
   typedef std::list<Bucket*> BucketList;
 
   // A helper interface to retrieve the bucket corresponding to |args| from
   // the set of buckets (which is typically stored in the BucketMapper itself)
   // for this QuotaLimitHeuristic.
   class BucketMapper {
    public:
     virtual ~BucketMapper() {}
@@ skipping 62 matching lines @@
 class QuotaService::TimedLimit : public QuotaLimitHeuristic {
  public:
   TimedLimit(const Config& config, BucketMapper* map, const std::string& name)
       : QuotaLimitHeuristic(config, map, name) {}
   bool Apply(Bucket* bucket, const base::TimeTicks& event_time) override;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_QUOTA_SERVICE_H_