Switch to standard integer types in content/browser/.

content/browser/dom_storage/session_storage_database.cc

 // 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.
 
 #include "content/browser/dom_storage/session_storage_database.h"
 
+#include <stddef.h>
+
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
@@ skipping 124 matching lines @@
   const bool kOkIfExists = true;
   if (!CreateNamespace(namespace_id, kOkIfExists, &batch))
     return false;
 
   std::string map_id;
   bool exists;
   if (!GetMapForArea(namespace_id, origin.spec(), leveldb::ReadOptions(),
                      &exists, &map_id))
     return false;
   if (exists) {
-    int64 ref_count;
+    int64_t ref_count;
     if (!GetMapRefCount(map_id, &ref_count))
       return false;
     if (ref_count > 1) {
       if (!DeepCopyArea(namespace_id, origin, !clear_all_first,
                         &map_id, &batch))
         return false;
     } else if (clear_all_first) {
       if (!ClearMap(map_id, &batch))
         return false;
     }
@@ skipping 366 matching lines @@
 }
 
 bool SessionStorageDatabase::CreateMapForArea(const std::string& namespace_id,
                                               const GURL& origin,
                                               std::string* map_id,
                                               leveldb::WriteBatch* batch) {
   leveldb::Slice next_map_id_key = NextMapIdKey();
   leveldb::Status s = db_->Get(leveldb::ReadOptions(), next_map_id_key, map_id);
   if (!DatabaseErrorCheck(s.ok() || s.IsNotFound()))
     return false;
-  int64 next_map_id = 0;
+  int64_t next_map_id = 0;
   if (s.IsNotFound()) {
     *map_id = "0";
   } else {
     bool conversion_ok = base::StringToInt64(*map_id, &next_map_id);
     if (!ConsistencyCheck(conversion_ok))
       return false;
   }
   batch->Put(next_map_id_key, base::Int64ToString(++next_map_id));
   std::string namespace_key = NamespaceKey(namespace_id, origin.spec());
   batch->Put(namespace_key, *map_id);
@@ skipping 54 matching lines @@
       // Convert the raw data stored in base::string16 to raw data stored in
       // std::string.
       const char* data = reinterpret_cast<const char*>(value.string().data());
       size_t size = value.string().size() * 2;
       batch->Put(key, leveldb::Slice(data, size));
     }
   }
 }
 
 bool SessionStorageDatabase::GetMapRefCount(const std::string& map_id,
-                                            int64* ref_count) {
+                                            int64_t* ref_count) {
   std::string ref_count_string;
   leveldb::Status s = db_->Get(leveldb::ReadOptions(),
                                MapRefCountKey(map_id), &ref_count_string);
   if (!ConsistencyCheck(s.ok()))
     return false;
   bool conversion_ok = base::StringToInt64(ref_count_string, ref_count);
   return ConsistencyCheck(conversion_ok);
 }
 
 bool SessionStorageDatabase::IncreaseMapRefCount(const std::string& map_id,
                                                  leveldb::WriteBatch* batch) {
   // Increase the ref count for the map.
-  int64 old_ref_count;
+  int64_t old_ref_count;
   if (!GetMapRefCount(map_id, &old_ref_count))
     return false;
   batch->Put(MapRefCountKey(map_id), base::Int64ToString(++old_ref_count));
   return true;
 }
 
 bool SessionStorageDatabase::DecreaseMapRefCount(const std::string& map_id,
                                                  int decrease,
                                                  leveldb::WriteBatch* batch) {
   // Decrease the ref count for the map.
-  int64 ref_count;
+  int64_t ref_count;
   if (!GetMapRefCount(map_id, &ref_count))
     return false;
   if (!ConsistencyCheck(decrease <= ref_count))
     return false;
   ref_count -= decrease;
   if (ref_count > 0) {
     batch->Put(MapRefCountKey(map_id), base::Int64ToString(ref_count));
   } else {
     // Clear all keys in the map.
     if (!ClearMap(map_id, batch))
@@ skipping 73 matching lines @@
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace content