Switch to standard integer types in sync/.

sync/syncable/directory.h

 // Copyright 2013 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.
 
 #ifndef SYNC_SYNCABLE_DIRECTORY_H_
 #define SYNC_SYNCABLE_DIRECTORY_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <deque>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_util.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/values.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/syncable/dir_open_result.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/parent_child_index.h"
 #include "sync/syncable/syncable_delete_journal.h"
@@ skipping 22 matching lines @@
   FULL_DB_VERIFICATION = 2  // Check every entry.  This can be expensive.
 };
 
 // Directory stores and manages EntryKernels.
 //
 // This class is tightly coupled to several other classes via Directory::Kernel.
 // Although Directory's kernel_ is exposed via public accessor it should be
 // treated as pseudo-private.
 class SYNC_EXPORT Directory {
  public:
-  typedef std::vector<int64> Metahandles;
+  typedef std::vector<int64_t> Metahandles;
 
   // TODO(skym): Convert this hash_map usage to unordered_map, crbug/567280.
   // Be careful when using these hash_map containers.  According to the spec,
   // inserting into them may invalidate all iterators.
   //
   // It gets worse, though.  The Anroid STL library has a bug that means it may
   // invalidate all iterators when you erase from the map, too.  That means that
   // you can't iterate while erasing.  STLDeleteElements(), std::remove_if(),
   // and other similar functions are off-limits too, until this bug is fixed.
   //
   // See http://sourceforge.net/p/stlport/bugs/239/.
-  typedef base::hash_map<int64, EntryKernel*> MetahandlesMap;
+  typedef base::hash_map<int64_t, EntryKernel*> MetahandlesMap;
   typedef base::hash_map<std::string, EntryKernel*> IdsMap;
   typedef base::hash_map<std::string, EntryKernel*> TagsMap;
   typedef std::string AttachmentIdUniqueId;
   typedef base::hash_map<AttachmentIdUniqueId, MetahandleSet>
       IndexByAttachmentId;
 
   static const base::FilePath::CharType kSyncDatabaseFilename[];
 
   // The dirty/clean state of kernel fields backed by the share_info table.
   // This is public so it can be used in SaveChangesSnapshot for persistence.
@@ skipping 18 matching lines @@
     bool HasEmptyDownloadProgress(ModelType model_type);
 
     // Last sync timestamp fetched from the server.
     sync_pb::DataTypeProgressMarker download_progress[MODEL_TYPE_COUNT];
     // Sync-side transaction version per data type. Monotonically incremented
     // when updating native model. A copy is also saved in native model.
     // Later out-of-sync models can be detected and fixed by comparing
     // transaction versions of sync model and native model.
     // TODO(hatiaol): implement detection and fixing of out-of-sync models.
     //                Bug 154858.
-    int64 transaction_version[MODEL_TYPE_COUNT];
+    int64_t transaction_version[MODEL_TYPE_COUNT];
     // The store birthday we were given by the server. Contents are opaque to
     // the client.
     std::string store_birthday;
     // The serialized bag of chips we were given by the server. Contents are
     // opaque to the client. This is the serialization of a message of type
     // ChipBag defined in sync.proto. It can contains NULL characters.
     std::string bag_of_chips;
     // The per-datatype context.
     sync_pb::DataTypeContext datatype_context[MODEL_TYPE_COUNT];
   };
 
   // What the Directory needs on initialization to create itself and its Kernel.
   // Filled by DirectoryBackingStore::Load.
   struct KernelLoadInfo {
     PersistedKernelInfo kernel_info;
     std::string cache_guid;  // Created on first initialization, never changes.
-    int64 max_metahandle;    // Computed (using sql MAX aggregate) on init.
+    int64_t max_metahandle;  // Computed (using sql MAX aggregate) on init.
     KernelLoadInfo() : max_metahandle(0) {
     }
   };
 
   // When the Directory is told to SaveChanges, a SaveChangesSnapshot is
   // constructed and forms a consistent snapshot of what needs to be sent to
   // the backing store.
   struct SYNC_EXPORT SaveChangesSnapshot {
     SaveChangesSnapshot();
     ~SaveChangesSnapshot();
@@ skipping 15 matching lines @@
     Kernel(const std::string& name, const KernelLoadInfo& info,
            DirectoryChangeDelegate* delegate,
            const WeakHandle<TransactionObserver>& transaction_observer);
 
     ~Kernel();
 
     // Implements ReadTransaction / WriteTransaction using a simple lock.
     base::Lock transaction_mutex;
 
     // Protected by transaction_mutex.  Used by WriteTransactions.
-    int64 next_write_transaction_id;
+    int64_t next_write_transaction_id;
 
     // The name of this directory.
     std::string const name;
 
     // Protects all members below.
     // The mutex effectively protects all the indices, but not the
     // entries themselves.  So once a pointer to an entry is pulled
     // from the index, the mutex can be unlocked and entry read or written.
     //
     // Never hold the mutex and do anything with the database or any
@@ skipping 56 matching lines @@
 
     // A unique identifier for this account's cache db, used to generate
     // unique server IDs. No need to lock, only written at init time.
     const std::string cache_guid;
 
     // It doesn't make sense for two threads to run SaveChanges at the same
     // time; this mutex protects that activity.
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
-    int64 next_metahandle;
+    int64_t next_metahandle;
 
     // The delegate for directory change events.  Must not be NULL.
     DirectoryChangeDelegate* const delegate;
 
     // The transaction observer.
     const WeakHandle<TransactionObserver> transaction_observer;
   };
 
   // Does not take ownership of |encryptor|.
   // |report_unrecoverable_error_function| may be NULL.
   // Takes ownership of |store|.
   Directory(
       DirectoryBackingStore* store,
       const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
       const base::Closure& report_unrecoverable_error_function,
       NigoriHandler* nigori_handler,
       Cryptographer* cryptographer);
   virtual ~Directory();
 
   // Does not take ownership of |delegate|, which must not be NULL.
   // Starts sending events to |delegate| if the returned result is
   // OPENED.  Note that events to |delegate| may be sent from *any*
   // thread.  |transaction_observer| must be initialized.
   DirOpenResult Open(const std::string& name,
                      DirectoryChangeDelegate* delegate,
                      const WeakHandle<TransactionObserver>&
                          transaction_observer);
 
