[SyncFS] Wire up MetadataDatabaseIndex to MetadataDatabase

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 <map>
 #include <set>
 #include <string>
@@ skipping 31 matching lines @@
 namespace tracked_objects {
 class Location;
 }
 
 namespace sync_file_system {
 namespace drive_backend {
 
 class FileDetails;
 class FileMetadata;
 class FileTracker;
+class MetadataDatabaseIndex;
 class ServiceMetadata;
 
 struct DatabaseContents {
   scoped_ptr<ServiceMetadata> service_metadata;
   ScopedVector<FileMetadata> file_metadata;
   ScopedVector<FileTracker> file_trackers;
 
   DatabaseContents();
   ~DatabaseContents();
 };
@@ skipping 51 matching lines @@
 //     - have |needs_folder_listing| flag and dirty flag, or
 //     - have all children at the stored largest change ID.
 //
 //   - If multiple trackers have the same parent tracker and same title, they
 //     must not have same |file_id|, and at most one of them may be active.
 //   - If multiple trackers have the same |file_id|, at most one of them may be
 //     active.
 //
 class MetadataDatabase {
  public:
-  typedef base::ScopedPtrHashMap<std::string, FileMetadata> MetadataByID;
-  typedef base::ScopedPtrHashMap<int64, FileTracker> TrackerByID;
-  typedef base::hash_map<std::string, TrackerIDSet> TrackerIDsByFileID;
-  typedef base::hash_map<std::string, TrackerIDSet> TrackerIDsByTitle;
-  typedef std::map<int64, TrackerIDsByTitle> TrackerIDsByParentAndTitle;
-  typedef base::hash_map<std::string, int64> TrackerIDByAppID;
   typedef std::vector<std::string> FileIDList;
 
   typedef base::Callback<
       void(SyncStatusCode status, scoped_ptr<MetadataDatabase> instance)>
       CreateCallback;
 
   enum ActivationStatus {
     ACTIVATION_PENDING,
     ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER,
   };
@@ skipping 214 matching lines @@
   bool GetMultiParentFileTrackers(std::string* file_id,
                                   TrackerIDSet* trackers);
   bool GetConflictingTrackers(TrackerIDSet* trackers);
 
   // Sets |app_ids| to a list of all registered app ids.
   void GetRegisteredAppIDs(std::vector<std::string>* app_ids);
 
  private:
   friend class MetadataDatabaseTest;
 
-  struct DirtyTrackerComparator {
-    bool operator()(const FileTracker* left,
-                    const FileTracker* right) const;
-  };
-
-  typedef std::set<FileTracker*, DirtyTrackerComparator> DirtyTrackers;
-
   MetadataDatabase(base::SequencedTaskRunner* task_runner,
                    const base::FilePath& database_path,
                    leveldb::Env* env_override);
   static void CreateOnTaskRunner(base::SingleThreadTaskRunner* callback_runner,
                                  base::SequencedTaskRunner* task_runner,
                                  const base::FilePath& database_path,
                                  leveldb::Env* env_override,
                                  const CreateCallback& callback);
   SyncStatusCode InitializeOnTaskRunner();
   void BuildIndexes(DatabaseContents* contents);
 
   // Database manipulation methods.
   void RegisterTrackerAsAppRoot(const std::string& app_id,
                                 int64 tracker_id,
                                 leveldb::WriteBatch* batch);
-  void MakeTrackerActive(int64 tracker_id, leveldb::WriteBatch* batch);
-  void MakeTrackerInactive(int64 tracker_id, leveldb::WriteBatch* batch);
-  void MakeAppRootDisabled(int64 tracker_id, leveldb::WriteBatch* batch);
-  void MakeAppRootEnabled(int64 tracker_id, leveldb::WriteBatch* batch);
-
-  void UnregisterTrackerAsAppRoot(const std::string& app_id,
-                                  leveldb::WriteBatch* batch);
-  void RemoveAllDescendantTrackers(int64 root_tracker_id,
-                                   leveldb::WriteBatch* batch);
 
   void CreateTrackerForParentAndFileID(const FileTracker& parent_tracker,
                                        const std::string& file_id,
                                        leveldb::WriteBatch* batch);
   void CreateTrackerForParentAndFileMetadata(const FileTracker& parent_tracker,
                                              const FileMetadata& file_metadata,
                                              UpdateOption option,
                                              leveldb::WriteBatch* batch);
   void CreateTrackerInternal(const FileTracker& parent_tracker,
                              const std::string& file_id,
                              const FileDetails* details,
                              UpdateOption option,
                              leveldb::WriteBatch* batch);
 
-  void RemoveTracker(int64 tracker_id, leveldb::WriteBatch* batch);
-  void RemoveTrackerIgnoringSameTitle(int64 tracker_id,
-                                      leveldb::WriteBatch* batch);
-  void RemoveTrackerInternal(int64 tracker_id,
-                             leveldb::WriteBatch* batch,
-                             bool ignoring_same_title);
   void MaybeAddTrackersForNewFile(const FileMetadata& file,
                                   UpdateOption option,
                                   leveldb::WriteBatch* batch);
 
-  void MarkSingleTrackerAsDirty(FileTracker* tracker,
-                                leveldb::WriteBatch* batch);
-  void ClearDirty(FileTracker* tracker, leveldb::WriteBatch* batch);
-  void MarkTrackerSetDirty(TrackerIDSet* trackers,
-                           leveldb::WriteBatch* batch);
-  void MarkTrackersDirtyByFileID(const std::string& file_id,
-                                 leveldb::WriteBatch* batch);
-  void MarkTrackersDirtyByPath(int64 parent_tracker_id,
-                               const std::string& title,
-                               leveldb::WriteBatch* batch);
-
-  void EraseTrackerFromFileIDIndex(FileTracker* tracker,
-                                   leveldb::WriteBatch* batch);
-  void EraseTrackerFromPathIndex(FileTracker* tracker);
-  void EraseFileFromDatabase(const std::string& file_id,
-                             leveldb::WriteBatch* batch);
-
   int64 IncrementTrackerID(leveldb::WriteBatch* batch);
 
-  void RecursiveMarkTrackerAsDirty(int64 root_tracker_id,
-                                   leveldb::WriteBatch* batch);
   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,
                                const std::string& title) const;
 
   void RemoveUnneededTrackersForMissingFile(const std::string& file_id,
                                             leveldb::WriteBatch* batch);
   void UpdateByFileMetadata(const tracked_objects::Location& from_where,
                             scoped_ptr<FileMetadata> file,
                             UpdateOption option,
                             leveldb::WriteBatch* batch);
 
   void WriteToDatabase(scoped_ptr<leveldb::WriteBatch> batch,
                        const SyncStatusCallback& callback);
 
   bool HasNewerFileMetadata(const std::string& file_id, int64 change_id);
 
   scoped_ptr<base::ListValue> DumpTrackers();
   scoped_ptr<base::ListValue> DumpMetadata();
 
-  void StoreFileMetadata(scoped_ptr<FileMetadata> file_metadata);
-  void StoreFileTracker(scoped_ptr<FileTracker> file_tracker);
-
   void AttachSyncRoot(const google_apis::FileResource& sync_root_folder,
                       leveldb::WriteBatch* batch);
   void AttachInitialAppRoot(const google_apis::FileResource& app_root_folder,
                             leveldb::WriteBatch* batch);
-  void InsertFileTrackerToIndex(FileTracker* tracker);
 
   void ForceActivateTrackerByPath(int64 parent_tracker_id,
                                   const std::string& title,
                                   const std::string& file_id,
                                   leveldb::WriteBatch* batch);
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   base::FilePath database_path_;
   leveldb::Env* env_override_;
   scoped_ptr<leveldb::DB> db_;
 
   scoped_ptr<ServiceMetadata> service_metadata_;
   int64 largest_known_change_id_;
 
-  MetadataByID metadata_by_id_;  // Owned.
-  TrackerByID tracker_by_id_;  // Owned.
-
-  // Maps FileID to trackers.  The active tracker must be unique per FileID.
-  // This must be updated when updating |active| field of a tracker.
-  TrackerIDsByFileID trackers_by_file_id_;  // Not owned.
-
-  // Maps AppID to the app-root tracker.
-  // This must be updated when a tracker is registered/unregistered as an
-  // app-root.
-  TrackerIDByAppID app_root_by_app_id_;  // Not owned.
-
-  // Maps |tracker_id| to its children grouped by their |title|.
-  // If the title is unknown for a tracker, treats its title as empty. Empty
-  // titled file must not be active.
-  // The active tracker must be unique per its parent_tracker and its title.
-  // This must be updated when updating |title|, |active| or
-  // |parent_tracker_id|.
-  TrackerIDsByParentAndTitle trackers_by_parent_and_title_;
-
-  // Holds all trackers which marked as dirty.
-  // This must be updated when updating |dirty| field of a tracker.
-  DirtyTrackers dirty_trackers_;  // Not owned.
-  DirtyTrackers low_priority_dirty_trackers_;  // Not owned.
+  scoped_ptr<MetadataDatabaseIndex> 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_