Switch to standard integer types in content/browser/.

content/browser/dom_storage/session_storage_database_unittest.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 <stdint.h>
+
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "url/gurl.h"
 
 namespace content {
 
 class SessionStorageDatabaseTest : public testing::Test {
  public:
   SessionStorageDatabaseTest();
   ~SessionStorageDatabaseTest() override;
   void SetUp() override;
 
  protected:
   typedef std::map<std::string, std::string> DataMap;
 
   // Helpers.
   static bool IsNamespaceKey(const std::string& key,
                              std::string* namespace_id);
   static bool IsNamespaceOriginKey(const std::string& key,
                                    std::string* namespace_id);
-  static bool IsMapRefCountKey(const std::string& key,
-                               int64* map_id);
-  static bool IsMapValueKey(const std::string& key,
-                            int64* map_id);
+  static bool IsMapRefCountKey(const std::string& key, int64_t* map_id);
+  static bool IsMapValueKey(const std::string& key, int64_t* map_id);
   void ResetDatabase();
   void ReadData(DataMap* data) const;
   void CheckDatabaseConsistency() const;
   void CheckEmptyDatabase() const;
   void DumpData() const;
   void CheckAreaData(const std::string& namespace_id,
                      const GURL& origin,
                      const DOMStorageValuesMap& reference) const;
   void CompareValuesMaps(const DOMStorageValuesMap& map1,
                          const DOMStorageValuesMap& map2) const;
   void CheckNamespaceIds(
       const std::set<std::string>& expected_namespace_ids) const;
   void CheckOrigins(
       const std::string& namespace_id,
       const std::set<GURL>& expected_origins) const;
   std::string GetMapForArea(const std::string& namespace_id,
                             const GURL& origin) const;
-  int64 GetMapRefCount(const std::string& map_id) const;
+  int64_t GetMapRefCount(const std::string& map_id) const;
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<SessionStorageDatabase> db_;
 
   // Test data.
   const GURL kOrigin1;
   const GURL kOrigin2;
   const std::string kNamespace1;
   const std::string kNamespace2;
   const std::string kNamespaceClone;
@@ skipping 69 matching lines @@
   // Key is of the form "namespace-<namespaceid>-<origin>", and the value
   // is the map id.
   *namespace_id = key.substr(
       namespace_prefix.length(),
       second_dash - namespace_prefix.length());
   return true;
 }
 
 // static
 bool SessionStorageDatabaseTest::IsMapRefCountKey(const std::string& key,
-                                                  int64* map_id) {
+                                                  int64_t* map_id) {
   std::string map_prefix = "map-";
   if (key.find(map_prefix) != 0)
     return false;
   size_t second_dash = key.find('-', map_prefix.length());
   if (second_dash != key.length() - 1)
     return false;
   // Key is of the form "map-<mapid>-" and the value is the ref count.
   std::string map_id_str = key.substr(map_prefix.length(),
                                       second_dash - map_prefix.length());
   bool conversion_ok = base::StringToInt64(map_id_str, map_id);
   EXPECT_TRUE(conversion_ok);
   return true;
 }
 
 // static
 bool SessionStorageDatabaseTest::IsMapValueKey(const std::string& key,
-                                               int64* map_id) {
+                                               int64_t* map_id) {
   std::string map_prefix = "map-";
   if (key.find(map_prefix) != 0)
     return false;
   size_t second_dash = key.find('-', map_prefix.length());
   if (second_dash == std::string::npos || second_dash == key.length() - 1)
     return false;
   // Key is of the form "map-<mapid>-key".
   std::string map_id_str = key.substr(map_prefix.length(),
                                       second_dash - map_prefix.length());
   bool conversion_ok = base::StringToInt64(map_id_str, map_id);
@@ skipping 28 matching lines @@
     for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) {
       ASSERT_TRUE(it->first == next_map_id_key);
     }
     return;
   }
   ++valid_keys;
 
   // Iterate the "namespace-" keys.
   std::set<std::string> found_namespace_ids;
   std::set<std::string> namespaces_with_areas;