-  int64 NextMetahandle();
+  int64_t NextMetahandle();
   // Generates next client ID based on a randomly generated GUID.
   syncable::Id NextId();
 
   bool good() const { return NULL != kernel_; }
 
   // The download progress is an opaque token provided by the sync server
   // to indicate the continuation state of the next GetUpdates operation.
   void GetDownloadProgress(
       ModelType type,
       sync_pb::DataTypeProgressMarker* value_out) const;
   void GetDownloadProgressAsString(
       ModelType type,
       std::string* value_out) const;
   void SetDownloadProgress(
       ModelType type,
       const sync_pb::DataTypeProgressMarker& value);
   bool HasEmptyDownloadProgress(ModelType type) const;
 
   // Gets the total number of entries in the directory.
   size_t GetEntriesCount() const;
 
   // Gets/Increments transaction version of a model type. Must be called when
   // holding kernel mutex.
-  int64 GetTransactionVersion(ModelType type) const;
+  int64_t GetTransactionVersion(ModelType type) const;
   void IncrementTransactionVersion(ModelType type);
 
   // Getter/setters for the per datatype context.
   void GetDataTypeContext(BaseTransaction* trans,
                           ModelType type,
                           sync_pb::DataTypeContext* context) const;
   void SetDataTypeContext(BaseWriteTransaction* trans,
                           ModelType type,
                           const sync_pb::DataTypeContext& context);
 
@@ skipping 87 matching lines @@
   // state and indices (by deep copy) under a ReadTransaction, passing this
   // snapshot to the backing store under no transaction, and finally cleaning
   // up by either purging entries no longer needed (this part done under a
   // WriteTransaction) or rolling back the dirty bits.  It also uses
   // internal locking to enforce SaveChanges operations are mutually exclusive.
   //
   // WARNING: THIS METHOD PERFORMS SYNCHRONOUS I/O VIA SQLITE.
   bool SaveChanges();
 
   // Returns the number of entities with the unsynced bit set.
-  int64 unsynced_entity_count() const;
+  int64_t unsynced_entity_count() const;
 
   // Get GetUnsyncedMetaHandles should only be called after SaveChanges and
   // before any new entries have been created. The intention is that the
   // syncer should call it from its PerformSyncQueries member.
   void GetUnsyncedMetaHandles(BaseTransaction* trans,
                               Metahandles* result);
 
   // Returns whether or not this |type| has unapplied updates.
   bool TypeHasUnappliedUpdates(ModelType type);
 
   // Get all the metahandles for unapplied updates for a given set of
   // server types.
   void GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
                                      FullModelTypeSet server_types,
