Remove kint64max.

storage/browser/quota/quota_manager.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.
 
 #ifndef STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_
 #define STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_
 
+#include <stdint.h>
+
 #include <deque>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "storage/browser/quota/quota_callbacks.h"
 #include "storage/browser/quota/quota_client.h"
 #include "storage/browser/quota/quota_database.h"
 #include "storage/browser/quota/quota_task.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "storage/browser/quota/storage_observer.h"
@@ skipping 23 matching lines @@
 
 class QuotaDatabase;
 class QuotaManagerProxy;
 class QuotaTemporaryStorageEvictor;
 class StorageMonitor;
 class UsageTracker;
 
 struct QuotaManagerDeleter;
 
 struct STORAGE_EXPORT UsageAndQuota {
-  int64 usage;
-  int64 global_limited_usage;
-  int64 quota;
-  int64 available_disk_space;
+  int64_t usage;
+  int64_t global_limited_usage;
+  int64_t quota;
+  int64_t available_disk_space;
 
   UsageAndQuota();
-  UsageAndQuota(int64 usage,
-                int64 global_limited_usage,
-                int64 quota,
-                int64 available_disk_space);
+  UsageAndQuota(int64_t usage,
+                int64_t global_limited_usage,
+                int64_t quota,
+                int64_t available_disk_space);
 };
 
 // TODO(calamity): Use this in the temporary storage eviction path.
 // An interface for deciding which origin's storage should be evicted when the
 // quota is exceeded.
 class STORAGE_EXPORT QuotaEvictionPolicy {
  public:
   virtual ~QuotaEvictionPolicy() {}
 
   // Returns the next origin to evict.  It might return an empty GURL when there
   // are no evictable origins.
   virtual void GetEvictionOrigin(
       const scoped_refptr<SpecialStoragePolicy>& special_storage_policy,
       const std::set<GURL>& exceptions,
-      const std::map<GURL, int64>& usage_map,
-      int64 global_quota,
+      const std::map<GURL, int64_t>& usage_map,
+      int64_t global_quota,
       const GetOriginCallback& callback) = 0;
 };
 
 // An interface called by QuotaTemporaryStorageEvictor.
 class STORAGE_EXPORT QuotaEvictionHandler {
  public:
   typedef StatusCallback EvictOriginDataCallback;
   typedef base::Callback<void(QuotaStatusCode status,
                               const UsageAndQuota& usage_and_quota)>
       UsageAndQuotaCallback;
 
   // Returns next origin to evict.  It might return an empty GURL when there are
   // no evictable origins.
   virtual void GetEvictionOrigin(StorageType type,
                                  const std::set<GURL>& extra_exceptions,
-                                 int64 global_quota,
+                                 int64_t global_quota,
                                  const GetOriginCallback& callback) = 0;
 
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
       const EvictOriginDataCallback& callback) = 0;
 
   virtual void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) = 0;
 
  protected:
   virtual ~QuotaEvictionHandler() {}
 };
 
 struct UsageInfo {
-  UsageInfo(const std::string& host, StorageType type, int64 usage)
-      : host(host),
-        type(type),
-        usage(usage) {}
+  UsageInfo(const std::string& host, StorageType type, int64_t usage)
+      : host(host), type(type), usage(usage) {}
   std::string host;
   StorageType type;
-  int64 usage;
+  int64_t usage;
 };
 
 // The quota manager class.  This class is instantiated per profile and
 // held by the profile.  With the exception of the constructor and the
 // proxy() method, all methods should only be called on the IO thread.
 class STORAGE_EXPORT QuotaManager
     : public QuotaTaskObserver,
       public QuotaEvictionHandler,
       public base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter> {
  public:
   typedef base::Callback<void(QuotaStatusCode,
-                              int64 /* usage */,
-                              int64 /* quota */)>
-      GetUsageAndQuotaCallback;
+                              int64_t /* usage */,
+                              int64_t /* quota */)> GetUsageAndQuotaCallback;
 
-  static const int64 kIncognitoDefaultQuotaLimit;
-  static const int64 kNoLimit;
+  static const int64_t kIncognitoDefaultQuotaLimit;
+  static const int64_t kNoLimit;
 
   QuotaManager(
       bool is_incognito,
       const base::FilePath& profile_path,
       const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
       const scoped_refptr<base::SequencedTaskRunner>& db_thread,
       const scoped_refptr<SpecialStoragePolicy>& special_storage_policy);
 
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
@@ skipping 25 matching lines @@
   void NotifyStorageAccessed(QuotaClient::ID client_id,
                              const GURL& origin,
                              StorageType type);
 
   // Called by clients via proxy.
   // Client storage must call this method whenever they have made any
   // modifications that change the amount of data stored in their storage.
   void NotifyStorageModified(QuotaClient::ID client_id,
                              const GURL& origin,
                              StorageType type,
-                             int64 delta);
+                             int64_t delta);
 
   // Used to avoid evicting origins with open pages.
   // A call to NotifyOriginInUse must be balanced by a later call
   // to NotifyOriginNoLongerInUse.
   void NotifyOriginInUse(const GURL& origin);
   void NotifyOriginNoLongerInUse(const GURL& origin);
   bool IsOriginInUse(const GURL& origin) const {
     return origins_in_use_.find(origin) != origins_in_use_.end();
   }
 
