[SyncFS] Refactor MetadataDatabase on dirty flag handling and sync-root creation

chrome/browser/sync_file_system/drive_backend/metadata_database.cc

 // 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.
 
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 66 matching lines @@
   result.reserve(total_size);
   for (PathComponents::const_reverse_iterator itr = components.rbegin();
        itr != components.rend(); ++itr) {
     result.append(1, base::FilePath::kSeparators[0]);
     result.append(itr->value());
   }
 
   return base::FilePath(result).NormalizePathSeparators();
 }
 
-void CreateInitialSyncRootTracker(
+scoped_ptr<FileTracker> CreateSyncRootTracker(
     int64 tracker_id,
-    const google_apis::FileResource& file_resource,
-    scoped_ptr<FileMetadata>* file_out,
-    scoped_ptr<FileTracker>* tracker_out) {
-  FileDetails details;
-  PopulateFileDetailsByFileResource(file_resource, &details);
-
-  scoped_ptr<FileMetadata> file(new FileMetadata);
-  file->set_file_id(file_resource.file_id());
-  *file->mutable_details() = details;
-
-  scoped_ptr<FileTracker> tracker(new FileTracker);
-  tracker->set_tracker_id(tracker_id);
-  tracker->set_file_id(file_resource.file_id());
-  tracker->set_parent_tracker_id(0);
-  tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
-  tracker->set_dirty(false);
-  tracker->set_active(true);
-  tracker->set_needs_folder_listing(false);
-  *tracker->mutable_synced_details() = details;
-
-  *file_out = file.Pass();
-  *tracker_out = tracker.Pass();
+    const FileMetadata& sync_root_metadata) {
+  scoped_ptr<FileTracker> sync_root_tracker(new FileTracker);
+  sync_root_tracker->set_tracker_id(tracker_id);
+  sync_root_tracker->set_file_id(sync_root_metadata.file_id());
+  sync_root_tracker->set_parent_tracker_id(0);
+  sync_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
+  sync_root_tracker->set_dirty(false);
+  sync_root_tracker->set_active(true);
+  sync_root_tracker->set_needs_folder_listing(false);
+  *sync_root_tracker->mutable_synced_details() = sync_root_metadata.details();
+  return sync_root_tracker.Pass();
 }
 
 void CreateInitialAppRootTracker(
     int64 tracker_id,
     const FileTracker& parent_tracker,
     const google_apis::FileResource& file_resource,
     scoped_ptr<FileMetadata>* file_out,
     scoped_ptr<FileTracker>* tracker_out) {
   FileDetails details;
   PopulateFileDetailsByFileResource(file_resource, &details);
@@ skipping 16 matching lines @@
   *tracker_out = tracker.Pass();
 }
 
 void AdaptLevelDBStatusToSyncStatusCode(const SyncStatusCallback& callback,
                                         const leveldb::Status& status) {
   callback.Run(LevelDBStatusToSyncStatusCode(status));
 }
 
 void PutFileDeletionToBatch(const std::string& file_id,
                             leveldb::WriteBatch* batch) {
-  batch->Delete(kFileMetadataKeyPrefix + file_id);
+  if (batch)
+    batch->Delete(kFileMetadataKeyPrefix + file_id);
 }
 
 void PutTrackerDeletionToBatch(int64 tracker_id, leveldb::WriteBatch* batch) {
-  batch->Delete(kFileTrackerKeyPrefix + base::Int64ToString(tracker_id));
+  if (batch)
+    batch->Delete(kFileTrackerKeyPrefix + base::Int64ToString(tracker_id));
 }
 
 template <typename OutputIterator>
 OutputIterator PushChildTrackersToContainer(
     const TrackersByParentAndTitle& trackers_by_parent,
     int64 parent_tracker_id,
     OutputIterator target_itr) {
   TrackersByParentAndTitle::const_iterator found =
       trackers_by_parent.find(parent_tracker_id);
   if (found == trackers_by_parent.end())
@@ skipping 164 matching lines @@
 }
 
 SyncStatusCode InitializeServiceMetadata(DatabaseContents* contents,
                                          leveldb::WriteBatch* batch) {
   if (!contents->service_metadata) {
     contents->service_metadata.reset(new ServiceMetadata);
     contents->service_metadata->set_next_tracker_id(1);
 
     std::string value;
     contents->service_metadata->SerializeToString(&value);
-    batch->Put(kServiceMetadataKey, value);
+    if (batch)
+      batch->Put(kServiceMetadataKey, value);
   }
   return SYNC_STATUS_OK;
 }
 
 SyncStatusCode RemoveUnreachableItems(DatabaseContents* contents,
                                       leveldb::WriteBatch* batch) {
   TrackerByID unvisited_trackers;
   typedef std::map<int64, std::set<FileTracker*> > TrackersByParent;
   TrackersByParent trackers_by_parent;
 
@@ skipping 202 matching lines @@
   DCHECK(tracker_by_id_.empty());
   DCHECK(file_by_id_.empty());
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   service_metadata_->set_largest_change_id(largest_change_id);
   UpdateLargestKnownChangeID(largest_change_id);
 
   FileTracker* sync_root_tracker = NULL;
   int64 sync_root_tracker_id = 0;
   {
-    scoped_ptr<FileMetadata> folder;
-    scoped_ptr<FileTracker> tracker;
-    CreateInitialSyncRootTracker(IncrementTrackerID(batch.get()),
-                                 sync_root_folder,
-                                 &folder,
-                                 &tracker);
+    scoped_ptr<FileMetadata> folder =
+        CreateFileMetadataFromFileResource(largest_change_id, sync_root_folder);
+    scoped_ptr<FileTracker> tracker =
+        CreateSyncRootTracker(IncrementTrackerID(batch.get()), *folder);
+
     std::string sync_root_folder_id = folder->file_id();
     sync_root_tracker = tracker.get();
     sync_root_tracker_id = tracker->tracker_id();
 
     PutFileToBatch(*folder, batch.get());
     PutTrackerToBatch(*tracker, batch.get());
 
     service_metadata_->set_sync_root_tracker_id(tracker->tracker_id());
     PutServiceMetadataToBatch(*service_metadata_, batch.get());
 
@@ skipping 378 matching lines @@
   MakeTrackerActive(new_tracker->tracker_id(), batch.get());
 
   if (new_tracker->synced_details().title() != title) {
     trackers_by_parent_and_title_[parent_tracker_id]
         [GetTrackerTitle(*new_tracker)].Erase(new_tracker);
     trackers_by_parent_and_title_[parent_tracker_id][title].Insert(
         new_tracker);
   }
   *new_tracker->mutable_synced_details() = new_file_details;
 
-  new_tracker->set_dirty(false);
-  dirty_trackers_.erase(new_tracker);
-  low_priority_dirty_trackers_.erase(new_tracker);
-  PutTrackerToBatch(*new_tracker, batch.get());
-
+  ClearDirty(new_tracker, batch.get());
   WriteToDatabase(batch.Pass(), callback);
 }
 
 void MetadataDatabase::PopulateFolderByChildList(
     const std::string& folder_id,
     const FileIDList& child_file_ids,
     const SyncStatusCallback& callback) {
   TrackerSet trackers;
   if (!FindTrackersByFileID(folder_id, &trackers) ||
       !trackers.has_active()) {
@@ skipping 14 matching lines @@
                                std::back_inserter(known_children));
   for (std::vector<int64>::iterator itr = known_children.begin();
        itr != known_children.end(); ++itr)
     children.erase(tracker_by_id_[*itr]->file_id());
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   for (FileIDList::const_iterator itr = child_file_ids.begin();
        itr != child_file_ids.end(); ++itr)
     CreateTrackerForParentAndFileID(*folder_tracker, *itr, batch.get());
   folder_tracker->set_needs_folder_listing(false);
-  if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker)) {
-    folder_tracker->set_dirty(false);
-    dirty_trackers_.erase(folder_tracker);
-    low_priority_dirty_trackers_.erase(folder_tracker);
-  }
+  if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker))
+    ClearDirty(folder_tracker, NULL);
   PutTrackerToBatch(*folder_tracker, batch.get());
 
   WriteToDatabase(batch.Pass(), callback);
 }
 
 void MetadataDatabase::UpdateTracker(int64 tracker_id,
                                      const FileDetails& updated_details,
                                      const SyncStatusCallback& callback) {
   TrackerByID::iterator found = tracker_by_id_.find(tracker_id);
   if (found == tracker_by_id_.end()) {
@@ skipping 64 matching lines @@
     }
   }
 
   *tracker->mutable_synced_details() = updated_details;
 
   // Activate the tracker if:
   //   - There is no active tracker that tracks |tracker->file_id()|.
   //   - There is no active tracker that has the same |parent| and |title|.
   if (!tracker->active() && CanActivateTracker(*tracker))
     MakeTrackerActive(tracker->tracker_id(), batch.get());
