WIP: The Bookmark Position Megapatch

sync/internal_api/base_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/base_node.h"
 
 #include <stack>
 
-#include "base/base64.h"
-#include "base/sha1.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base_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/nigori_specifics.pb.h"
@@ skipping 37 matching lines @@
       EndsWithSpace(server_name)) {
     --length_to_copy;
   }
   *out = std::string(server_name.c_str(), length_to_copy);
 }
 
 BaseNode::BaseNode() : password_data_(new sync_pb::PasswordSpecificsData) {}
 
 BaseNode::~BaseNode() {}
 
-std::string BaseNode::GenerateSyncableHash(
-    ModelType model_type, const std::string& client_tag) {
-  // Blank PB with just the field in it has termination symbol,
-  // handy for delimiter.
-  sync_pb::EntitySpecifics serialized_type;
-  AddDefaultFieldValue(model_type, &serialized_type);
-  std::string hash_input;
-  serialized_type.AppendToString(&hash_input);
-  hash_input.append(client_tag);
-
-  std::string encode_output;
-  CHECK(base::Base64Encode(base::SHA1HashString(hash_input), &encode_output));
-  return encode_output;
-}
-
 bool BaseNode::DecryptIfNecessary() {
   if (!GetEntry()->Get(syncable::UNIQUE_SERVER_TAG).empty())
       return true;  // Ignore unique folders.
   const sync_pb::EntitySpecifics& specifics =
       GetEntry()->Get(syncable::SPECIFICS);
   if (specifics.has_password()) {
     // Passwords have their own legacy encryption structure.
     scoped_ptr<sync_pb::PasswordSpecificsData> data(DecryptPasswordSpecifics(
         specifics, GetTransaction()->GetCryptographer()));
     if (!data.get()) {
@@ skipping 112 matching lines @@
   return result;
 }
 
 bool BaseNode::HasChildren() const {
   syncable::Directory* dir = GetTransaction()->GetDirectory();
   syncable::BaseTransaction* trans = GetTransaction()->GetWrappedTrans();
   return dir->HasChildren(trans, GetEntry()->Get(syncable::ID));
 }
 
 int64 BaseNode::GetPredecessorId() const {
-  syncable::Id id_string = GetEntry()->Get(syncable::PREV_ID);
+  syncable::Id id_string = GetEntry()->GetPredecessorId();
   if (id_string.IsRoot())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
 int64 BaseNode::GetSuccessorId() const {
-  syncable::Id id_string = GetEntry()->Get(syncable::NEXT_ID);
+  syncable::Id id_string = GetEntry()->GetSuccessorId();
   if (id_string.IsRoot())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
 int64 BaseNode::GetFirstChildId() const {
-  syncable::Directory* dir = GetTransaction()->GetDirectory();
-  syncable::BaseTransaction* trans = GetTransaction()->GetWrappedTrans();
-  syncable::Id id_string;
-  // TODO(akalin): Propagate up the error further (see
-  // http://crbug.com/100907).
-  CHECK(dir->GetFirstChildId(trans,
-                             GetEntry()->Get(syncable::ID), &id_string));
+  syncable::Id id_string = GetEntry()->GetFirstChildId();
   if (id_string.IsRoot())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
 int BaseNode::GetTotalNodeCount() const {
-  syncable::Directory* dir = GetTransaction()->GetDirectory();
   syncable::BaseTransaction* trans = GetTransaction()->GetWrappedTrans();
 
   int count = 1;  // Start with one to include the node itself.
 
   std::stack<int64> stack;
   stack.push(GetFirstChildId());
   while (!stack.empty()) {
     int64 handle = stack.top();
     stack.pop();
     if (handle == kInvalidId)
       continue;
     count++;
     syncable::Entry entry(trans, syncable::GET_BY_HANDLE, handle);
     if (!entry.good())
       continue;
     syncable::Id id = entry.Get(syncable::ID);
-    syncable::Id child_id;
-    if (dir->GetFirstChildId(trans, id, &child_id) && !child_id.IsRoot())
-      stack.push(IdToMetahandle(trans, child_id));
-    syncable::Id successor_id = entry.Get(syncable::NEXT_ID);
+    syncable::Id successor_id = entry.GetSuccessorId();
     if (!successor_id.IsRoot())
       stack.push(IdToMetahandle(trans, successor_id));
+    if (!entry.Get(syncable::IS_DIR))
+      continue;
+    syncable::Id child_id = entry.GetFirstChildId();
+    if (!child_id.IsRoot())
+      stack.push(IdToMetahandle(trans, child_id));
   }
   return count;
 }
 
 DictionaryValue* BaseNode::GetSummaryAsValue() const {
   DictionaryValue* node_info = new DictionaryValue();
   node_info->SetString("id", base::Int64ToString(GetId()));
   node_info->SetBoolean("isFolder", GetIsFolder());
   node_info->SetString("title", GetTitle());
   node_info->Set("type", ModelTypeToValue(GetModelType()));
   return node_info;
 }
 
 DictionaryValue* BaseNode::GetDetailsAsValue() const {
   DictionaryValue* node_info = GetSummaryAsValue();
   node_info->SetString(
       "modificationTime",
       GetTimeDebugString(GetModificationTime()));
   node_info->SetString("parentId", base::Int64ToString(GetParentId()));
   // Specifics are already in the Entry value, so no need to duplicate
   // it here.
   node_info->SetString("externalId",
                        base::Int64ToString(GetExternalId()));
-  node_info->SetString("predecessorId",
-                       base::Int64ToString(GetPredecessorId()));
-  node_info->SetString("successorId",
-                       base::Int64ToString(GetSuccessorId()));
-  node_info->SetString("firstChildId",
-                       base::Int64ToString(GetFirstChildId()));
   node_info->Set("entry",
                  GetEntry()->ToValue(GetTransaction()->GetCryptographer()));
   return node_info;
 }
 
 int64 BaseNode::GetExternalId() const {
   return GetEntry()->Get(syncable::LOCAL_EXTERNAL_ID);
 }
 
 const sync_pb::AppSpecifics& BaseNode::GetAppSpecifics() const {
@@ skipping 68 matching lines @@
     const sync_pb::EntitySpecifics& specifics) {
   ModelType type = GetModelTypeFromSpecifics(specifics);
   DCHECK_NE(UNSPECIFIED, type);
   if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(GetModelType(), type);
   }
   unencrypted_data_.CopyFrom(specifics);
 }
 
 }  // namespace syncer