@@ skipping 20 matching lines @@
   void DeleteHostData(const std::string& host,
                       StorageType type,
                       int quota_client_mask,
                       const StatusCallback& callback);
 
   // Called by UI and internal modules.
   void GetAvailableSpace(const AvailableSpaceCallback& callback);
   void GetTemporaryGlobalQuota(const QuotaCallback& callback);
 
   // Ok to call with NULL callback.
-  void SetTemporaryGlobalOverrideQuota(int64 new_quota,
+  void SetTemporaryGlobalOverrideQuota(int64_t new_quota,
                                        const QuotaCallback& callback);
 
   void GetPersistentHostQuota(const std::string& host,
                               const QuotaCallback& callback);
   void SetPersistentHostQuota(const std::string& host,
-                              int64 new_quota,
+                              int64_t new_quota,
                               const QuotaCallback& callback);
   void GetGlobalUsage(StorageType type, const GlobalUsageCallback& callback);
   void GetHostUsage(const std::string& host, StorageType type,
                     const UsageCallback& callback);
   void GetHostUsage(const std::string& host, StorageType type,
                     QuotaClient::ID client_id,
                     const UsageCallback& callback);
 
   bool IsTrackingHostUsage(StorageType type, QuotaClient::ID client_id) const;
 
@@ skipping 16 matching lines @@
   void AddStorageObserver(StorageObserver* observer,
                           const StorageObserver::MonitorParams& params);
   void RemoveStorageObserver(StorageObserver* observer);
   void RemoveStorageObserverForFilter(StorageObserver* observer,
                                       const StorageObserver::Filter& filter);
 
   // Determines the portion of the temp pool that can be
   // utilized by a single host (ie. 5 for 20%).
   static const int kPerHostTemporaryPortion;
 
-  static const int64 kPerHostPersistentQuotaLimit;
+  static const int64_t kPerHostPersistentQuotaLimit;
 
   static const char kDatabaseName[];
 
   static const int kThresholdOfErrorsToBeBlacklisted;
 
   static const int kEvictionIntervalInMilliSeconds;
 
   static const char kTimeBetweenRepeatedOriginEvictionsHistogram[];
   static const char kEvictedOriginAccessedCountHistogram[];
   static const char kEvictedOriginTimeSinceAccessHistogram[];
 
   // These are kept non-const so that test code can change the value.
   // TODO(kinuko): Make this a real const value and add a proper way to set
   // the quota for syncable storage. (http://crbug.com/155488)
-  static int64 kMinimumPreserveForSystem;
-  static int64 kSyncableStorageDefaultHostQuota;
+  static int64_t kMinimumPreserveForSystem;
+  static int64_t kSyncableStorageDefaultHostQuota;
 
  protected:
   ~QuotaManager() override;
 
  private:
   friend class base::DeleteHelper<QuotaManager>;
   friend class base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter>;
   friend class content::QuotaManagerTest;
   friend class content::StorageMonitorTest;
   friend class content::MockQuotaManager;
@@ skipping 13 matching lines @@
   class DumpQuotaTableHelper;
   class DumpOriginInfoTableHelper;
 
   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
   typedef QuotaDatabase::OriginInfoTableEntry OriginInfoTableEntry;
   typedef std::vector<QuotaTableEntry> QuotaTableEntries;
   typedef std::vector<OriginInfoTableEntry> OriginInfoTableEntries;
 
   // Function pointer type used to store the function which returns the
   // available disk space for the disk containing the given FilePath.
-  typedef int64 (*GetAvailableDiskSpaceFn)(const base::FilePath&);
+  typedef int64_t (*GetAvailableDiskSpaceFn)(const base::FilePath&);
 
   typedef base::Callback<void(const QuotaTableEntries&)>
       DumpQuotaTableCallback;
   typedef base::Callback<void(const OriginInfoTableEntries&)>
       DumpOriginInfoTableCallback;
 
   typedef CallbackQueue<base::Closure> ClosureQueue;
-  typedef CallbackQueue<AvailableSpaceCallback, QuotaStatusCode, int64>
+  typedef CallbackQueue<AvailableSpaceCallback, QuotaStatusCode, int64_t>
       AvailableSpaceCallbackQueue;
-  typedef CallbackQueueMap<QuotaCallback, std::string, QuotaStatusCode, int64>
+  typedef CallbackQueueMap<QuotaCallback, std::string, QuotaStatusCode, int64_t>
       HostQuotaCallbackMap;
 
   struct EvictionContext {
     EvictionContext();
     virtual ~EvictionContext();
     GURL evicted_origin;
     StorageType evicted_type;
 
     EvictOriginDataCallback evict_origin_data_callback;
   };
@@ skipping 17 matching lines @@
   // Extract cached origins list from the usage tracker.
   // (Might return empty list if no origin is tracked by the tracker.)
   void GetCachedOrigins(StorageType type, std::set<GURL>* origins);
 
   // These internal methods are separately defined mainly for testing.
   void NotifyStorageAccessedInternal(
       QuotaClient::ID client_id,
       const GURL& origin,
       StorageType type,
       base::Time accessed_time);
-  void NotifyStorageModifiedInternal(
-      QuotaClient::ID client_id,
-      const GURL& origin,
-      StorageType type,
-      int64 delta,
-      base::Time modified_time);
+  void NotifyStorageModifiedInternal(QuotaClient::ID client_id,
+                                     const GURL& origin,
+                                     StorageType type,
+                                     int64_t delta,
+                                     base::Time modified_time);
 
   void DumpQuotaTable(const DumpQuotaTableCallback& callback);
   void DumpOriginInfoTable(const DumpOriginInfoTableCallback& callback);
 
   void DeleteOriginDataInternal(const GURL& origin,
                                 StorageType type,
                                 int quota_client_mask,
                                 bool is_eviction,
                                 const StatusCallback& callback);
 
   // Methods for eviction logic.
   void StartEviction();
   void DeleteOriginFromDatabase(const GURL& origin,
                                 StorageType type,
                                 bool is_eviction);
 
   void DidOriginDataEvicted(QuotaStatusCode status);
 
   void ReportHistogram();
-  void DidGetTemporaryGlobalUsageForHistogram(int64 usage,
-                                              int64 unlimited_usage);
-  void DidGetPersistentGlobalUsageForHistogram(int64 usage,
-                                               int64 unlimited_usage);
+  void DidGetTemporaryGlobalUsageForHistogram(int64_t usage,
+                                              int64_t unlimited_usage);
+  void DidGetPersistentGlobalUsageForHistogram(int64_t usage,
+                                               int64_t unlimited_usage);
 
   std::set<GURL> GetEvictionOriginExceptions(
       const std::set<GURL>& extra_exceptions);
   void DidGetEvictionOrigin(const GetOriginCallback& callback,
                             const GURL& origin);
 
   // QuotaEvictionHandler.
   void GetEvictionOrigin(StorageType type,
                          const std::set<GURL>& extra_exceptions,
-                         int64 global_quota,
+                         int64_t global_quota,
                          const GetOriginCallback& callback) override;
   void EvictOriginData(const GURL& origin,
                        StorageType type,
                        const EvictOriginDataCallback& callback) override;
   void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) override;
 
   void GetLRUOrigin(StorageType type, const GetOriginCallback& callback);
 
   void DidSetTemporaryGlobalOverrideQuota(const QuotaCallback& callback,
-                                          const int64* new_quota,
+                                          const int64_t* new_quota,
                                           bool success);
   void DidGetPersistentHostQuota(const std::string& host,
-                                 const int64* quota,
+                                 const int64_t* quota,
                                  bool success);
   void DidSetPersistentHostQuota(const std::string& host,
                                  const QuotaCallback& callback,
-                                 const int64* new_quota,
+                                 const int64_t* new_quota,
                                  bool success);