-  if (tracker->dirty() && !ShouldKeepDirty(*tracker)) {
-    tracker->set_dirty(false);
-    dirty_trackers_.erase(tracker);
-    low_priority_dirty_trackers_.erase(tracker);
-  }
+  if (tracker->dirty() && !ShouldKeepDirty(*tracker))
+    ClearDirty(tracker, NULL);
   PutTrackerToBatch(*tracker, batch.get());
 
   WriteToDatabase(batch.Pass(), callback);
 }
 
 MetadataDatabase::ActivationStatus MetadataDatabase::TryNoSideEffectActivation(
     int64 parent_tracker_id,
     const std::string& file_id,
     const SyncStatusCallback& callback) {
   DCHECK(ContainsKey(tracker_by_id_, parent_tracker_id));
@@ skipping 40 matching lines @@
   if (!tracker->has_synced_details() ||
       tracker->synced_details().title() != title) {
     trackers_by_parent_and_title_[parent_tracker_id]
         [GetTrackerTitle(*tracker)].Erase(tracker);
     trackers_by_parent_and_title_[parent_tracker_id][title].Insert(
         tracker);
   }
   *tracker->mutable_synced_details() = file.details();
 
   MakeTrackerActive(tracker->tracker_id(), batch.get());
-  tracker->set_dirty(false);
-  dirty_trackers_.erase(tracker);
-  low_priority_dirty_trackers_.erase(tracker);
-  PutTrackerToBatch(*tracker, batch.get());
+  ClearDirty(tracker, batch.get());
 
   WriteToDatabase(batch.Pass(), callback);
   return ACTIVATION_PENDING;
 }
 
 void MetadataDatabase::LowerTrackerPriority(int64 tracker_id) {
   TrackerByID::const_iterator found = tracker_by_id_.find(tracker_id);
   if (found == tracker_by_id_.end())
     return;
 
@@ skipping 241 matching lines @@
   trackers_by_file_id_[tracker->file_id()].Activate(tracker);
   if (parent_tracker_id) {
     trackers_by_parent_and_title_[parent_tracker_id][
         tracker->synced_details().title()].Activate(tracker);
   }
   tracker->set_active(true);
   tracker->set_needs_folder_listing(
       tracker->synced_details().file_kind() == FILE_KIND_FOLDER);
 
   // Make |tracker| a normal priority dirty tracker.
-  if (tracker->dirty())
-    low_priority_dirty_trackers_.erase(tracker);
-  tracker->set_dirty(true);
-  dirty_trackers_.insert(tracker);
-
+  MarkSingleTrackerAsDirty(tracker, NULL);
   PutTrackerToBatch(*tracker, batch);
 }
 
 void MetadataDatabase::MakeTrackerInactive(int64 tracker_id,
                                            leveldb::WriteBatch* batch) {
   FileTracker* tracker = tracker_by_id_[tracker_id];
   DCHECK(tracker);
   DCHECK(tracker->active());
   DCHECK_EQ(TRACKER_KIND_REGULAR, tracker->tracker_kind());
   trackers_by_file_id_[tracker->file_id()].Inactivate(tracker);
@@ skipping 223 matching lines @@
   TrackerSet* conflicting_trackers = &found_by_title->second;
   conflicting_trackers->Erase(tracker);
 
   if (conflicting_trackers->tracker_set().empty()) {
     trackers_by_title->erase(found_by_title);
     if (trackers_by_title->empty())
       trackers_by_parent_and_title_.erase(found);
   }
 }
 