-                                     std::vector<int64>* result);
+                                     std::vector<int64_t>* result);
 
   // Get all the metahandles of entries of |type|.
   void GetMetaHandlesOfType(BaseTransaction* trans,
                             ModelType type,
                             Metahandles* result);
 
   // Get metahandle counts for various criteria to show on the
   // about:sync page. The information is computed on the fly
   // each time. If this results in a significant performance hit,
   // additional data structures can be added to cache results.
@@ skipping 70 matching lines @@
   // uploaded to the sync server.
   void GetAttachmentIdsToUpload(BaseTransaction* trans,
                                 ModelType type,
                                 AttachmentIdList* ids);
 
   // For new entry creation only.
   bool InsertEntry(BaseWriteTransaction* trans, EntryKernel* entry);
 
   // Update the attachment index for |metahandle| removing it from the index
   // under |old_metadata| entries and add it under |new_metadata| entries.
-  void UpdateAttachmentIndex(const int64 metahandle,
+  void UpdateAttachmentIndex(const int64_t metahandle,
                              const sync_pb::AttachmentMetadata& old_metadata,
                              const sync_pb::AttachmentMetadata& new_metadata);
 
   virtual EntryKernel* GetEntryById(const Id& id);
   virtual EntryKernel* GetEntryByClientTag(const std::string& tag);
   EntryKernel* GetEntryByServerTag(const std::string& tag);
 
-  virtual EntryKernel* GetEntryByHandle(int64 handle);
+  virtual EntryKernel* GetEntryByHandle(int64_t handle);
 
   bool ReindexId(BaseWriteTransaction* trans, EntryKernel* const entry,
                  const Id& new_id);
 
   bool ReindexParentId(BaseWriteTransaction* trans, EntryKernel* const entry,
                        const Id& new_parent_id);
 
   // Accessors for the underlying Kernel. Although these are public methods, the
   // number of classes that call these should be limited.
   Kernel* kernel();
@@ skipping 10 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsMetahandlesToPurge);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest, CatastrophicError);
 
   // You'll notice that some of the methods below are private overloads of the
   // public ones declared above. The general pattern is that the public overload
   // constructs a ScopedKernelLock before calling the corresponding private
   // overload with the held ScopedKernelLock.
 
   virtual EntryKernel* GetEntryByHandle(const ScopedKernelLock& lock,
-                                        int64 metahandle);
+                                        int64_t metahandle);
 
   virtual EntryKernel* GetEntryById(const ScopedKernelLock& lock, const Id& id);
 
   bool InsertEntry(const ScopedKernelLock& lock,
                    BaseWriteTransaction* trans,
                    EntryKernel* entry);
 
   // Remove each of |metahandle|'s attachment ids from index_by_attachment_id.
   void RemoveFromAttachmentIndex(
       const ScopedKernelLock& lock,
-      const int64 metahandle,
+      const int64_t metahandle,
       const sync_pb::AttachmentMetadata& attachment_metadata);
 
   // Add each of |metahandle|'s attachment ids to the index_by_attachment_id.
   void AddToAttachmentIndex(
       const ScopedKernelLock& lock,
-      const int64 metahandle,
+      const int64_t metahandle,
       const sync_pb::AttachmentMetadata& attachment_metadata);
 
   void ClearDirtyMetahandles(const ScopedKernelLock& lock);
 
   DirOpenResult OpenImpl(
       const std::string& name,
       DirectoryChangeDelegate* delegate,
       const WeakHandle<TransactionObserver>& transaction_observer);
 
   // A helper that implements the logic of checking tree invariants.
@@ skipping 42 matching lines @@
   void DeleteEntry(const ScopedKernelLock& lock,
                    bool save_to_journal,
                    EntryKernel* entry,
                    EntryKernelSet* entries_to_journal);
 
   // A private version of the public GetMetaHandlesOfType for when you already
   // have a ScopedKernelLock.
   void GetMetaHandlesOfType(const ScopedKernelLock& lock,
                             BaseTransaction* trans,
                             ModelType type,
-                            std::vector<int64>* result);
+                            std::vector<int64_t>* result);
 
   // Invoked by DirectoryBackingStore when a catastrophic database error is
   // detected.
   void OnCatastrophicError();
 
   // Stops sending events to the delegate and the transaction
   // observer.
   void Close();
 
   // Returns true if the directory had encountered an unrecoverable error.
@@ skipping 22 matching lines @@
 
   base::WeakPtrFactory<Directory> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Directory);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif  // SYNC_SYNCABLE_DIRECTORY_H_