[SyncFS] Add MetadataDatabase::UpdateTracker

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 663 matching lines @@
 
       FileMetadata* file_ptr = file.release();
       std::swap(file_ptr, file_by_id_[file_id]);
       delete file_ptr;
     }
   }
 
   WriteToDatabase(batch.Pass(), callback);
 }
 
-void MetadataDatabase::PopulateFolder(const std::string& folder_id,
-                                      const FileIDList& child_file_ids,
-                                      const SyncStatusCallback& 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()) {
     // It's OK that there is no folder to populate its children.
     // Inactive folders should ignore their contents updates.
     RunSoon(FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
     return;
   }
 
   FileTracker* folder_tracker =
       tracker_by_id_[trackers.active_tracker()->tracker_id()];
   DCHECK(folder_tracker);
   std::set<std::string> children(child_file_ids.begin(), child_file_ids.end());
 
   std::vector<int64> known_children;
   PushChildTrackersToContainer(trackers_by_parent_and_title_,
                                folder_tracker->tracker_id(),
                                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 (!ShouldKeepDirty(*folder_tracker)) {
+  if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker)) {
     folder_tracker->set_dirty(false);
     dirty_trackers_.erase(folder_tracker);
   }
   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()) {
+    RunSoon(FROM_HERE, base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
+    return;
+  }
+
+  FileTracker* tracker = found->second;
+  DCHECK(tracker);
+
+  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
+
+  if (updated_details.deleted()) {
+    // The update deletes the local file.
+    FileByID::iterator found = file_by_id_.find(tracker->file_id());
+    if (found == file_by_id_.end() || found->second->details().deleted()) {
+      // Both the tracker and metadata have the deleted flag, now it's safe to
+      // delete the |tracker|.
+      RemoveTracker(tracker->tracker_id(), batch.get());
+    } else {
+      // The local file is deleted, but corresponding remote file isn't.
+      // Put the tracker back to the initial state.
+      tracker->clear_synced_details();
+      tracker->set_dirty(true);
+      tracker->set_active(false);
+      PutTrackerToBatch(*tracker, batch.get());
+    }
+
+    WriteToDatabase(batch.Pass(), callback);
+    return;
+  }
+
+  // Check if the tracker was retitled.  If it was, update the title and its
+  // index in advance.
+  if (!tracker->has_synced_details() ||
+      tracker->synced_details().title() != updated_details.title()) {
+    UpdateTrackerTitle(tracker, updated_details.title(), batch.get());
+  }
+
+  *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);
+  }
+  PutTrackerToBatch(*tracker, batch.get());
+
+  WriteToDatabase(batch.Pass(), callback);
+}
+
 MetadataDatabase::MetadataDatabase(base::SequencedTaskRunner* task_runner)
     : task_runner_(task_runner), weak_ptr_factory_(this) {
   DCHECK(task_runner);
 }
 
 // static
 void MetadataDatabase::CreateOnTaskRunner(
     base::SingleThreadTaskRunner* callback_runner,
     base::SequencedTaskRunner* task_runner,
     const base::FilePath& database_path,
@@ skipping 221 matching lines @@
   // FileMetadata::details but from FileTracker::synced_details, which is filled
   // on tracker updated phase.  Use empty string as the title since
   // FileTracker::synced_details is empty here.
   trackers_by_parent_and_title_[parent_tracker.tracker_id()][std::string()]
       .Insert(tracker.get());
   dirty_trackers_.insert(tracker.get());
   DCHECK(!ContainsKey(tracker_by_id_, tracker_id));
   tracker_by_id_[tracker_id] = tracker.release();
 }
 
