Switch to standard integer types in sync/.

sync/internal_api/sync_rollback_manager_unittest.cc

 // Copyright 2014 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/internal_api/sync_rollback_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/internal_api/public/test/test_internal_components_factory.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
@@ skipping 17 matching lines @@
 
 class TestChangeDelegate : public SyncManager::ChangeDelegate {
  public:
   TestChangeDelegate() {
     ON_CALL(*this, OnChangesApplied(_, _, _, _))
         .WillByDefault(
             WithArgs<3>(Invoke(this,
                                &TestChangeDelegate::VerifyDeletes)));
   }
 
-  void add_expected_delete(int64 v) {
-    expected_deletes_.insert(v);
-  }
+  void add_expected_delete(int64_t v) { expected_deletes_.insert(v); }
 
   MOCK_METHOD4(OnChangesApplied,
                void(ModelType model_type,
-                    int64 model_version,
+                    int64_t model_version,
                     const BaseTransaction* trans,
                     const ImmutableChangeRecordList& changes));
   MOCK_METHOD1(OnChangesComplete, void(ModelType model_type));
 
  private:
   void VerifyDeletes(const ImmutableChangeRecordList& changes) {
-    std::set<int64> deleted;
+    std::set<int64_t> deleted;
     for (size_t i = 0; i < changes.Get().size(); ++i) {
       const ChangeRecord& change = (changes.Get())[i];
       EXPECT_EQ(ChangeRecord::ACTION_DELETE, change.action);
       EXPECT_TRUE(deleted.find(change.id) == deleted.end());
       deleted.insert(change.id);
     }
     EXPECT_TRUE(expected_deletes_ == deleted);
   }
 
-  std::set<int64> expected_deletes_;
+  std::set<int64_t> expected_deletes_;
 };
 
 class SyncRollbackManagerTest : public testing::Test,
                                 public SyncManager::Observer {
  protected:
   void SetUp() override {
     CHECK(temp_dir_.CreateUniqueTempDir());
 
     worker_ = new FakeModelWorker(GROUP_UI);
   }
 
   MOCK_METHOD1(OnSyncCycleCompleted,
                void(const sessions::SyncSessionSnapshot&));
   MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));
   MOCK_METHOD4(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&,
                     const WeakHandle<DataTypeDebugInfoListener>&,
                     bool, ModelTypeSet));
   MOCK_METHOD1(OnActionableError, void(const SyncProtocolError&));
   MOCK_METHOD1(OnMigrationRequested, void(ModelTypeSet));;
   MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));
 
   void OnConfigDone(bool success) {
     EXPECT_TRUE(success);
   }
 
-  int64 CreateEntry(UserShare* user_share, ModelType type,
-                    const std::string& client_tag) {
+  int64_t CreateEntry(UserShare* user_share,
+                      ModelType type,
+                      const std::string& client_tag) {
     WriteTransaction trans(FROM_HERE, user_share);
     WriteNode node(&trans);
     EXPECT_EQ(WriteNode::INIT_SUCCESS,
               node.InitUniqueByCreation(type, client_tag));
     return node.GetId();
   }
 
   void InitManager(SyncManager* manager, ModelTypeSet types,
                    TestChangeDelegate* delegate,
                    InternalComponentsFactory::StorageOption storage_option) {
@@ skipping 76 matching lines @@
 
 TEST_F(SyncRollbackManagerTest, RollbackBasic) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
   SyncRollbackManager rollback_manager;
   InitManager(&rollback_manager, ModelTypeSet(PREFERENCES), &delegate,
               InternalComponentsFactory::STORAGE_ON_DISK);
 
   // Simulate a new entry added during type initialization.
-  int64 new_pref_id =
+  int64_t new_pref_id =
       CreateEntry(rollback_manager.GetUserShare(), PREFERENCES, "pref2");
 
   delegate.add_expected_delete(new_pref_id);
   EXPECT_CALL(delegate, OnChangesApplied(_, _, _, _))
       .Times(1)
       .WillOnce(DoDefault());
   EXPECT_CALL(delegate, OnChangesComplete(_)).Times(1);
   EXPECT_CALL(*this, OnActionableError(Truly(IsRollbackDoneAction))).Times(1);
 
   ModelSafeRoutingInfo routing_info;
   routing_info[PREFERENCES] = GROUP_UI;
   rollback_manager.StartSyncingNormally(routing_info, base::Time());
 }
 
 TEST_F(SyncRollbackManagerTest, NoRollbackOfTypesNotBackedUp) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
   SyncRollbackManager rollback_manager;
   InitManager(&rollback_manager, ModelTypeSet(PREFERENCES, APPS), &delegate,
               InternalComponentsFactory::STORAGE_ON_DISK);
 
   // Simulate new entry added during type initialization.
-  int64 new_pref_id =
+  int64_t new_pref_id =
       CreateEntry(rollback_manager.GetUserShare(), PREFERENCES, "pref2");
   CreateEntry(rollback_manager.GetUserShare(), APPS, "app1");
 
   delegate.add_expected_delete(new_pref_id);
   EXPECT_CALL(delegate, OnChangesApplied(_, _, _, _))
       .Times(1)
       .WillOnce(DoDefault());
   EXPECT_CALL(delegate, OnChangesComplete(_)).Times(1);
 
   ModelSafeRoutingInfo routing_info;
@@ skipping 31 matching lines @@
   // Test graceful shutdown on initialization failure.
   scoped_ptr<SyncRollbackManager> rollback_manager(
       new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), NULL,
               InternalComponentsFactory::STORAGE_ON_DISK);
 }
 
 }  // anonymous namespace
 
 }  // namespace syncer