WIP: The Bookmark Position Megapatch

sync/internal_api/write_node.cc

 // Copyright (c) 2012 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 "sync/internal_api/public/write_node.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/nigori_util.h"
+#include "sync/syncable/syncable_util.h"
 #include "sync/util/cryptographer.h"
 
 using std::string;
 using std::vector;
 
 namespace syncer {
 
 using syncable::kEncryptedString;
 using syncable::SPECIFICS;
 
@@ skipping 165 matching lines @@
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetEntitySpecifics(
     const sync_pb::EntitySpecifics& new_value) {
   ModelType new_specifics_type =
       GetModelTypeFromSpecifics(new_value);
   DCHECK_NE(new_specifics_type, UNSPECIFIED);
   DVLOG(1) << "Writing entity specifics of type "
            << ModelTypeToString(new_specifics_type);
-  // GetModelType() can be unspecified if this is the first time this
-  // node is being initialized (see PutModelType()).  Otherwise, it
-  // should match |new_specifics_type|.
-  if (GetModelType() != UNSPECIFIED) {
-    DCHECK_EQ(new_specifics_type, GetModelType());
-  }
+  DCHECK_EQ(new_specifics_type, GetModelType());
 
   // Preserve unknown fields.
   const sync_pb::EntitySpecifics& old_specifics = entry_->Get(SPECIFICS);
   sync_pb::EntitySpecifics new_specifics;
   new_specifics.CopyFrom(new_value);
   new_specifics.mutable_unknown_fields()->MergeFrom(
       old_specifics.unknown_fields());
 
   // Will update the entry if encryption was necessary.
   if (!UpdateEntryWithEncryption(GetTransaction()->GetWrappedTrans(),
@@ skipping 62 matching lines @@
 // 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.
 BaseNode::InitByLookupResult WriteNode::InitByClientTagLookup(
     ModelType model_type,
     const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
   if (tag.empty())
     return INIT_FAILED_PRECONDITION;
 
-  const std::string hash = GenerateSyncableHash(model_type, tag);
+  const std::string hash = syncable::GenerateSyncableHash(model_type, tag);
 
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                       syncable::GET_BY_CLIENT_TAG, hash);
   if (!entry_->good())
     return INIT_FAILED_ENTRY_NOT_GOOD;
   if (entry_->Get(syncable::IS_DEL))
     return INIT_FAILED_ENTRY_IS_DEL;
   return DecryptIfNecessary() ? INIT_OK : INIT_FAILED_DECRYPT_IF_NECESSARY;
 }
 
 BaseNode::InitByLookupResult WriteNode::InitByTagLookup(
     const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
   if (tag.empty())
     return INIT_FAILED_PRECONDITION;
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                       syncable::GET_BY_SERVER_TAG, tag);
   if (!entry_->good())
     return INIT_FAILED_ENTRY_NOT_GOOD;
   if (entry_->Get(syncable::IS_DEL))
     return INIT_FAILED_ENTRY_IS_DEL;
   ModelType model_type = GetModelType();
   DCHECK_EQ(model_type, NIGORI);
   return INIT_OK;
 }
 
-void WriteNode::PutModelType(ModelType model_type) {
-  // Set an empty specifics of the appropriate datatype.  The presence
-  // of the specific field will identify the model type.
-  DCHECK(GetModelType() == model_type ||
-         GetModelType() == UNSPECIFIED);  // Immutable once set.
-
-  sync_pb::EntitySpecifics specifics;
-  AddDefaultFieldValue(model_type, &specifics);
-  SetEntitySpecifics(specifics);
-}
-
 // Create a new node with default properties, and bind this WriteNode to it.
 // Return true on success.
-bool WriteNode::InitByCreation(ModelType model_type,
-                               const BaseNode& parent,
-                               const BaseNode* predecessor) {
+bool WriteNode::InitBookmarkByCreation(const BaseNode& parent,
+                                       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.  We expect
   // the caller to set a meaningful name after creation.
   string dummy(kDefaultNameForNewNodes);
 
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
-                                      syncable::CREATE, parent_id, dummy);
+                                      syncable::CREATE_BOOKMARK, parent_id,
+                                      dummy);
 
   if (!entry_->good())
     return false;
 
   // Entries are untitled folders by default.
   entry_->Put(syncable::IS_DIR, true);
 
-  PutModelType(model_type);
-
   // Now set the predecessor, which sets IS_UNSYNCED as necessary.
   return PutPredecessor(predecessor);
 }
 
 // Create a new node with default properties and a client defined unique tag,
 // 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?
 WriteNode::InitUniqueByCreationResult WriteNode::InitUniqueByCreation(
     ModelType model_type,
     const BaseNode& parent,
     const std::string& tag) {
   // This DCHECK will only fail if init is called twice.
   DCHECK(!entry_);
   if (tag.empty()) {
     LOG(WARNING) << "InitUniqueByCreation failed due to empty tag.";
     return INIT_FAILED_EMPTY_TAG;
   }
 
-  const std::string hash = GenerateSyncableHash(model_type, tag);
+  const std::string hash = syncable::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(),
@@ skipping 25 matching lines @@
       // tags and updates.
 
       existing_entry->Put(syncable::NON_UNIQUE_NAME, dummy);
       existing_entry->Put(syncable::PARENT_ID, parent_id);
       entry_ = existing_entry.release();
     } else {
       return INIT_FAILED_ENTRY_ALREADY_EXISTS;
     }
   } else {
     entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
-                                        syncable::CREATE, parent_id, dummy);
+                                        syncable::CREATE_UNIQUE,
+                                        model_type, parent_id, dummy);
     if (!entry_->good())
       return INIT_FAILED_COULD_NOT_CREATE_ENTRY;
 
     // Only set IS_DIR for new entries. Don't bitflip undeleted ones.
     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.
   bool success = PutPredecessor(NULL);
   if (!success)
     return INIT_FAILED_SET_PREDECESSOR;
 
   return INIT_SUCCESS;
 }
 
 bool WriteNode::SetPosition(const BaseNode& new_parent,
                             const BaseNode* predecessor) {
   // |predecessor| must be a child of |new_parent| or NULL.
   if (predecessor && predecessor->GetParentId() != new_parent.GetId()) {
     DCHECK(false);
     return false;
   }
 
   syncable::Id new_parent_id = new_parent.GetEntry()->Get(syncable::ID);
 
   // 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);
+    const syncable::Id& old = entry_->GetPredecessorId();
     if ((!predecessor && old.IsRoot()) ||
         (predecessor && (old == predecessor->GetEntry()->Get(syncable::ID)))) {
       return true;
     }
   }
 
   // Atomically change the parent. This will fail if it would
   // introduce a cycle in the hierarchy.
   if (!entry_->Put(syncable::PARENT_ID, new_parent_id))
     return false;
 
   // Now set the predecessor, which sets IS_UNSYNCED as necessary.
   return PutPredecessor(predecessor);
+  return true;
 }
 
 const syncable::Entry* WriteNode::GetEntry() const {
   return entry_;
 }
 
 const BaseTransaction* WriteNode::GetTransaction() const {
   return transaction_;
 }
 
@@ skipping 18 matching lines @@
   MarkForSyncing();
 
   return true;
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 }  // namespace syncer