Switch to standard integer types in sync/.

sync/syncable/directory_backing_store_unittest.cc

 // Copyright 2012 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 "sync/syncable/directory_backing_store.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "build/build_config.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/test/scoped_error_ignorer.h"
 #include "sql/test/test_helpers.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
@@ skipping 18 matching lines @@
   scoped_ptr<EntryKernel> entry(new EntryKernel());
   std::string id_string = base::Int64ToString(id) + id_suffix;
   entry->put(ID, Id::CreateFromClientString(id_string));
   entry->put(META_HANDLE, id);
   entry->mark_dirty(NULL);
   return entry;
 }
 
 }  // namespace
 
-SYNC_EXPORT extern const int32 kCurrentDBVersion;
+SYNC_EXPORT extern const int32_t kCurrentDBVersion;
 
 class MigrationTest : public testing::TestWithParam<int> {
  public:
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
 
  protected:
   std::string GetUsername() {
     return "nick@chromium.org";
   }
 
@@ skipping 206 matching lines @@
 
 // Helper functions for testing.
 
 enum ShouldIncludeDeletedItems {
   INCLUDE_DELETED_ITEMS,
   DONT_INCLUDE_DELETED_ITEMS
 };
 
 // Returns a map from metahandle -> expected legacy time (in proto
 // format).
-std::map<int64, int64> GetExpectedLegacyMetaProtoTimes(
+std::map<int64_t, int64_t> GetExpectedLegacyMetaProtoTimes(
     enum ShouldIncludeDeletedItems include_deleted) {
-  std::map<int64, int64> expected_legacy_meta_proto_times;
+  std::map<int64_t, int64_t> expected_legacy_meta_proto_times;
   expected_legacy_meta_proto_times[1] = LEGACY_META_PROTO_TIMES(1);
   if (include_deleted == INCLUDE_DELETED_ITEMS) {
     expected_legacy_meta_proto_times[2] = LEGACY_META_PROTO_TIMES(2);
     expected_legacy_meta_proto_times[4] = LEGACY_META_PROTO_TIMES(4);
     expected_legacy_meta_proto_times[5] = LEGACY_META_PROTO_TIMES(5);
   }
   expected_legacy_meta_proto_times[6] = LEGACY_META_PROTO_TIMES(6);
   expected_legacy_meta_proto_times[7] = LEGACY_META_PROTO_TIMES(7);
   expected_legacy_meta_proto_times[8] = LEGACY_META_PROTO_TIMES(8);
   expected_legacy_meta_proto_times[9] = LEGACY_META_PROTO_TIMES(9);
   expected_legacy_meta_proto_times[10] = LEGACY_META_PROTO_TIMES(10);
   expected_legacy_meta_proto_times[11] = LEGACY_META_PROTO_TIMES(11);
   expected_legacy_meta_proto_times[12] = LEGACY_META_PROTO_TIMES(12);
   expected_legacy_meta_proto_times[13] = LEGACY_META_PROTO_TIMES(13);
   expected_legacy_meta_proto_times[14] = LEGACY_META_PROTO_TIMES(14);
   return expected_legacy_meta_proto_times;
 }
 
 // Returns a map from metahandle -> expected time (in proto format).
-std::map<int64, int64> GetExpectedMetaProtoTimes(
+std::map<int64_t, int64_t> GetExpectedMetaProtoTimes(
     enum ShouldIncludeDeletedItems include_deleted) {
-  std::map<int64, int64> expected_meta_proto_times;
+  std::map<int64_t, int64_t> expected_meta_proto_times;
   expected_meta_proto_times[1] = META_PROTO_TIMES(1);
   if (include_deleted == INCLUDE_DELETED_ITEMS) {
     expected_meta_proto_times[2] = META_PROTO_TIMES(2);
     expected_meta_proto_times[4] = META_PROTO_TIMES(4);
     expected_meta_proto_times[5] = META_PROTO_TIMES(5);
   }
   expected_meta_proto_times[6] = META_PROTO_TIMES(6);
   expected_meta_proto_times[7] = META_PROTO_TIMES(7);
   expected_meta_proto_times[8] = META_PROTO_TIMES(8);
   expected_meta_proto_times[9] = META_PROTO_TIMES(9);
   expected_meta_proto_times[10] = META_PROTO_TIMES(10);
   expected_meta_proto_times[11] = META_PROTO_TIMES(11);
   expected_meta_proto_times[12] = META_PROTO_TIMES(12);
   expected_meta_proto_times[13] = META_PROTO_TIMES(13);
   expected_meta_proto_times[14] = META_PROTO_TIMES(14);
   return expected_meta_proto_times;
 }
 
 // Returns a map from metahandle -> expected time (as a Time object).
-std::map<int64, base::Time> GetExpectedMetaTimes() {
-  std::map<int64, base::Time> expected_meta_times;
-  const std::map<int64, int64>& expected_meta_proto_times =
+std::map<int64_t, base::Time> GetExpectedMetaTimes() {
+  std::map<int64_t, base::Time> expected_meta_times;
+  const std::map<int64_t, int64_t>& expected_meta_proto_times =
       GetExpectedMetaProtoTimes(INCLUDE_DELETED_ITEMS);
-  for (std::map<int64, int64>::const_iterator it =
+  for (std::map<int64_t, int64_t>::const_iterator it =
            expected_meta_proto_times.begin();
        it != expected_meta_proto_times.end(); ++it) {
     expected_meta_times[it->first] = ProtoTimeToTime(it->second);
   }
   return expected_meta_times;
 }
 
 // Extracts a map from metahandle -> time (in proto format) from the
 // given database.
-std::map<int64, int64> GetMetaProtoTimes(sql::Connection *db) {
+std::map<int64_t, int64_t> GetMetaProtoTimes(sql::Connection* db) {
   sql::Statement s(db->GetCachedStatement(
           SQL_FROM_HERE,
           "SELECT metahandle, mtime, server_mtime, ctime, server_ctime "
           "FROM metas"));
   EXPECT_EQ(5, s.ColumnCount());
-  std::map<int64, int64> meta_times;
+  std::map<int64_t, int64_t> meta_times;
   while (s.Step()) {
-    int64 metahandle = s.ColumnInt64(0);
-    int64 mtime = s.ColumnInt64(1);
-    int64 server_mtime = s.ColumnInt64(2);
-    int64 ctime = s.ColumnInt64(3);
-    int64 server_ctime = s.ColumnInt64(4);
+    int64_t metahandle = s.ColumnInt64(0);
+    int64_t mtime = s.ColumnInt64(1);
+    int64_t server_mtime = s.ColumnInt64(2);
+    int64_t ctime = s.ColumnInt64(3);
+    int64_t server_ctime = s.ColumnInt64(4);
     EXPECT_EQ(mtime, server_mtime);
     EXPECT_EQ(mtime, ctime);
     EXPECT_EQ(mtime, server_ctime);
     meta_times[metahandle] = mtime;
   }
   EXPECT_TRUE(s.Succeeded());
   return meta_times;
 }
 
 ::testing::AssertionResult AssertTimesMatch(const char* t1_expr,
@@ skipping 22 matching lines @@
                       expected_time, entry_kernel.ref(SERVER_CTIME));
   EXPECT_PRED_FORMAT2(AssertTimesMatch,
                       expected_time, entry_kernel.ref(MTIME));
   EXPECT_PRED_FORMAT2(AssertTimesMatch,
                       expected_time, entry_kernel.ref(SERVER_MTIME));
 }
 
 // Expect that all the entries in |entries| have times matching those in
 // the given map (from metahandle to expect time).
 void ExpectTimes(const Directory::MetahandlesMap& handles_map,
-                 const std::map<int64, base::Time>& expected_times) {
+                 const std::map<int64_t, base::Time>& expected_times) {
   for (Directory::MetahandlesMap::const_iterator it = handles_map.begin();
        it != handles_map.end(); ++it) {
-    int64 meta_handle = it->first;
+    int64_t meta_handle = it->first;
     SCOPED_TRACE(meta_handle);
-    std::map<int64, base::Time>::const_iterator it2 =
+    std::map<int64_t, base::Time>::const_iterator it2 =
         expected_times.find(meta_handle);
     if (it2 == expected_times.end()) {
       ADD_FAILURE() << "Could not find expected time for " << meta_handle;
       continue;
     }
     ExpectTime(*it->second, it2->second);
   }
 }
 
 }  // namespace
@@ skipping 1440 matching lines @@
           "'c27e9f59-08ca-46f8-b0cc-f16a2ed778bb','Unknown',1263522064,"
           "-131078,'9010788312004066376x-6609234393368420856x',NULL, NULL);"));
   ASSERT_TRUE(connection->CommitTransaction());
 }
 
 
 // Helper definitions to create the version 81 DB tables.
 namespace {
 
 const int V80_ROW_COUNT = 13;
-const int64 V80_POSITIONS[V80_ROW_COUNT] = {
-  0,
-  -2097152,
-  -3145728,
-  1048576,
-  -4194304,
-  1048576,
-  1048576,
-  1048576,
-  2097152,
-  -1048576,
-  0,
-  -917504,
-  1048576
-};
+const int64_t V80_POSITIONS[V80_ROW_COUNT] = {
+    0,       -2097152, -3145728, 1048576, -4194304, 1048576, 1048576,
+    1048576, 2097152,  -1048576, 0,       -917504,  1048576};
 
 std::string V81_Ordinal(int n) {
   return Int64ToNodeOrdinal(V80_POSITIONS[n]).ToInternalValue();
 }
 
 }  // namespace
 
 // Unlike the earlier versions, the rows for version 81 are generated
 // programmatically to accurately handle unprintable characters for the
 // server_ordinal_in_parent field.
@@ skipping 2166 matching lines @@
   Directory::MetahandlesMap handles_map;
   JournalIndex  delete_journals;
   MetahandleSet metahandles_to_purge;
   Directory::KernelLoadInfo kernel_load_info;
   STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
             &kernel_load_info);
   size_t initial_size = handles_map.size();
   ASSERT_LT(0U, initial_size) << "Test requires handles_map to delete.";
-  int64 first_to_die = handles_map.begin()->second->ref(META_HANDLE);
+  int64_t first_to_die = handles_map.begin()->second->ref(META_HANDLE);
   MetahandleSet to_delete;
   to_delete.insert(first_to_die);
   EXPECT_TRUE(dbs->DeleteEntries(to_delete));
 
   STLDeleteValues(&handles_map);
   metahandles_to_purge.clear();
   dbs->LoadEntries(&handles_map, &metahandles_to_purge);
 
   EXPECT_EQ(initial_size - 1, handles_map.size());
   bool delete_failed = false;
@@ skipping 165 matching lines @@
   ASSERT_FALSE(dbs->SaveChanges(snapshot));
   // At this point the handler has been posted but not executed.
   ASSERT_FALSE(was_called);
   // Pump the message loop and see that it is executed.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
 }
 
 }  // namespace syncable
 }  // namespace syncer