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

components/bookmarks/browser/bookmark_codec_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 "components/bookmarks/browser/bookmark_codec.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/bookmarks/browser/bookmark_model.h"
@@ skipping 139 matching lines @@
     EXPECT_FALSE(stored_checksum.empty());
     EXPECT_EQ(computed_checksum, stored_checksum);
 
     *checksum = computed_checksum;
     return value.release();
   }
 
   bool Decode(BookmarkCodec* codec,
               BookmarkModel* model,
               const base::Value& value) {
-    int64 max_id;
+    int64_t max_id;
     bool result = codec->Decode(AsMutable(model->bookmark_bar_node()),
                                 AsMutable(model->other_node()),
                                 AsMutable(model->mobile_node()),
                                 &max_id,
                                 value);
     model->set_next_node_id(max_id);
     AsMutable(model->root_node())->SetMetaInfoMap(codec->model_meta_info_map());
     AsMutable(model->root_node())
         ->set_sync_transaction_version(codec->model_sync_transaction_version());
 
@@ skipping 25 matching lines @@
     // The two checksums should be equal if expected_changes is true; otherwise
     // they should be different.
     if (expected_changes)
       EXPECT_NE(*computed_checksum, stored_checksum);
     else
       EXPECT_EQ(*computed_checksum, stored_checksum);
 
     return model.release();
   }
 
-  void CheckIDs(const BookmarkNode* node, std::set<int64>* assigned_ids) {
+  void CheckIDs(const BookmarkNode* node, std::set<int64_t>* assigned_ids) {
     DCHECK(node);
-    int64 node_id = node->id();
+    int64_t node_id = node->id();
     EXPECT_TRUE(assigned_ids->find(node_id) == assigned_ids->end());
     assigned_ids->insert(node_id);
     for (int i = 0; i < node->child_count(); ++i)
       CheckIDs(node->GetChild(i), assigned_ids);
   }
 
   void ExpectIDsUnique(BookmarkModel* model) {
-    std::set<int64> assigned_ids;
+    std::set<int64_t> assigned_ids;
     CheckIDs(model->bookmark_bar_node(), &assigned_ids);
     CheckIDs(model->other_node(), &assigned_ids);
     CheckIDs(model->mobile_node(), &assigned_ids);
   }
 
   TestBookmarkClient client_;
 };
 
 TEST_F(BookmarkCodecTest, ChecksumEncodeDecodeTest) {
   scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel1());
@@ skipping 235 matching lines @@
       bbn->GetChild(1)->GetMetaInfo(kSyncTransactionVersionKey, &meta_value));
   EXPECT_TRUE(bbn->GetChild(0)->GetMetaInfo(kNormalKey, &meta_value));
   EXPECT_EQ("value", meta_value);
   EXPECT_TRUE(bbn->GetChild(1)->GetMetaInfo(kNormalKey, &meta_value));
   EXPECT_EQ("value2", meta_value);
   EXPECT_TRUE(bbn->GetChild(0)->GetMetaInfo(kNestedKey, &meta_value));
   EXPECT_EQ("value3", meta_value);
 }
 
 }  // namespace bookmarks