Switch to standard integer types in sync/.

sync/test/fake_server/fake_server.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/test/fake_server/fake_server.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
@@ skipping 41 matching lines @@
   ~UpdateSieve() { }
 
   // Factory method for creating an UpdateSieve.
   static scoped_ptr<UpdateSieve> Create(
       const sync_pb::GetUpdatesMessage& get_updates_message);
 
   // Sets the progress markers in |get_updates_response| given the progress
   // markers from the original GetUpdatesMessage and |new_version| (the latest
   // version in the entries sent back).
   void UpdateProgressMarkers(
-      int64 new_version,
+      int64_t new_version,
       sync_pb::GetUpdatesResponse* get_updates_response) const {
     ModelTypeToVersionMap::const_iterator it;
     for (it = request_from_version_.begin(); it != request_from_version_.end();
          ++it) {
       sync_pb::DataTypeProgressMarker* new_marker =
           get_updates_response->add_new_progress_marker();
       new_marker->set_data_type_id(
           GetSpecificsFieldNumberFromModelType(it->first));
 
-      int64 version = std::max(new_version, it->second);
+      int64_t version = std::max(new_version, it->second);
       new_marker->set_token(base::Int64ToString(version));
     }
   }
 
   // Determines whether the server should send an |entity| to the client as
   // part of a GetUpdatesResponse.
   bool ClientWantsItem(const FakeServerEntity& entity) const {
-    int64 version = entity.GetVersion();
+    int64_t version = entity.GetVersion();
     if (version <= min_version_) {
       return false;
     } else if (entity.IsDeleted()) {
       return true;
     }
 
     ModelTypeToVersionMap::const_iterator it =
         request_from_version_.find(entity.GetModelType());
 
     return it == request_from_version_.end() ? false : it->second < version;
   }
 
   // Returns the minimum version seen across all types.
-  int64 GetMinVersion() const {
-    return min_version_;
-  }
+  int64_t GetMinVersion() const { return min_version_; }
 
  private:
-  typedef std::map<ModelType, int64> ModelTypeToVersionMap;
+  typedef std::map<ModelType, int64_t> ModelTypeToVersionMap;
 
   // Creates an UpdateSieve.
   UpdateSieve(const ModelTypeToVersionMap request_from_version,
-              const int64 min_version)
+              const int64_t min_version)
       : request_from_version_(request_from_version),
-        min_version_(min_version) { }
+        min_version_(min_version) {}
 
   // Maps data type IDs to the latest version seen for that type.
   const ModelTypeToVersionMap request_from_version_;
 
   // The minimum version seen among all data types.
   const int min_version_;
 };
 
 scoped_ptr<UpdateSieve> UpdateSieve::Create(
     const sync_pb::GetUpdatesMessage& get_updates_message) {
   CHECK_GT(get_updates_message.from_progress_marker_size(), 0)
       << "A GetUpdates request must have at least one progress marker.";
 
   UpdateSieve::ModelTypeToVersionMap request_from_version;
-  int64 min_version = std::numeric_limits<int64>::max();
+  int64_t min_version = std::numeric_limits<int64_t>::max();
   for (int i = 0; i < get_updates_message.from_progress_marker_size(); i++) {
     sync_pb::DataTypeProgressMarker marker =
         get_updates_message.from_progress_marker(i);
 
-    int64 version = 0;
+    int64_t version = 0;
     // Let the version remain zero if there is no token or an empty token (the
     // first request for this type).
     if (marker.has_token() && !marker.token().empty()) {
       bool parsed = base::StringToInt64(marker.token(), &version);
       CHECK(parsed) << "Unable to parse progress marker token.";
     }
 
     ModelType model_type = syncer::GetModelTypeFromSpecificsFieldNumber(
         marker.data_type_id());
     request_from_version[model_type] = version;
@@ skipping 181 matching lines @@
 
   // This folder is called "Synced Bookmarks" by sync and is renamed
   // "Mobile Bookmarks" by the mobile client UIs.
   if (get_updates.create_mobile_bookmarks_folder() &&
       !CreatePermanentBookmarkFolder(kSyncedBookmarksFolderServerTag,
                                      kSyncedBookmarksFolderName)) {
     return false;
   }
 
   bool send_encryption_keys_based_on_nigori = false;
-  int64 max_response_version = 0;
+  int64_t max_response_version = 0;
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (sieve->ClientWantsItem(entity)) {
       sync_pb::SyncEntity* response_entity = response->add_entries();
       entity.SerializeAsProto(response_entity);
 
       max_response_version = std::max(max_response_version,
                                       response_entity->version());
 
@@ skipping 354 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 std::string FakeServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
 }  // namespace fake_server