Remove unique naming.

chrome/browser/sync/engine/build_and_process_conflict_sets_command.cc

 // Copyright (c) 2006-2009 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/engine/build_and_process_conflict_sets_command.h"
 
 #include <string>
 #include <sstream>
 #include <vector>
 
@@ skipping 74 matching lines @@
 
 void StoreLocalDataForUpdateRollback(syncable::Entry* entry,
                                      syncable::EntryKernel* backup) {
   CHECK(!entry->Get(syncable::IS_UNSYNCED)) << " Storing Rollback data for "
       "entry that's unsynced." << *entry;
   CHECK(entry->Get(syncable::IS_UNAPPLIED_UPDATE)) << " Storing Rollback data "
       "for entry that's not an unapplied update." << *entry;
   *backup = entry->GetKernelCopy();
 }
 
-class UniqueNameGenerator {
- public:
-  void Initialize() {
-    // To avoid name collisions we prefix the names with hex data derived from
-    // 64 bits of randomness.
-    int64 name_prefix = static_cast<int64>(base::RandUint64());
-    name_stem_ = StringPrintf("%0" PRId64 "x.", name_prefix);
-  }
-  string StringNameForEntry(const syncable::Entry& entry) {
-    CHECK(!name_stem_.empty());
-    std::stringstream rv;
-    rv << name_stem_ << entry.Get(syncable::ID);
-    return rv.str();
-  }
-  PathString PathStringNameForEntry(const syncable::Entry& entry) {
-    string name = StringNameForEntry(entry);
-    return PathString(name.begin(), name.end());
-  }
-
- private:
-  string name_stem_;
-};
 
 bool RollbackEntry(syncable::WriteTransaction* trans,
                    syncable::EntryKernel* backup) {
   syncable::MutableEntry entry(trans, syncable::GET_BY_HANDLE,
                                backup->ref(syncable::META_HANDLE));
   CHECK(entry.good());
 
   if (!entry.Put(syncable::IS_DEL, backup->ref(syncable::IS_DEL)))
     return false;
-  syncable::Name name = syncable::Name::FromEntryKernel(backup);
-  if (!entry.PutParentIdAndName(backup->ref(syncable::PARENT_ID), name))
-    return false;
+
+  entry.Put(syncable::NON_UNIQUE_NAME, backup->ref(syncable::NON_UNIQUE_NAME));
+  entry.Put(syncable::PARENT_ID, backup->ref(syncable::PARENT_ID));
 
   if (!backup->ref(syncable::IS_DEL)) {
     if (!entry.PutPredecessor(backup->ref(syncable::PREV_ID)))
       return false;
   }
 
   if (backup->ref(syncable::PREV_ID) != entry.Get(syncable::PREV_ID))
     return false;
 
   entry.Put(syncable::CTIME, backup->ref(syncable::CTIME));
   entry.Put(syncable::MTIME, backup->ref(syncable::MTIME));
   entry.Put(syncable::BASE_VERSION, backup->ref(syncable::BASE_VERSION));
   entry.Put(syncable::IS_DIR, backup->ref(syncable::IS_DIR));
   entry.Put(syncable::IS_DEL, backup->ref(syncable::IS_DEL));
   entry.Put(syncable::ID, backup->ref(syncable::ID));
   entry.Put(syncable::IS_UNAPPLIED_UPDATE,
             backup->ref(syncable::IS_UNAPPLIED_UPDATE));
   return true;
 }
 
