Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/sync_file_system/drive_backend/metadata_database.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 CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_METADATA_DATABASE_H_
 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_METADATA_DATABASE_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
 #include "base/values.h"
 #include "chrome/browser/sync_file_system/drive_backend/tracker_id_set.h"
 #include "chrome/browser/sync_file_system/sync_status_code.h"
 
 namespace leveldb {
 class Env;
@@ skipping 105 matching lines @@
       SyncStatusCode* status);
   static SyncStatusCode CreateForTesting(
       scoped_ptr<LevelDBWrapper> db,
       bool enable_on_disk_index,
       scoped_ptr<MetadataDatabase>* metadata_database_out);
 
   ~MetadataDatabase();
 
   static void ClearDatabase(scoped_ptr<MetadataDatabase> metadata_database);
 
-  int64 GetLargestFetchedChangeID() const;
-  int64 GetSyncRootTrackerID() const;
+  int64_t GetLargestFetchedChangeID() const;
+  int64_t GetSyncRootTrackerID() const;
 
   // Returns true if the client should check if the sync root is still valid.
   bool NeedsSyncRootRevalidation() const;
 
   bool HasSyncRoot() const;
 
   // Returns all file metadata for the given |app_id|.
   scoped_ptr<base::ListValue> DumpFiles(const std::string& app_id);
 
   // Returns all database data.
   scoped_ptr<base::ListValue> DumpDatabase();
 
   // TODO(tzik): Move GetLargestKnownChangeID() to private section, and hide its
   // handling in the class, instead of letting user do.
   //
   // Gets / updates the largest known change ID.
   // The largest known change ID is on-memory and not persist over restart.
   // This is supposed to use when a task fetches ChangeList in parallel to other
   // operation.  When a task starts fetching paged ChangeList one by one, it
   // should update the largest known change ID on the first round and background
   // remaining fetch job.
   // Then, when other tasks that update FileMetadata by UpdateByFileResource,
   // it should use largest known change ID as the |change_id| that prevents
   // FileMetadata from overwritten by ChangeList.
   // Also if other tasks try to update a remote resource whose change is not yet
   // retrieved the task should fail due to etag check, so we should be fine.