-  void DidInitialize(int64* temporary_quota_override,
-                     int64* desired_available_space,
+  void DidInitialize(int64_t* temporary_quota_override,
+                     int64_t* desired_available_space,
                      bool success);
   void DidGetLRUOrigin(const GURL* origin,
                        bool success);
   void DidGetInitialTemporaryGlobalQuota(QuotaStatusCode status,
-                                         int64 quota_unused);
+                                         int64_t quota_unused);
   void DidInitializeTemporaryOriginsInfo(bool success);
-  void DidGetAvailableSpace(int64 space);
+  void DidGetAvailableSpace(int64_t space);
   void DidDatabaseWork(bool success);
 
   void DeleteOnCorrectThread() const;
 
   void PostTaskAndReplyWithResultForDBThread(
       const tracked_objects::Location& from_here,
       const base::Callback<bool(QuotaDatabase*)>& task,
       const base::Callback<void(bool)>& reply);
 
   const bool is_incognito_;
@@ skipping 20 matching lines @@
   scoped_ptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_;
   EvictionContext eviction_context_;
   scoped_ptr<QuotaEvictionPolicy> temporary_storage_eviction_policy_;
   bool is_getting_eviction_origin_;
 
   ClosureQueue db_initialization_callbacks_;
   AvailableSpaceCallbackQueue available_space_callbacks_;
   HostQuotaCallbackMap persistent_host_quota_callbacks_;
 
   bool temporary_quota_initialized_;
-  int64 temporary_quota_override_;
+  int64_t temporary_quota_override_;
 
-  int64 desired_available_space_;
+  int64_t desired_available_space_;
 
   // Map from origin to count.
   std::map<GURL, int> origins_in_use_;
   // Map from origin to error count.
   std::map<GURL, int> origins_in_error_;
 
   scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
 
   base::RepeatingTimer histogram_timer_;
 
@@ skipping 11 matching lines @@
 
 struct QuotaManagerDeleter {
   static void Destruct(const QuotaManager* manager) {
     manager->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_