-class TransactionalUpdateEntryPreparer {
- public:
-  TransactionalUpdateEntryPreparer() {
-    namegen_.Initialize();
+void PlaceEntriesAtRoot(syncable::WriteTransaction* trans,
+                        const vector<syncable::Id>* ids) {
+  vector<syncable::Id>::const_iterator it;
+  for (it = ids->begin(); it != ids->end(); ++it) {
+    syncable::MutableEntry entry(trans, syncable::GET_BY_ID, *it);
+    entry.Put(syncable::PARENT_ID, trans->root_id());
   }
-
-  void PrepareEntries(syncable::WriteTransaction* trans,
-                      const vector<syncable::Id>* ids) {
-    vector<syncable::Id>::const_iterator it;
-    for (it = ids->begin(); it != ids->end(); ++it) {
-      syncable::MutableEntry entry(trans, syncable::GET_BY_ID, *it);
-      syncable::Name random_name(namegen_.PathStringNameForEntry(entry));
-      CHECK(entry.PutParentIdAndName(trans->root_id(), random_name));
-    }
-  }
-
- private:
-  UniqueNameGenerator namegen_;
-  DISALLOW_COPY_AND_ASSIGN(TransactionalUpdateEntryPreparer);
-};
+}
 
 }  // namespace
 
 bool BuildAndProcessConflictSetsCommand::ApplyUpdatesTransactionally(
     syncable::WriteTransaction* trans,
     const vector<syncable::Id>* const update_set,
     SyncerSession* const session) {
   // The handles in the |update_set| order.
   vector<int64> handles;
 
@@ skipping 22 matching lines @@
   DCHECK_EQ(rollback_ids_inserted_items.size(), update_set->size());
 
   // 3. Store the information needed to rollback if the transaction fails.
   // Do this before modifying anything to keep the next/prev values intact.
   vector<syncable::EntryKernel> rollback_data(rollback_ids.size());
   for (size_t i = 0; i < rollback_ids.size(); ++i) {
     syncable::Entry entry(trans, syncable::GET_BY_ID, rollback_ids[i]);
     StoreLocalDataForUpdateRollback(&entry, &rollback_data[i]);
   }
 
-  // 4. Use the preparer to move things to an initial starting state where no
-  // names collide, and nothing in the set is a child of anything else.  If
+  // 4. Use the preparer to move things to an initial starting state where
+  // nothing in the set is a child of anything else.  If
   // we've correctly calculated the set, the server tree is valid and no
   // changes have occurred locally we should be able to apply updates from this
   // state.
-  TransactionalUpdateEntryPreparer preparer;
-  preparer.PrepareEntries(trans, update_set);
+  PlaceEntriesAtRoot(trans, update_set);
 
   // 5. Use the usual apply updates from the special start state we've just
   // prepared.
   UpdateApplicator applicator(session->resolver(), handles.begin(),
                               handles.end());
   while (applicator.AttemptOneApplication(trans)) {
     // Keep going till all updates are applied.
   }
   if (!applicator.AllUpdatesApplied()) {
     LOG(ERROR) << "Transactional Apply Failed, Rolling back.";
     // We have to move entries into the temp dir again. e.g. if a swap was in a
     // set with other failing updates, the swap may have gone through, meaning
     // the roll back needs to be transactional. But as we're going to a known
     // good state we should always succeed.
-    preparer.PrepareEntries(trans, update_set);
+    PlaceEntriesAtRoot(trans, update_set);
 
     // Rollback all entries.
     for (size_t i = 0; i < rollback_data.size(); ++i) {
       CHECK(RollbackEntry(trans, &rollback_data[i]));
     }
     return false;  // Don't save progress -- we just undid it.
   }
   applicator.SaveProgressIntoSessionState(session);
   return true;
 }
 
 void BuildAndProcessConflictSetsCommand::BuildConflictSets(
     syncable::BaseTransaction* trans,
     ConflictResolutionView* view) {
   view->CleanupSets();
   set<syncable::Id>::iterator i = view->CommitConflictsBegin();
   while (i != view->CommitConflictsEnd()) {
     syncable::Entry entry(trans, syncable::GET_BY_ID, *i);
     CHECK(entry.good());
     if (!entry.Get(syncable::IS_UNSYNCED) &&
         !entry.Get(syncable::IS_UNAPPLIED_UPDATE)) {
       // This can happen very rarely. It means we had a simply conflicting item
       // that randomly committed. We drop the entry as it's no longer
       // conflicting.
       view->EraseCommitConflict(i++);
       continue;
     }
-    if (entry.ExistsOnClientBecauseDatabaseNameIsNonEmpty() &&
+    if (entry.ExistsOnClientBecauseNameIsNonEmpty() &&
        (entry.Get(syncable::IS_DEL) || entry.Get(syncable::SERVER_IS_DEL))) {
        // If we're deleted on client or server we can't be in a complex set.
       ++i;
       continue;
     }
     bool new_parent =
         entry.Get(syncable::PARENT_ID) != entry.Get(syncable::SERVER_PARENT_ID);
-    bool new_name = 0 != syncable::ComparePathNames(entry.GetSyncNameValue(),
-                                          entry.Get(syncable::SERVER_NAME));
-    if (new_parent || new_name)
-      MergeSetsForNameClash(trans, &entry, view);
     if (new_parent)
       MergeSetsForIntroducedLoops(trans, &entry, view);
     MergeSetsForNonEmptyDirectories(trans, &entry, view);
     ++i;
   }
 }
 
-void BuildAndProcessConflictSetsCommand::MergeSetsForNameClash(
-    syncable::BaseTransaction* trans, syncable::Entry* entry,
-    ConflictResolutionView* view) {
-  PathString server_name = entry->Get(syncable::SERVER_NAME);
-  // Uncommitted entries have no server name. We trap this because the root
-  // item has a null name and 0 parentid.
-  if (server_name.empty())
-    return;
-  syncable::Id conflicting_id =
-      SyncerUtil::GetNameConflictingItemId(
-          trans, entry->Get(syncable::SERVER_PARENT_ID), server_name);
-  if (syncable::kNullId != conflicting_id)
-    view->MergeSets(entry->Get(syncable::ID), conflicting_id);
-}
-
 void BuildAndProcessConflictSetsCommand::MergeSetsForIntroducedLoops(
     syncable::BaseTransaction* trans, syncable::Entry* entry,
     ConflictResolutionView* view) {
   // This code crawls up from the item in question until it gets to the root
   // or itself. If it gets to the root it does nothing. If it finds a loop all
   // moved unsynced entries in the list of crawled entries have their sets
   // merged with the entry.
   // TODO(sync): Build test cases to cover this function when the argument list
   // has settled.
   syncable::Id parent_id = entry->Get(syncable::SERVER_PARENT_ID);
@@ skipping 131 matching lines @@
       return;
     LocallyDeletedPathChecker checker;
     if (!checker.CausingConflict(parent, *entry))
       return;
     view->MergeSets(entry->Get(syncable::ID), parent.Get(syncable::ID));
     CrawlDeletedTreeMergingSets(trans, parent, view, checker);
   }
 }
 
 }  // namespace browser_sync