-void MetadataDatabase::MarkSingleTrackerDirty(FileTracker* tracker,
-                                              leveldb::WriteBatch* batch) {
+void MetadataDatabase::MarkSingleTrackerAsDirty(FileTracker* tracker,
+                                                leveldb::WriteBatch* batch) {
   if (!tracker->dirty()) {
     tracker->set_dirty(true);
     PutTrackerToBatch(*tracker, batch);
   }
   dirty_trackers_.insert(tracker);
   low_priority_dirty_trackers_.erase(tracker);
 }
 
+void MetadataDatabase::ClearDirty(FileTracker* tracker,
+                                  leveldb::WriteBatch* batch) {
+  if (tracker->dirty()) {
+    tracker->set_dirty(false);
+    PutTrackerToBatch(*tracker, batch);
+  }
+
+  dirty_trackers_.erase(tracker);
+  low_priority_dirty_trackers_.erase(tracker);
+}
+
 void MetadataDatabase::MarkTrackerSetDirty(
     TrackerSet* trackers,
     leveldb::WriteBatch* batch) {
   for (TrackerSet::iterator itr = trackers->begin();
        itr != trackers->end(); ++itr) {
-    MarkSingleTrackerDirty(*itr, batch);
+    MarkSingleTrackerAsDirty(*itr, batch);
   }
 }
 
 void MetadataDatabase::MarkTrackersDirtyByFileID(
     const std::string& file_id,
     leveldb::WriteBatch* batch) {
   TrackersByFileID::iterator found = trackers_by_file_id_.find(file_id);
   if (found != trackers_by_file_id_.end())
     MarkTrackerSetDirty(&found->second, batch);
 }
@@ skipping 22 matching lines @@
 void MetadataDatabase::RecursiveMarkTrackerAsDirty(int64 root_tracker_id,
                                                    leveldb::WriteBatch* batch) {
   std::vector<int64> stack;
   stack.push_back(root_tracker_id);
   while (!stack.empty()) {
     int64 tracker_id = stack.back();
     stack.pop_back();
     PushChildTrackersToContainer(
         trackers_by_parent_and_title_, tracker_id, std::back_inserter(stack));
 
-    FileTracker* tracker = tracker_by_id_[tracker_id];
-    if (!tracker->dirty()) {
-      tracker->set_dirty(true);
-      PutTrackerToBatch(*tracker, batch);
-      dirty_trackers_.insert(tracker);
-      low_priority_dirty_trackers_.erase(tracker);
-    }
+    MarkSingleTrackerAsDirty(tracker_by_id_[tracker_id], batch);
   }
 }
 
 bool MetadataDatabase::CanActivateTracker(const FileTracker& tracker) {
   DCHECK(!tracker.active());
   DCHECK_NE(service_metadata_->sync_root_tracker_id(), tracker.tracker_id());
 
   if (HasActiveTrackerForFileID(tracker.file_id()))
     return false;
 
@@ skipping 111 matching lines @@
 
   if (FindTrackersByFileID(file_id, NULL)) {
     MarkTrackersDirtyByFileID(file_id, batch);
     PutFileToBatch(*file, batch);
     StoreFileMetadata(file.Pass());
   }
 }
 
 void MetadataDatabase::WriteToDatabase(scoped_ptr<leveldb::WriteBatch> batch,
                                        const SyncStatusCallback& callback) {
+  if (!batch) {
+    RunSoon(FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
+    return;
+  }
+
   base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(&leveldb::DB::Write,
                  base::Unretained(db_.get()),
                  leveldb::WriteOptions(),
                  base::Owned(batch.release())),
       base::Bind(&AdaptLevelDBStatusToSyncStatusCode, callback));
 }
 
@@ skipping 168 matching lines @@
 void MetadataDatabase::StoreFileTracker(scoped_ptr<FileTracker> file_tracker) {
   DCHECK(file_tracker);
 
   int64 tracker_id = file_tracker->tracker_id();
   DCHECK(!ContainsKey(tracker_by_id_, tracker_id));
   tracker_by_id_[tracker_id] = file_tracker.release();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system