Switch to standard integer types in sync/.

sync/internal_api/public/sync_manager.h

 // Copyright 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.
 
 #ifndef SYNC_INTERNAL_API_PUBLIC_SYNC_MANAGER_H_
 #define SYNC_INTERNAL_API_PUBLIC_SYNC_MANAGER_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_checker.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/base/invalidation_interface.h"
@@ skipping 88 matching lines @@
     // 2. Updates to existing items with synced parents & predecessors.
     // 3. New items with synced parents & predecessors.
     // 4. Items with parents & predecessors in |changes|.
     // 5. Repeat #4 until all items are in |changes|.
     //
     // Thus, an implementation of OnChangesApplied should be able to
     // process the change records in the order without having to worry about
     // forward dependencies.  But since deletions come before reparent
     // operations, a delete may temporarily orphan a node that is
     // updated later in the list.
-    virtual void OnChangesApplied(
-        ModelType model_type,
-        int64 model_version,
-        const BaseTransaction* trans,
-        const ImmutableChangeRecordList& changes) = 0;
+    virtual void OnChangesApplied(ModelType model_type,
+                                  int64_t model_version,
+                                  const BaseTransaction* trans,
+                                  const ImmutableChangeRecordList& changes) = 0;
 
     // OnChangesComplete gets called when the TransactionComplete event is
     // posted (after OnChangesApplied finishes), after the transaction lock
     // and the change channel mutex are released.
     //
     // The purpose of this function is to support processors that require
     // split-transactions changes. For example, if a model processor wants to
     // perform blocking I/O due to a change, it should calculate the changes
     // while holding the transaction lock (from within OnChangesApplied), buffer
     // those changes, let the transaction fall out of scope, and then commit
@@ skipping 19 matching lines @@
     // TODO(sync, long-term): Ideally, ChangeDelegate/Observer would
     // be passed a transformed version of EntryKernelMutation instead
     // of a transaction that would have to be used to look up the
     // changed nodes.  That is, ChangeDelegate::OnChangesApplied()
     // would still be called under the transaction, but all the needed
     // data will be passed down.
     //
     // Even more ideally, we would have sync semantics such that we'd
     // be able to apply changes without being under a transaction.
     // But that's a ways off...
-    virtual void OnChangesApplied(
-        ModelType model_type,
-        int64 write_transaction_id,
-        const ImmutableChangeRecordList& changes) = 0;
+    virtual void OnChangesApplied(ModelType model_type,
+                                  int64_t write_transaction_id,
+                                  const ImmutableChangeRecordList& changes) = 0;
 
     virtual void OnChangesComplete(ModelType model_type) = 0;
 
    protected:
     virtual ~ChangeObserver();
   };
 
   // An interface the embedding application implements to receive
   // notifications from the SyncManager.  Register an observer via
   // SyncManager::AddObserver.  All methods are called only on the
@@ skipping 221 matching lines @@
   //
   // This is an asynchronous operation that requires interaction with the sync
   // server. The operation will automatically be retried with backoff until it
   // completes successfully or sync is shutdown.
   virtual void ClearServerData(const ClearServerDataCallback& callback) = 0;
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_SYNC_MANAGER_H_