Switch to standard integer types in sync/.

sync/test/engine/mock_connection_manager.h

 // Copyright (c) 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.
 //
 // Mock ServerConnectionManager class for use in client unit tests.
 
 #ifndef SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #define SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 
+#include <stdint.h>
+
 #include <bitset>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/lock.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace syncer {
 
 class MockConnectionManager : public ServerConnectionManager {
@@ skipping 18 matching lines @@
   // Control of commit response.
   // NOTE: Commit callback is invoked only once then reset.
   void SetMidCommitCallback(const base::Closure& callback);
   void SetMidCommitObserver(MidCommitObserver* observer);
 
   // Set this if you want commit to perform commit time rename. Will request
   // that the client renames all commited entries, prepending this string.
   void SetCommitTimeRename(const std::string& prepend);
 
   // Generic versions of AddUpdate functions. Tests using these function should
-  // compile for both the int64 and string id based versions of the server.
+  // compile for both the int64_t and string id based versions of the server.
   // The SyncEntity returned is only valid until the Sync is completed
   // (e.g. with SyncShare.) It allows to add further entity properties before
   // sync, using SetLastXXX() methods and/or GetMutableLastUpdate().
   sync_pb::SyncEntity* AddUpdateDirectory(
       syncable::Id id,
       syncable::Id parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
   sync_pb::SyncEntity* AddUpdateBookmark(
       syncable::Id id,
       syncable::Id parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
   // Versions of the AddUpdate functions that accept integer IDs.
   sync_pb::SyncEntity* AddUpdateDirectory(
       int id,
       int parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
   sync_pb::SyncEntity* AddUpdateBookmark(
       int id,
       int parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
   // New protocol versions of the AddUpdate functions.
   sync_pb::SyncEntity* AddUpdateDirectory(
       const std::string& id,
       const std::string& parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
   sync_pb::SyncEntity* AddUpdateBookmark(
       const std::string& id,
       const std::string& parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
   // Versions of the AddUpdate function that accept specifics.
   sync_pb::SyncEntity* AddUpdateSpecifics(
       int id,
       int parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       bool is_dir,
-      int64 position,
+      int64_t position,
       const sync_pb::EntitySpecifics& specifics);
   sync_pb::SyncEntity* AddUpdateSpecifics(
       int id,
       int parent_id,
       const std::string& name,
-      int64 version,
-      int64 sync_ts,
+      int64_t version,
+      int64_t sync_ts,
       bool is_dir,
-      int64 position,
+      int64_t position,
       const sync_pb::EntitySpecifics& specifics,
       const std::string& originator_cache_guid,
       const std::string& originator_client_item_id);
-  sync_pb::SyncEntity* SetNigori(
-      int id,
-      int64 version,
-      int64 sync_ts,
-      const sync_pb::EntitySpecifics& specifics);
+  sync_pb::SyncEntity* SetNigori(int id,
+                                 int64_t version,
+                                 int64_t sync_ts,
+                                 const sync_pb::EntitySpecifics& specifics);
   // Unique client tag variant for adding items.
   sync_pb::SyncEntity* AddUpdatePref(const std::string& id,
                                      const std::string& parent_id,
                                      const std::string& client_tag,
-                                     int64 version,
-                                     int64 sync_ts);
+                                     int64_t version,
+                                     int64_t sync_ts);
 
   // Find the last commit sent by the client, and replay it for the next get
   // updates command.  This can be used to simulate the GetUpdates that happens
   // immediately after a successful commit.
   sync_pb::SyncEntity* AddUpdateFromLastCommit();
 
   // Add a deleted item.  Deletion records typically contain no
   // additional information beyond the deletion, and no specifics.
   // The server may send the originator fields.
   void AddUpdateTombstone(const syncable::Id& id, ModelType type);
 
   void SetLastUpdateDeleted();
   void SetLastUpdateServerTag(const std::string& tag);
   void SetLastUpdateClientTag(const std::string& tag);
   void SetLastUpdateOriginatorFields(const std::string& client_id,
                                      const std::string& entry_id);
-  void SetLastUpdatePosition(int64 position_in_parent);
+  void SetLastUpdatePosition(int64_t position_in_parent);
   void SetNewTimestamp(int ts);
-  void SetChangesRemaining(int64 count);
+  void SetChangesRemaining(int64_t count);
 
   // Add a new batch of updates after the current one.  Allows multiple
   // GetUpdates responses to be buffered up, since the syncer may
   // issue multiple requests during a sync cycle.
   void NextUpdateBatch();
 
   void FailNextPostBufferToPathCall() { countdown_to_postbuffer_fail_ = 1; }
   void FailNthPostBufferToPathCall(int n) { countdown_to_postbuffer_fail_ = n; }
 
   void SetKeystoreKey(const std::string& key);
@@ skipping 98 matching lines @@
   // Locate the most recent update message for purpose of alteration.
   sync_pb::SyncEntity* GetMutableLastUpdate();
 
   // Adds a new progress marker to the last update.
   sync_pb::DataTypeProgressMarker* AddUpdateProgressMarker();
 
  private:
   sync_pb::SyncEntity* AddUpdateFull(syncable::Id id,
                                      syncable::Id parentid,
                                      const std::string& name,
-                                     int64 version,
-                                     int64 sync_ts,
+                                     int64_t version,
+                                     int64_t sync_ts,
                                      bool is_dir);
   sync_pb::SyncEntity* AddUpdateFull(const std::string& id,
                                      const std::string& parentid,
                                      const std::string& name,
-                                     int64 version,
-                                     int64 sync_ts,
+                                     int64_t version,
+                                     int64_t sync_ts,
                                      bool is_dir);
   sync_pb::SyncEntity* AddUpdateMeta(const std::string& id,
                                      const std::string& parentid,
                                      const std::string& name,
-                                     int64 version,
-                                     int64 sync_ts);
+                                     int64_t version,
+                                     int64_t sync_ts);
 
   // Functions to handle the various types of server request.
   void ProcessGetUpdates(sync_pb::ClientToServerMessage* csm,
                          sync_pb::ClientToServerResponse* response);
   void ProcessCommit(sync_pb::ClientToServerMessage* csm,
                      sync_pb::ClientToServerResponse* response_buffer);
   void ProcessClearServerData(sync_pb::ClientToServerMessage* csm,
                               sync_pb::ClientToServerResponse* response);
   void AddDefaultBookmarkData(sync_pb::SyncEntity* entity, bool is_folder);
 
   // Determine if one entry in a commit should be rejected with a conflict.
   bool ShouldConflictThisCommit();
 
   // Determine if the given item's commit request should be refused with
   // a TRANSIENT_ERROR response.
   bool ShouldTransientErrorThisId(syncable::Id id);
 
   // Generate a numeric position_in_parent value.  We use a global counter
   // that only decreases; this simulates new objects always being added to the
   // front of the ordering.
-  int64 GeneratePositionInParent() {
-    return next_position_in_parent_--;
-  }
+  int64_t GeneratePositionInParent() { return next_position_in_parent_--; }
 
   // Get a mutable update response which will eventually be returned to the
   // client.
   sync_pb::GetUpdatesResponse* GetUpdateResponse();
   void ApplyToken();
 
   // Determine whether an progress marker array (like that sent in
   // GetUpdates.from_progress_marker) indicates that a particular ModelType
   // should be included.
   bool IsModelTypePresentInSpecifics(
@@ skipping 66 matching lines @@
 
   base::Lock response_code_override_lock_;
 
   // True if we are only accepting GetUpdatesCallerInfo::PERIODIC requests.
   bool fail_non_periodic_get_updates_;
 
   scoped_ptr<sync_pb::ClientCommand> gu_client_command_;
   scoped_ptr<sync_pb::ClientCommand> commit_client_command_;
 
   // The next value to use for the position_in_parent property.
-  int64 next_position_in_parent_;
+  int64_t next_position_in_parent_;
 
   // The default is to use the newer sync_pb::BookmarkSpecifics-style protocol.
   // If this option is set to true, then the MockConnectionManager will
   // use the older sync_pb::SyncEntity_BookmarkData-style protocol.
   bool use_legacy_bookmarks_protocol_;
 
   ModelTypeSet expected_filter_;
 
   ModelTypeSet throttled_type_;
 
   int num_get_updates_requests_;
 
   std::string next_token_;
 
   std::vector<sync_pb::ClientToServerMessage> requests_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_