[SyncFS] Delete local file on rename and reorganize completion

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 868 matching lines @@
       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());
+  // Check if the tracker's parent is still in |parent_tracker_ids|.
+  // If not, there should exist another tracker for the new parent, so delete
+  // old tracker.
+  DCHECK(ContainsKey(tracker_by_id_, tracker->parent_tracker_id()));
+  FileTracker* parent_tracker = tracker_by_id_[tracker->parent_tracker_id()];
+  if (!HasFileAsParent(updated_details, parent_tracker->file_id())) {
+    RemoveTracker(tracker->tracker_id(), batch.get());
+    WriteToDatabase(batch.Pass(), callback);
+    return;
+  }
+
+  if (tracker->has_synced_details()) {
+    // Check if the tracker was retitled.  If it was, there should exist another
+    // tracker for the new title, so delete old tracker.
+    if (tracker->synced_details().title() != updated_details.title()) {
+      RemoveTracker(tracker->tracker_id(), batch.get());
+      WriteToDatabase(batch.Pass(), callback);
+      return;
+    }
+  } else {
+    int64 parent_tracker_id = parent_tracker->tracker_id();
+    const std::string& title = updated_details.title();
+    trackers_by_parent_and_title_[parent_tracker_id][title].Insert(
+        parent_tracker);
   }
 
   *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)) {
@@ skipping 305 matching lines @@
     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;
+  std::set<int64> parents_to_exclude;
   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();
          itr != found->second.end(); ++itr) {
-      int64 parent_tracker_id = (*itr)->parent_tracker_id();
-      if (parent_tracker_id)
-        known_parents.insert(parent_tracker_id);
+      const FileTracker& tracker = **itr;
+      int64 parent_tracker_id = tracker.parent_tracker_id();
+      if (!parent_tracker_id)
+        continue;
+
+      // Exclude |parent_tracker_id| if it already has a tracker that has
+      // unknown title or has the same title with |file|.
+      if (!tracker.has_synced_details() ||
+          tracker.synced_details().title() == file.details().title()) {
+        parents_to_exclude.insert(parent_tracker_id);
+      }
     }
   }
 
   for (int i = 0; i < file.details().parent_folder_ids_size(); ++i) {
     std::string parent_folder_id = file.details().parent_folder_ids(i);
     TrackersByFileID::iterator found =
         trackers_by_file_id_.find(parent_folder_id);
     if (found == trackers_by_file_id_.end())
       continue;
 
     for (TrackerSet::const_iterator itr = found->second.begin();
          itr != found->second.end(); ++itr) {
       FileTracker* parent_tracker = *itr;
       int64 parent_tracker_id = parent_tracker->tracker_id();
       if (!parent_tracker->active())
         continue;
 
-      if (ContainsKey(known_parents, parent_tracker_id))
+      if (ContainsKey(parents_to_exclude, parent_tracker_id))
         continue;
 
       CreateTrackerForParentAndFileID(*parent_tracker, file.file_id(), batch);
     }
   }
 }
 
 void MetadataDatabase::RemoveAllDescendantTrackers(int64 root_tracker_id,
                                                    leveldb::WriteBatch* batch) {
   std::vector<int64> pending_trackers;
@@ skipping 72 matching lines @@
   TrackersByFileID::iterator found = trackers_by_file_id_.find(file_id);
   if (found != trackers_by_file_id_.end())
     MarkTrackerSetDirty(&found->second, batch);
 }
 
 void MetadataDatabase::MarkTrackersDirtyByPath(int64 parent_tracker_id,
                                                const std::string& title,
                                                leveldb::WriteBatch* batch) {
   TrackersByParentAndTitle::iterator found =
       trackers_by_parent_and_title_.find(parent_tracker_id);
-  if (found == trackers_by_parent_and_title_.end()) {
-    NOTREACHED() << "parent: " << parent_tracker_id
-                 << ", title: " << title;
+  if (found == trackers_by_parent_and_title_.end())
     return;
-  }
 
   TrackersByTitle::iterator itr = found->second.find(title);
   if (itr != found->second.end())
     MarkTrackerSetDirty(&itr->second, batch);
 }
 
 int64 MetadataDatabase::GetNextTrackerID(leveldb::WriteBatch* batch) {
   int64 tracker_id = service_metadata_->next_tracker_id();
   service_metadata_->set_next_tracker_id(tracker_id + 1);
   PutServiceMetadataToBatch(*service_metadata_, batch);
@@ skipping 91 matching lines @@
   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));
@@ skipping 51 matching lines @@
     file->Set("details", details);
 
     files->Append(file);
   }
 
   return files.Pass();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system