+void MetadataDatabase::RemoveTracker(int64 tracker_id,
+                                     leveldb::WriteBatch* batch) {
+  RemoveTrackerInternal(tracker_id, batch, false);
+}
+
 void MetadataDatabase::RemoveTrackerIgnoringSiblings(
     int64 tracker_id,
     leveldb::WriteBatch* batch) {
+  RemoveTrackerInternal(tracker_id, batch, true);
+}
+
+void MetadataDatabase::RemoveTrackerInternal(
+    int64 tracker_id,
+    leveldb::WriteBatch* batch,
+    bool ignoring_siblings) {
   scoped_ptr<FileTracker> tracker(
       FindAndEraseItem(&tracker_by_id_, tracker_id));
   if (!tracker)
     return;
 
   EraseTrackerFromFileIDIndex(tracker.get(), batch);
   if (IsAppRoot(*tracker))
     app_root_by_app_id_.erase(tracker->app_id());
   EraseTrackerFromPathIndex(tracker.get());
 
   MarkTrackersDirtyByFileID(tracker->file_id(), batch);
-  // Do not mark the same path trackers as dirty, since the caller is deleting
-  // all its siblings.
+  if (!ignoring_siblings) {
+    MarkTrackersDirtyByPath(tracker->parent_tracker_id(),
+                            GetTrackerTitle(*tracker),
+                            batch);
+  }
   PutTrackerDeletionToBatch(tracker_id, batch);
 }
 
 void MetadataDatabase::MaybeAddTrackersForNewFile(
     const FileMetadata& file,
     leveldb::WriteBatch* batch) {
   std::set<int64> known_parents;
   TrackersByFileID::iterator found = trackers_by_file_id_.find(file.file_id());
   if (found != trackers_by_file_id_.end()) {
     for (TrackerSet::const_iterator itr = found->second.begin();
@@ skipping 142 matching lines @@
 
     FileTracker* tracker = tracker_by_id_[tracker_id];
     if (!tracker->dirty()) {
       tracker->set_dirty(true);
       PutTrackerToBatch(*tracker, batch);
       dirty_trackers_.insert(tracker);
     }
   }
 }
 
+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;
+
+  if (tracker.app_id().empty())
+    return false;
+  if (!tracker.has_synced_details())
+    return false;
+  DCHECK(tracker.parent_tracker_id());
+
+  return !HasActiveTrackerForPath(tracker.parent_tracker_id(),
+                                  tracker.synced_details().title());
+}
+
 bool MetadataDatabase::ShouldKeepDirty(const FileTracker& tracker) const {
+  if (HasDisabledAppRoot(tracker))
+    return false;
+
   DCHECK(tracker.dirty());
   if (!tracker.has_synced_details())
     return true;
 
   FileByID::const_iterator found = file_by_id_.find(tracker.file_id());
   if (found == file_by_id_.end())
     return true;
-  const FileMetadata& file = *found->second;
+  const FileMetadata* file = found->second;
+  DCHECK(file);
 
   if (tracker.active()) {
     if (tracker.needs_folder_listing())
       return true;
-    if (tracker.synced_details().md5() != file.details().md5())
+    if (tracker.synced_details().md5() != file->details().md5())
       return true;
   }
 
   const FileDetails& local_details = tracker.synced_details();
-  const FileDetails& remote_details = file.details();
+  const FileDetails& remote_details = file->details();
 
   if (local_details.title() != remote_details.title())
     return true;
   if (local_details.deleted() != remote_details.deleted())
     return true;
 
   return false;
 }
 
+bool MetadataDatabase::HasDisabledAppRoot(const FileTracker& tracker) const {
+  TrackerByAppID::const_iterator found =
+      app_root_by_app_id_.find(tracker.app_id());
+  if (found == app_root_by_app_id_.end())
+    return false;
+
+  const FileTracker* app_root_tracker = found->second;
+  DCHECK(app_root_tracker);
+  return app_root_tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT;
+}
+
+bool MetadataDatabase::HasActiveTrackerForFileID(
+    const std::string& file_id) const {
+  TrackersByFileID::const_iterator found = trackers_by_file_id_.find(file_id);
+  return found != trackers_by_file_id_.end() && found->second.has_active();
+}
+
+bool MetadataDatabase::HasActiveTrackerForPath(int64 parent_tracker_id,
+                                               const std::string& title) const {
+  TrackersByParentAndTitle::const_iterator found_by_parent =
+      trackers_by_parent_and_title_.find(parent_tracker_id);
+  if (found_by_parent == trackers_by_parent_and_title_.end())
+    return false;
+
+  const TrackersByTitle& trackers_by_title = found_by_parent->second;
+  TrackersByTitle::const_iterator found = trackers_by_title.find(title);
+  return found != trackers_by_title.end() && found->second.has_active();
+}
+
+void MetadataDatabase::UpdateTrackerTitle(FileTracker* tracker,
+                                          const std::string& new_title,
+                                          leveldb::WriteBatch* batch) {
+  int64 parent_id = tracker->parent_tracker_id();
+  std::string old_title = GetTrackerTitle(*tracker);
+  DCHECK_NE(old_title, new_title);
+  DCHECK(!new_title.empty());
+
+  TrackersByTitle* trackers_by_title =
+      &trackers_by_parent_and_title_[parent_id];
+  TrackerSet* old_siblings = &(*trackers_by_title)[old_title];
+  TrackerSet* new_siblings = &(*trackers_by_title)[new_title];
+
+  old_siblings->Erase(tracker);
+  if (old_siblings->empty())
+    trackers_by_title->erase(old_title);
+  else
+    MarkTrackerSetDirty(old_siblings, batch);
+
+  if (tracker->active() && new_siblings->has_active()) {
+    // Inactivate existing active tracker.
+    FileTracker* obstacle = new_siblings->active_tracker();
+    new_siblings->Inactivate(obstacle);
+    DCHECK_EQ(TRACKER_KIND_REGULAR, obstacle->tracker_kind());
+
+    TrackerSet* same_file_id_trackers_to_obstacle =
+        &trackers_by_file_id_[obstacle->file_id()];
+    same_file_id_trackers_to_obstacle->Inactivate(obstacle);
+    MarkTrackerSetDirty(same_file_id_trackers_to_obstacle, batch);
+
+    obstacle->set_active(false);
+    PutTrackerToBatch(*obstacle, batch);
+
+    RemoveAllDescendantTrackers(obstacle->tracker_id(), batch);
+  }
+
+  tracker->mutable_synced_details()->set_title(new_title);
+  new_siblings->Insert(tracker);
+  PutTrackerToBatch(*tracker, batch);
+}
+
 void MetadataDatabase::WriteToDatabase(scoped_ptr<leveldb::WriteBatch> batch,
                                        const SyncStatusCallback& callback) {
   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));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system