Add unique hashing to sync API.

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 14 matching lines @@
 
 #include <iomanip>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/lock.h"
 #include "base/platform_thread.h"
 #include "base/scoped_ptr.h"
+#include "base/sha1.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/auth_watcher.h"
 #include "chrome/browser/sync/engine/change_reorder_buffer.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/gaia_authenticator.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/net/syncapi_server_connection_manager.h"
@@ skipping 337 matching lines @@
   }
 }
 
 ////////////////////////////////////
 // BaseNode member definitions.
 
 BaseNode::BaseNode() {}
 
 BaseNode::~BaseNode() {}
 
+std::string BaseNode::GenerateSyncableHash(
+    syncable::ModelType model_type, const std::string& client_tag) {
+  // blank PB with just the extension in it has termination symbol,
+  // handy for delimiter
+  sync_pb::EntitySpecifics serialized_type;
+  syncable::AddDefaultExtensionValue(model_type, &serialized_type);
+  std::string hash_input;
+  serialized_type.AppendToString(&hash_input);
+  hash_input.append(client_tag);
+  return base::SHA1HashString(hash_input);
+}
+
 int64 BaseNode::GetParentId() const {
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(),
                         GetEntry()->Get(syncable::PARENT_ID));
 }
 
 int64 BaseNode::GetId() const {
   return GetEntry()->Get(syncable::META_HANDLE);
 }
 
 bool BaseNode::GetIsFolder() const {
@@ skipping 147 matching lines @@
   DCHECK(!entry_) << "Init called twice";
   DCHECK_NE(id, kInvalidId);
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                       syncable::GET_BY_HANDLE, id);
   return (entry_->good() && !entry_->Get(syncable::IS_DEL));
 }
 
 // Find a node by client tag, and bind this WriteNode to it.
 // Return true if the write node was found, and was not deleted.
 // Undeleting a deleted node is possible by ClientTag.
-bool WriteNode::InitByClientTagLookup(const std::string& tag) {
+bool WriteNode::InitByClientTagLookup(syncable::ModelType model_type,
+                                      const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
   if (tag.empty())
     return false;
+
+  const std::string hash = GenerateSyncableHash(model_type, tag);
+
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
-                                      syncable::GET_BY_CLIENT_TAG, tag);
+                                      syncable::GET_BY_CLIENT_TAG, hash);
   return (entry_->good() && !entry_->Get(syncable::IS_DEL));
 }
 
 void WriteNode::PutModelType(syncable::ModelType model_type) {
   // Set an empty specifics of the appropriate datatype.  The presence
   // of the specific extension will identify the model type.
+  DCHECK(GetModelType() == model_type ||
+         GetModelType() == syncable::UNSPECIFIED);  // Immutable once set.
+
   sync_pb::EntitySpecifics specifics;
   syncable::AddDefaultExtensionValue(model_type, &specifics);
   PutSpecificsAndMarkForSyncing(specifics);
   DCHECK(GetModelType() == model_type);
 }
 
 // Create a new node with default properties, and bind this WriteNode to it.
 // Return true on success.
 bool WriteNode::InitByCreation(syncable::ModelType model_type,
                                const BaseNode& parent,
@@ skipping 32 matching lines @@
 // and bind this WriteNode to it.
 // Return true on success. If the tag exists in the database, then
 // we will attempt to undelete the node.
 // TODO(chron): Code datatype into hash tag.
 // TODO(chron): Is model type ever lost?
 bool WriteNode::InitUniqueByCreation(syncable::ModelType model_type,
                                      const BaseNode& parent,
                                      const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
 
+  const std::string hash = GenerateSyncableHash(model_type, tag);
+
   syncable::Id parent_id = parent.GetEntry()->Get(syncable::ID);
 
   // Start out with a dummy name.  We expect
   // the caller to set a meaningful name after creation.
   string dummy(kDefaultNameForNewNodes);
 
   // Check if we have this locally and need to undelete it.
   scoped_ptr<syncable::MutableEntry> existing_entry(
       new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
-                                 syncable::GET_BY_CLIENT_TAG, tag));
+                                 syncable::GET_BY_CLIENT_TAG, hash));
 
   if (existing_entry->good()) {
     if (existing_entry->Get(syncable::IS_DEL)) {
       // Rules for undelete:
       // BASE_VERSION: Must keep the same.
       // ID: Essential to keep the same.
       // META_HANDLE: Must be the same, so we can't "split" the entry.
       // IS_DEL: Must be set to false, will cause reindexing.
       //         This one is weird because IS_DEL is true for "update only"
       //         items. It should be OK to undelete an update only.
@@ skipping 20 matching lines @@
       return false;
     }
   } else {
     entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                         syncable::CREATE, parent_id, dummy);
     if (!entry_->good()) {
       return false;
     }
 
     // Only set IS_DIR for new entries. Don't bitflip undeleted ones.
-    entry_->Put(syncable::UNIQUE_CLIENT_TAG, tag);
+    entry_->Put(syncable::UNIQUE_CLIENT_TAG, hash);
   }
 
   // We don't support directory and tag combinations.
   entry_->Put(syncable::IS_DIR, false);
 
   // Will clear specifics data.
   PutModelType(model_type);
 
   // Now set the predecessor, which sets IS_UNSYNCED as necessary.
   PutPredecessor(NULL);
@@ skipping 90 matching lines @@
     return false;
   if (entry_->Get(syncable::IS_DEL))
     return false;
   syncable::ModelType model_type = GetModelType();
   LOG_IF(WARNING, model_type == syncable::UNSPECIFIED ||
                   model_type == syncable::TOP_LEVEL_FOLDER)
       << "SyncAPI InitByIdLookup referencing unusual object.";
   return true;
 }
 
-bool ReadNode::InitByClientTagLookup(const std::string& tag) {
+bool ReadNode::InitByClientTagLookup(syncable::ModelType model_type,
+                                     const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
   if (tag.empty())
     return false;
+
+  const std::string hash = GenerateSyncableHash(model_type, tag);
+
   entry_ = new syncable::Entry(transaction_->GetWrappedTrans(),
-                               syncable::GET_BY_CLIENT_TAG, tag);
+                               syncable::GET_BY_CLIENT_TAG, hash);
   return (entry_->good() && !entry_->Get(syncable::IS_DEL));
 }
 
 const syncable::Entry* ReadNode::GetEntry() const {
   return entry_;
 }
 
 const BaseTransaction* ReadNode::GetTransaction() const {
   return transaction_;
 }
@@ skipping 1038 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api