Switch to standard integer types in content/browser/.

content/browser/dom_storage/dom_storage_area.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 CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_AREA_H_
 #define CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_AREA_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string16.h"
 #include "content/common/content_export.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "url/gurl.h"
 
 namespace content {
 
@@ skipping 18 matching lines @@
   // rescheduled and will be flushed at the scheduled time after which
   // aggressive flushing will commence.
   static void EnableAggressiveCommitDelay();
 
   // Local storage. Backed on disk if directory is nonempty.
   DOMStorageArea(const GURL& origin,
                  const base::FilePath& directory,
                  DOMStorageTaskRunner* task_runner);
 
   // Session storage. Backed on disk if |session_storage_backing| is not NULL.
-  DOMStorageArea(int64 namespace_id,
+  DOMStorageArea(int64_t namespace_id,
                  const std::string& persistent_namespace_id,
                  const GURL& origin,
                  SessionStorageDatabase* session_storage_backing,
                  DOMStorageTaskRunner* task_runner);
 
   const GURL& origin() const { return origin_; }
-  int64 namespace_id() const { return namespace_id_; }
+  int64_t namespace_id() const { return namespace_id_; }
 
   // Writes a copy of the current set of values in the area to the |map|.
   void ExtractValues(DOMStorageValuesMap* map);
 
   unsigned Length();
   base::NullableString16 Key(unsigned index);
   base::NullableString16 GetItem(const base::string16& key);
   bool SetItem(const base::string16& key, const base::string16& value,
                base::NullableString16* old_value);
   bool RemoveItem(const base::string16& key, base::string16* old_value);
   bool Clear();
   void FastClear();
 
   DOMStorageArea* ShallowCopy(
-      int64 destination_namespace_id,
+      int64_t destination_namespace_id,
       const std::string& destination_persistent_namespace_id);
 
   bool HasUncommittedChanges() const;
   void ScheduleImmediateCommit();
 
   // Similar to Clear() but more optimized for just deleting
   // without raising events.
   void DeleteOrigin();
 
   // Frees up memory when possible. Typically, this method returns
@@ skipping 71 matching lines @@
   void OnCommitTimer();
   void PostCommitTask();
   void CommitChanges(const CommitBatch* commit_batch);
   void OnCommitComplete();
   base::TimeDelta ComputeCommitDelay() const;
 
   void ShutdownInCommitSequence();
 
   static bool s_aggressive_flushing_enabled_;
 
-  int64 namespace_id_;
+  int64_t namespace_id_;
   std::string persistent_namespace_id_;
   GURL origin_;
   base::FilePath directory_;
   scoped_refptr<DOMStorageTaskRunner> task_runner_;
   scoped_refptr<DOMStorageMap> map_;
   scoped_ptr<DOMStorageDatabaseAdapter> backing_;
   scoped_refptr<SessionStorageDatabase> session_storage_backing_;
   bool is_initial_import_done_;
   bool is_shutdown_;
   scoped_ptr<CommitBatch> commit_batch_;
   int commit_batches_in_flight_;
   base::TimeTicks start_time_;
   RateLimiter data_rate_limiter_;
   RateLimiter commit_rate_limiter_;
 
   DISALLOW_COPY_AND_ASSIGN(DOMStorageArea);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_AREA_H_