Switch to standard integer types in components/, part 2 of 4.

components/invalidation/impl/sync_invalidation_listener_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 <stddef.h>
+#include <stdint.h>
+
 #include <cstddef>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 17 matching lines @@
 
 const char kClientId[] = "client_id";
 const char kClientInfo[] = "client_info";
 
 const char kState[] = "state";
 const char kNewState[] = "new_state";
 
 const char kPayload1[] = "payload1";
 const char kPayload2[] = "payload2";
 
-const int64 kVersion1 = 1LL;
-const int64 kVersion2 = 2LL;
+const int64_t kVersion1 = 1LL;
+const int64_t kVersion2 = 2LL;
 
 const int kChromeSyncSourceId = 1004;
 
 struct AckHandleLessThan {
   bool operator()(const AckHandle& lhs, const AckHandle& rhs) const {
     return lhs.handle_data() < rhs.handle_data();
   }
 };
 
 typedef std::set<AckHandle, AckHandleLessThan> AckHandleSet;
@@ skipping 82 matching lines @@
 
   size_t GetInvalidationCount(const ObjectId& id) const {
     Map::const_iterator it = invalidations_.find(id);
     if (it == invalidations_.end()) {
       return 0;
     } else {
       return it->second.size();
     }
   }
 
-  int64 GetVersion(const ObjectId& id) const {
+  int64_t GetVersion(const ObjectId& id) const {
     Map::const_iterator it = invalidations_.find(id);
     if (it == invalidations_.end()) {
       ADD_FAILURE() << "No invalidations for ID " << ObjectIdToString(id);
       return 0;
     } else {
       return it->second.back().version();
     }
   }
 
   std::string GetPayload(const ObjectId& id) const {
@@ skipping 143 matching lines @@
     // drain the task queue before calling it.
     FlushPendingWrites();
     fake_invalidation_client_ = NULL;
     listener_.StopForTest();
   }
 
   size_t GetInvalidationCount(const ObjectId& id) const {
     return fake_delegate_.GetInvalidationCount(id);
   }
 
-  int64 GetVersion(const ObjectId& id) const {
+  int64_t GetVersion(const ObjectId& id) const {
     return fake_delegate_.GetVersion(id);
   }
 
   std::string GetPayload(const ObjectId& id) const {
     return fake_delegate_.GetPayload(id);
   }
 
   bool IsUnknownVersion(const ObjectId& id) const {
     return fake_delegate_.IsUnknownVersion(id);
   }
@@ skipping 55 matching lines @@
       return map.ForObject(id);
     }
   }
 
   ObjectIdSet GetRegisteredIds() const {
     return fake_invalidation_client_->GetRegisteredIds();
   }
 
   // |payload| can be NULL.
   void FireInvalidate(const ObjectId& object_id,
-                      int64 version, const char* payload) {
+                      int64_t version,
+                      const char* payload) {
     invalidation::Invalidation inv;
     if (payload) {
       inv = invalidation::Invalidation(object_id, version, payload);
     } else {
       inv = invalidation::Invalidation(object_id, version);
     }
     const AckHandle ack_handle("fakedata");
     fake_invalidation_client_->ClearAckedHandles();
     listener_.Invalidate(fake_invalidation_client_, inv, ack_handle);
     EXPECT_TRUE(fake_invalidation_client_->IsAckedHandle(ack_handle));
@@ skipping 106 matching lines @@
   ASSERT_EQ(1U, GetInvalidationCount(id));
   ASSERT_FALSE(IsUnknownVersion(id));
   EXPECT_EQ(kVersion1, GetVersion(id));
   EXPECT_EQ(kPayload1, GetPayload(id));
 }
 
 // Fire ten invalidations in a row.  All should be received.
 TEST_F(SyncInvalidationListenerTest, ManyInvalidations_NoDrop) {
   const int kRepeatCount = 10;
   const ObjectId& id = kPreferencesId_;
-  int64 initial_version = kVersion1;
-  for (int64 i = initial_version; i < initial_version + kRepeatCount; ++i) {
+  int64_t initial_version = kVersion1;
+  for (int64_t i = initial_version; i < initial_version + kRepeatCount; ++i) {
     FireInvalidate(id, i, kPayload1);
   }
   ASSERT_EQ(static_cast<size_t>(kRepeatCount), GetInvalidationCount(id));
   ASSERT_FALSE(IsUnknownVersion(id));
   EXPECT_EQ(kPayload1, GetPayload(id));
   EXPECT_EQ(initial_version + kRepeatCount - 1, GetVersion(id));
 }
 
 // Fire an invalidation for an unregistered object ID with a payload.  It should
 // still be processed, and both the payload and the version should be updated.
@@ skipping 24 matching lines @@
 TEST_F(SyncInvalidationListenerTest, InvalidateBeforeRegistration_Drop) {
   const int kRepeatCount =
       UnackedInvalidationSet::kMaxBufferedInvalidations + 1;
   const ObjectId kUnregisteredId(kChromeSyncSourceId, "unregistered");
   const ObjectId& id = kUnregisteredId;
   ObjectIdSet ids;
   ids.insert(id);
 
   EXPECT_EQ(0U, GetInvalidationCount(id));
 
-  int64 initial_version = kVersion1;
-  for (int64 i = initial_version; i < initial_version + kRepeatCount; ++i) {
+  int64_t initial_version = kVersion1;
+  for (int64_t i = initial_version; i < initial_version + kRepeatCount; ++i) {
     FireInvalidate(id, i, kPayload1);
   }
 
   EnableNotifications();
   listener_.Ready(fake_invalidation_client_);
   listener_.UpdateRegisteredIds(ids);
 
   ASSERT_EQ(UnackedInvalidationSet::kMaxBufferedInvalidations,
             GetInvalidationCount(id));
   ASSERT_FALSE(IsUnknownVersion(id));
@@ skipping 530 matching lines @@
   ids.insert(kExtensionsId_);
   listener_.UpdateRegisteredIds(ids);
 
   ASSERT_EQ(3U, GetInvalidationCount(kExtensionsId_));
   EXPECT_EQ(30, GetVersion(kExtensionsId_));
 }
 
 }  // namespace
 
 }  // namespace syncer