-  int64 GetLargestKnownChangeID() const;
-  void UpdateLargestKnownChangeID(int64 change_id);
+  int64_t GetLargestKnownChangeID() const;
+  void UpdateLargestKnownChangeID(int64_t change_id);
 
   // Populates empty database with initial data.
   // Adds a file metadata and a file tracker for |sync_root_folder|, and adds
   // file metadata and file trackers for each |app_root_folders|.
   // Newly added tracker for |sync_root_folder| is active and non-dirty.
   // Newly added trackers for |app_root_folders| are inactive and non-dirty.
   // Trackers for |app_root_folders| are not yet registered as app-roots, but
   // are ready to register.
   SyncStatusCode PopulateInitialData(
-      int64 largest_change_id,
+      int64_t largest_change_id,
       const google_apis::FileResource& sync_root_folder,
       const ScopedVector<google_apis::FileResource>& app_root_folders);
 
   // Returns true if the folder associated to |app_id| is enabled.
   bool IsAppEnabled(const std::string& app_id) const;
 
   // Registers existing folder as the app-root for |app_id|.  The folder
   // must be an inactive folder that does not yet associated to any App.
   // This method associates the folder with |app_id| and activates it.
   SyncStatusCode RegisterApp(const std::string& app_id,
@@ skipping 20 matching lines @@
 
   // Finds the file identified by |file_id|.  Returns true if the file is found.
   // Copies the metadata identified by |file_id| into |file| if exists and
   // |file| is non-NULL.
   bool FindFileByFileID(const std::string& file_id, FileMetadata* file) const;
 
   // Finds the tracker identified by |tracker_id|.  Returns true if the tracker
   // is found.
   // Copies the tracker identified by |tracker_id| into |tracker| if exists and
   // |tracker| is non-NULL.
-  bool FindTrackerByTrackerID(int64 tracker_id, FileTracker* tracker) const;
+  bool FindTrackerByTrackerID(int64_t tracker_id, FileTracker* tracker) const;
 
   // Finds the trackers tracking |file_id|.  Returns true if the trackers are
   // found.
   bool FindTrackersByFileID(const std::string& file_id,
                             TrackerIDSet* trackers) const;
 
   // Finds the set of trackers whose parent's tracker ID is |parent_tracker_id|,
   // and who has |title| as its title in the synced_details.
   // Copies the tracker set to |trackers| if it is non-NULL.
   // Returns true if the trackers are found.
-  bool FindTrackersByParentAndTitle(
-      int64 parent_tracker_id,
-      const std::string& title,
-      TrackerIDSet* trackers) const;
+  bool FindTrackersByParentAndTitle(int64_t parent_tracker_id,
+                                    const std::string& title,
+                                    TrackerIDSet* trackers) const;
 
   // Builds the file path for the given tracker.  Returns true on success.
   // |path| can be NULL.
   // The file path is relative to app-root and have a leading path separator.
-  bool BuildPathForTracker(int64 tracker_id, base::FilePath* path) const;
+  bool BuildPathForTracker(int64_t tracker_id, base::FilePath* path) const;
 
   // Builds the file path for the given tracker for display purpose.
   // This may return a path ending with '<unknown>' if the given tracker does
   // not have title information (yet). This may return an empty path.
   base::FilePath BuildDisplayPathForTracker(const FileTracker& tracker) const;
 
   // Returns false if no registered app exists associated to |app_id|.
   // If |full_path| is active, assigns the tracker of |full_path| to |tracker|.
   // Otherwise, assigns the nearest active ancestor to |full_path| to |tracker|.
   // Also, assigns the full path of |tracker| to |path|.
   bool FindNearestActiveAncestor(const std::string& app_id,
                                  const base::FilePath& full_path,
                                  FileTracker* tracker,
                                  base::FilePath* path) const;
 
   // Updates database by |changes|.
   // Marks each tracker for modified file as dirty and adds new trackers if
   // needed.
   SyncStatusCode UpdateByChangeList(
-      int64 largest_change_id,
+      int64_t largest_change_id,
       ScopedVector<google_apis::ChangeResource> changes);
 
   // Updates database by |resource|.
   // Marks each tracker for modified file as dirty and adds new trackers if
   // needed.
   SyncStatusCode UpdateByFileResource(
       const google_apis::FileResource& resource);
   SyncStatusCode UpdateByFileResourceList(
       ScopedVector<google_apis::FileResource> resources);
 
   SyncStatusCode UpdateByDeletedRemoteFile(const std::string& file_id);
   SyncStatusCode UpdateByDeletedRemoteFileList(const FileIDList& file_ids);
 
   // Adds new FileTracker and FileMetadata.  The database must not have
   // |resource| beforehand.
   // The newly added tracker under |parent_tracker_id| is active and non-dirty.
   // Deactivates existing active tracker if exists that has the same title and
   // parent_tracker to the newly added tracker.
   SyncStatusCode ReplaceActiveTrackerWithNewResource(
-      int64 parent_tracker_id,
+      int64_t parent_tracker_id,
       const google_apis::FileResource& resource);
 
   // Adds |child_file_ids| to |folder_id| as its children.
   // This method affects the active tracker only.
   // If the tracker has no further change to sync, unmarks its dirty flag.
   SyncStatusCode PopulateFolderByChildList(const std::string& folder_id,
                                            const FileIDList& child_file_ids);
 
   // Updates |synced_details| of the tracker with |updated_details|.
-  SyncStatusCode UpdateTracker(int64 tracker_id,
+  SyncStatusCode UpdateTracker(int64_t tracker_id,
                                const FileDetails& updated_details);
 
   // Activates a tracker identified by |parent_tracker_id| and |file_id| if the
   // tracker can be activated without inactivating other trackers that have the
   // same |file_id| but different paths.
   // If |file_id| has another active tracker, the function returns
   // ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER and does not invoke |callback|.
   // If there is another active tracker that has the same path but different
   // |file_id|, inactivates the tracker.
   // In success case, returns ACTIVATION_PENDING and invokes |callback| upon
   // completion.
   //
   // The tracker to be activated must:
   //  - have a tracked metadata in the database,
   //  - have |synced_details| with valid |title|.
-  ActivationStatus TryActivateTracker(int64 parent_tracker_id,
+  ActivationStatus TryActivateTracker(int64_t parent_tracker_id,
                                       const std::string& file_id,
                                       SyncStatusCode* status);
 
   // Changes the priority of the tracker to low.
-  void DemoteTracker(int64 tracker_id);
+  void DemoteTracker(int64_t tracker_id);
   bool PromoteDemotedTrackers();
-  void PromoteDemotedTracker(int64 tracker_id);
+  void PromoteDemotedTracker(int64_t tracker_id);
 
   // Returns true if there is a normal priority dirty tracker.
   // Assigns the dirty tracker if exists and |tracker| is non-NULL.
   bool GetDirtyTracker(FileTracker* tracker) const;
 
   // Returns true if there is a low priority dirty tracker.
   bool HasDemotedDirtyTracker() const;
 
   bool HasDirtyTracker() const;
   size_t CountDirtyTracker() const;
@@ skipping 13 matching lines @@
 
  private:
   friend class MetadataDatabaseTest;
 
   MetadataDatabase(const base::FilePath& database_path,
                    bool enable_on_disk_index,
                    leveldb::Env* env_override);
   SyncStatusCode Initialize();
 
   // Database manipulation methods.
-  void RegisterTrackerAsAppRoot(const std::string& app_id,
-                                int64 tracker_id);
+  void RegisterTrackerAsAppRoot(const std::string& app_id, int64_t tracker_id);
 
   void CreateTrackerForParentAndFileID(const FileTracker& parent_tracker,
                                        const std::string& file_id);
   void CreateTrackerForParentAndFileMetadata(const FileTracker& parent_tracker,
                                              const FileMetadata& file_metadata,
                                              UpdateOption option);
   void CreateTrackerInternal(const FileTracker& parent_tracker,
                              const std::string& file_id,
                              const FileDetails* details,
                              UpdateOption option);
 
   void MaybeAddTrackersForNewFile(const FileMetadata& file,
                                   UpdateOption option);
 
-  int64 IncrementTrackerID();
+  int64_t IncrementTrackerID();
 
   bool CanActivateTracker(const FileTracker& tracker);
   bool ShouldKeepDirty(const FileTracker& tracker) const;
 
   bool HasDisabledAppRoot(const FileTracker& tracker) const;
   bool HasActiveTrackerForFileID(const std::string& file_id) const;
-  bool HasActiveTrackerForPath(int64 parent_tracker,
+  bool HasActiveTrackerForPath(int64_t parent_tracker,
                                const std::string& title) const;
 
   void RemoveUnneededTrackersForMissingFile(const std::string& file_id);
   void UpdateByFileMetadata(const tracked_objects::Location& from_where,
                             scoped_ptr<FileMetadata> file,
                             UpdateOption option);
 
   SyncStatusCode WriteToDatabase();
 
-  bool HasNewerFileMetadata(const std::string& file_id, int64 change_id);
+  bool HasNewerFileMetadata(const std::string& file_id, int64_t change_id);
 
   scoped_ptr<base::ListValue> DumpTrackers();
   scoped_ptr<base::ListValue> DumpMetadata();
 
   void AttachSyncRoot(const google_apis::FileResource& sync_root_folder);
   void AttachInitialAppRoot(const google_apis::FileResource& app_root_folder);
 
-  void ForceActivateTrackerByPath(int64 parent_tracker_id,
+  void ForceActivateTrackerByPath(int64_t parent_tracker_id,
                                   const std::string& title,
                                   const std::string& file_id);
 
   bool CanClearDirty(const FileTracker& tracker);
 
   base::FilePath database_path_;
   leveldb::Env* env_override_;
   scoped_ptr<LevelDBWrapper> db_;
 
   bool enable_on_disk_index_;
 
-  int64 largest_known_change_id_;
+  int64_t largest_known_change_id_;
 
   scoped_ptr<MetadataDatabaseIndexInterface> index_;
 
   base::WeakPtrFactory<MetadataDatabase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataDatabase);
 };
 
 }  // namespace drive_backend
 }  // namespace sync_file_system
 
 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_METADATA_DATABASE_H_