Remove unique naming.

chrome/browser/sync/engine/syncapi.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/syncapi.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 226 matching lines @@
 
 int64 BaseNode::GetId() const {
   return GetEntry()->Get(syncable::META_HANDLE);
 }
 
 bool BaseNode::GetIsFolder() const {
   return GetEntry()->Get(syncable::IS_DIR);
 }
 
 const std::wstring& BaseNode::GetTitle() const {
-  ServerNameToSyncAPIName(GetEntry()->GetName().non_unique_value(),
-                         &data_->title);
+  ServerNameToSyncAPIName(GetEntry()->Get(syncable::NON_UNIQUE_NAME),
+                          &data_->title);
   return data_->title;
 }
 
 const GURL& BaseNode::GetURL() const {
   GURL url(GetEntry()->Get(syncable::BOOKMARK_URL));
   url.Swap(&data_->url);
   return data_->url;
 }
 
 const int64* BaseNode::GetChildIds(size_t* child_count) const {
@@ skipping 50 matching lines @@
     return;  // Skip redundant changes.
 
   entry_->Put(syncable::IS_DIR, folder);
   MarkForSyncing();
 }
 
 void WriteNode::SetTitle(const std::wstring& title) {
   std::string server_legal_name;
   SyncAPINameToServerName(title, &server_legal_name);
 
-  syncable::Name old_name = entry_->GetName();
+  PathString old_name = entry_->Get(syncable::NON_UNIQUE_NAME);
 
-  if (server_legal_name == old_name.non_unique_value())
+  if (server_legal_name == old_name)
     return;  // Skip redundant changes.
 
-  // Otherwise, derive a new unique name so we have a valid value
-  // to use as the DBName.
-  syncable::SyncName sync_name(server_legal_name);
-  syncable::DBName db_name(sync_name.value());
-  db_name.MakeOSLegal();
-  db_name.MakeNoncollidingForEntry(transaction_->GetWrappedTrans(),
-                                   entry_->Get(syncable::PARENT_ID), entry_);
-
-  syncable::Name new_name = syncable::Name::FromDBNameAndSyncName(db_name,
-                                                                  sync_name);
-  entry_->PutName(new_name);
+  entry_->Put(syncable::NON_UNIQUE_NAME, server_legal_name);
   MarkForSyncing();
 }
 
 void WriteNode::SetURL(const GURL& url) {
   const std::string& url_string = url.spec();
   if (url_string == entry_->Get(syncable::BOOKMARK_URL))
     return;  // Skip redundant changes.
 
   entry_->Put(syncable::BOOKMARK_URL, url_string);
   MarkForSyncing();
@@ skipping 29 matching lines @@
                                const BaseNode* predecessor) {
   DCHECK(!entry_) << "Init called twice";
   // |predecessor| must be a child of |parent| or NULL.
   if (predecessor && predecessor->GetParentId() != parent.GetId()) {
     DCHECK(false);
     return false;
   }
 
   syncable::Id parent_id = parent.GetEntry()->Get(syncable::ID);
 
-  // Start out with a dummy name, but make it unique.  We expect
+  // Start out with a dummy name.  We expect
   // the caller to set a meaningful name after creation.
-  syncable::DBName dummy(kDefaultNameForNewNodes);
-  dummy.MakeOSLegal();
-  dummy.MakeNoncollidingForEntry(transaction_->GetWrappedTrans(), parent_id,
-                                 NULL);
+  PathString dummy(kDefaultNameForNewNodes);
 
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                       syncable::CREATE, parent_id, dummy);
 
   if (!entry_->good())
     return false;
 
   // Entries are untitled folders by default.
   entry_->Put(syncable::IS_DIR, true);
   // TODO(ncarter): Naming this bit IS_BOOKMARK_OBJECT is a bit unfortunate,
@@ skipping 18 matching lines @@
 
   // Filter out redundant changes if both the parent and the predecessor match.
   if (new_parent_id == entry_->Get(syncable::PARENT_ID)) {
     const syncable::Id& old = entry_->Get(syncable::PREV_ID);
     if ((!predecessor && old.IsRoot()) ||
         (predecessor && (old == predecessor->GetEntry()->Get(syncable::ID)))) {
       return true;
     }
   }
 
-  // Discard the old database name, derive a new database name from the sync
-  // name, and make it legal and unique.
-  syncable::Name name = syncable::Name::FromSyncName(GetEntry()->GetName());
-  name.db_value().MakeOSLegal();
-  name.db_value().MakeNoncollidingForEntry(GetTransaction()->GetWrappedTrans(),
-                                           new_parent_id, entry_);
-
-  // Atomically change the parent and name. This will fail if it would
+  // Atomically change the parent. This will fail if it would
   // introduce a cycle in the hierarchy.
-  if (!entry_->PutParentIdAndName(new_parent_id, name))
+  if (!entry_->Put(syncable::PARENT_ID, new_parent_id))
     return false;
 
   // Now set the predecessor, which sets IS_UNSYNCED as necessary.
   PutPredecessor(predecessor);
 
   return true;
 }
 
 const syncable::Entry* WriteNode::GetEntry() const {
   return entry_;
@@ skipping 358 matching lines @@
     if (a.ref(syncable::PARENT_ID) != b.Get(syncable::PARENT_ID))
       return true;
     return false;
   }
 
   // Determine if any of the fields made visible to clients of the Sync API
   // differ between the versions of an entry stored in |a| and |b|. A return
   // value of false means that it should be OK to ignore this change.
   static bool BookmarkPropertiesDiffer(const syncable::EntryKernel& a,
                                        const syncable::Entry& b) {
-    if (a.ref(syncable::NAME) != b.Get(syncable::NAME))
-      return true;
-    if (a.ref(syncable::UNSANITIZED_NAME) != b.Get(syncable::UNSANITIZED_NAME))
+    if (a.ref(syncable::NON_UNIQUE_NAME) != b.Get(syncable::NON_UNIQUE_NAME))
       return true;
     if (a.ref(syncable::IS_DIR) != b.Get(syncable::IS_DIR))
       return true;
     if (a.ref(syncable::BOOKMARK_URL) != b.Get(syncable::BOOKMARK_URL))
       return true;
     if (a.ref(syncable::BOOKMARK_FAVICON) != b.Get(syncable::BOOKMARK_FAVICON))
       return true;
     if (BookmarkPositionsDiffer(a, b))
       return true;
     return false;
@@ skipping 701 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api