-  std::map<int64, int64> expected_map_refcounts;
-  int64 max_map_id = -1;
+  std::map<int64_t, int64_t> expected_map_refcounts;
+  int64_t max_map_id = -1;
 
   for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) {
     std::string namespace_id;
     if (IsNamespaceKey(it->first, &namespace_id)) {
       found_namespace_ids.insert(namespace_id);
       ++valid_keys;
     } else if (IsNamespaceOriginKey(
         it->first, &namespace_id)) {
       // Check that the corresponding "namespace-<namespaceid>-" key exists. It
       // has been read by now, since the keys are stored in order.
       ASSERT_TRUE(found_namespace_ids.find(namespace_id) !=
                   found_namespace_ids.end());
       namespaces_with_areas.insert(namespace_id);
-      int64 map_id;
+      int64_t map_id;
       bool conversion_ok = base::StringToInt64(it->second, &map_id);
       ASSERT_TRUE(conversion_ok);
       ASSERT_GE(map_id, 0);
       ++expected_map_refcounts[map_id];
       max_map_id = std::max(map_id, max_map_id);
       ++valid_keys;
     }
   }
   // Check that there are no leftover "namespace-namespaceid-" keys without
   // associated areas.
   ASSERT_EQ(found_namespace_ids.size(), namespaces_with_areas.size());
 
   if (max_map_id != -1) {
     // The database contains maps.
     ASSERT_TRUE(data.find(next_map_id_key) != data.end());
-    int64 next_map_id;
+    int64_t next_map_id;
     bool conversion_ok =
         base::StringToInt64(data[next_map_id_key], &next_map_id);
     ASSERT_TRUE(conversion_ok);
     ASSERT_GT(next_map_id, max_map_id);
   }
 
   // Iterate the "map-" keys.
-  std::set<int64> found_map_ids;
+  std::set<int64_t> found_map_ids;
   for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) {
-    int64 map_id;
+    int64_t map_id;
     if (IsMapRefCountKey(it->first, &map_id)) {
-      int64 ref_count;
+      int64_t ref_count;
       bool conversion_ok = base::StringToInt64(it->second, &ref_count);
       ASSERT_TRUE(conversion_ok);
       // Check that the map is not stale.
       ASSERT_GT(ref_count, 0);
       ASSERT_TRUE(expected_map_refcounts.find(map_id) !=
                   expected_map_refcounts.end());
       ASSERT_EQ(expected_map_refcounts[map_id], ref_count);
       // Mark the map as existing.
       expected_map_refcounts.erase(map_id);
       found_map_ids.insert(map_id);
@@ skipping 21 matching lines @@
   if (data.find(SessionStorageDatabase::NextMapIdKey()) != data.end())
     ++valid_keys;
   EXPECT_EQ(valid_keys, data.size());
 }
 
 void SessionStorageDatabaseTest::DumpData() const {
   LOG(WARNING) << "---- Session storage contents";
   scoped_ptr<leveldb::Iterator> it(
       db_->db_->NewIterator(leveldb::ReadOptions()));
   for (it->SeekToFirst(); it->Valid(); it->Next()) {
-    int64 dummy_map_id;
+    int64_t dummy_map_id;
     if (IsMapValueKey(it->key().ToString(), &dummy_map_id)) {
       // Convert the value back to base::string16.
       base::string16 value;
       size_t len = it->value().size() / sizeof(base::char16);
       value.resize(len);
       value.assign(
           reinterpret_cast<const base::char16*>(it->value().data()), len);
       LOG(WARNING) << it->key().ToString() << ": " << value;
     } else {
       LOG(WARNING) << it->key().ToString() << ": " << it->value().ToString();
@@ skipping 54 matching lines @@
 std::string SessionStorageDatabaseTest::GetMapForArea(
     const std::string& namespace_id, const GURL& origin) const {
   bool exists;
   std::string map_id;
   EXPECT_TRUE(db_->GetMapForArea(namespace_id, origin.spec(),
                                  leveldb::ReadOptions(), &exists, &map_id));
   EXPECT_TRUE(exists);
   return map_id;
 }
 
-int64 SessionStorageDatabaseTest::GetMapRefCount(
+int64_t SessionStorageDatabaseTest::GetMapRefCount(
     const std::string& map_id) const {
-  int64 ref_count;
+  int64_t ref_count;
   EXPECT_TRUE(db_->GetMapRefCount(map_id, &ref_count));
   return ref_count;
 }
 
 TEST_F(SessionStorageDatabaseTest, EmptyDatabaseSanityCheck) {
   // An empty database should be valid.
   CheckDatabaseConsistency();
 }
 
 TEST_F(SessionStorageDatabaseTest, WriteDataForOneOrigin) {
@@ skipping 400 matching lines @@
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin1));
   EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2));
   // Check that also the namespace start key was deleted.
   CheckDatabaseConsistency();
 }
 
 
 }  // namespace content