Initial implementation of "Synced Bookmarks" folder.

chrome/browser/bookmarks/bookmark_codec.cc

 // Copyright (c) 2011 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/bookmarks/bookmark_codec.h"
 
 #include <algorithm>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::Time;
 
 const char* BookmarkCodec::kRootsKey = "roots";
 const char* BookmarkCodec::kRootFolderNameKey = "bookmark_bar";
 const char* BookmarkCodec::kOtherBookmarkFolderNameKey = "other";
+const char* BookmarkCodec::kSyncedBookmarkFolderNameKey = "synced";
 const char* BookmarkCodec::kVersionKey = "version";
 const char* BookmarkCodec::kChecksumKey = "checksum";
 const char* BookmarkCodec::kIdKey = "id";
 const char* BookmarkCodec::kTypeKey = "type";
 const char* BookmarkCodec::kNameKey = "name";
 const char* BookmarkCodec::kDateAddedKey = "date_added";
 const char* BookmarkCodec::kURLKey = "url";
 const char* BookmarkCodec::kDateModifiedKey = "date_modified";
 const char* BookmarkCodec::kChildrenKey = "children";
 const char* BookmarkCodec::kTypeURL = "url";
 const char* BookmarkCodec::kTypeFolder = "folder";
 
 // Current version of the file.
 static const int kCurrentVersion = 1;
 
 BookmarkCodec::BookmarkCodec()
     : ids_reassigned_(false),
       ids_valid_(true),
       maximum_id_(0) {
 }
 
 BookmarkCodec::~BookmarkCodec() {}
 
 Value* BookmarkCodec::Encode(BookmarkModel* model) {
-  return Encode(model->GetBookmarkBarNode(), model->other_node());
+  return Encode(model->GetBookmarkBarNode(), model->other_node(),
+                model->synced_node());
 }
 
 Value* BookmarkCodec::Encode(const BookmarkNode* bookmark_bar_node,
-                             const BookmarkNode* other_folder_node) {
+                             const BookmarkNode* other_folder_node,
+                             const BookmarkNode* synced_folder_node) {
   ids_reassigned_ = false;
   InitializeChecksum();
   DictionaryValue* roots = new DictionaryValue();
   roots->Set(kRootFolderNameKey, EncodeNode(bookmark_bar_node));
   roots->Set(kOtherBookmarkFolderNameKey, EncodeNode(other_folder_node));
+  roots->Set(kSyncedBookmarkFolderNameKey, EncodeNode(synced_folder_node));
 
   DictionaryValue* main = new DictionaryValue();
   main->SetInteger(kVersionKey, kCurrentVersion);
   FinalizeChecksum();
   // We are going to store the computed checksum. So set stored checksum to be
   // the same as computed checksum.
   stored_checksum_ = computed_checksum_;
   main->Set(kChecksumKey, Value::CreateStringValue(computed_checksum_));
   main->Set(kRootsKey, roots);
   return main;
 }
 
 bool BookmarkCodec::Decode(BookmarkNode* bb_node,
                            BookmarkNode* other_folder_node,
+                           BookmarkNode* synced_folder_node,
                            int64* max_id,
                            const Value& value) {
   ids_.clear();
   ids_reassigned_ = false;
   ids_valid_ = true;
   maximum_id_ = 0;
   stored_checksum_.clear();
   InitializeChecksum();
-  bool success = DecodeHelper(bb_node, other_folder_node, value);
+  bool success = DecodeHelper(bb_node, other_folder_node, synced_folder_node,
+                              value);
   FinalizeChecksum();
   // If either the checksums differ or some IDs were missing/not unique,
   // reassign IDs.
   if (!ids_valid_ || computed_checksum() != stored_checksum())
-    ReassignIDs(bb_node, other_folder_node);
+    ReassignIDs(bb_node, other_folder_node, synced_folder_node);
   *max_id = maximum_id_ + 1;
   return success;
 }
 
 Value* BookmarkCodec::EncodeNode(const BookmarkNode* node) {
   DictionaryValue* value = new DictionaryValue();
   std::string id = base::Int64ToString(node->id());
   value->SetString(kIdKey, id);
   const string16& title = node->GetTitle();
   value->SetString(kNameKey, title);
@@ skipping 14 matching lines @@
     ListValue* child_values = new ListValue();
     value->Set(kChildrenKey, child_values);
     for (int i = 0; i < node->child_count(); ++i)
       child_values->Append(EncodeNode(node->GetChild(i)));
   }
   return value;
 }
 
 bool BookmarkCodec::DecodeHelper(BookmarkNode* bb_node,
                                  BookmarkNode* other_folder_node,
+                                 BookmarkNode* synced_folder_node,
                                  const Value& value) {
   if (value.GetType() != Value::TYPE_DICTIONARY)
     return false;  // Unexpected type.
 
   const DictionaryValue& d_value = static_cast<const DictionaryValue&>(value);
 
   int version;
   if (!d_value.GetInteger(kVersionKey, &version) || version != kCurrentVersion)
     return false;  // Unknown version.
 
   Value* checksum_value;
   if (d_value.Get(kChecksumKey, &checksum_value)) {
     if (checksum_value->GetType() != Value::TYPE_STRING)
       return false;
     StringValue* checksum_value_str = static_cast<StringValue*>(checksum_value);
     if (!checksum_value_str->GetAsString(&stored_checksum_))
       return false;
   }
 
   Value* roots;
   if (!d_value.Get(kRootsKey, &roots))
     return false;  // No roots.
 
   if (roots->GetType() != Value::TYPE_DICTIONARY)
     return false;  // Invalid type for roots.
 
   DictionaryValue* roots_d_value = static_cast<DictionaryValue*>(roots);
   Value* root_folder_value;
   Value* other_folder_value;
+  Value* synced_folder_value;
   if (!roots_d_value->Get(kRootFolderNameKey, &root_folder_value) ||
       root_folder_value->GetType() != Value::TYPE_DICTIONARY ||
       !roots_d_value->Get(kOtherBookmarkFolderNameKey, &other_folder_value) ||
-      other_folder_value->GetType() != Value::TYPE_DICTIONARY)
-    return false;  // Invalid type for root folder and/or other folder.
+      other_folder_value->GetType() != Value::TYPE_DICTIONARY ||
+      !roots_d_value->Get(kSyncedBookmarkFolderNameKey, &synced_folder_value) ||
+      synced_folder_value->GetType() != Value::TYPE_DICTIONARY) {
+    return false;  // Invalid type for root folder and/or synced and/or other
+                   // folder.
+  }
 
   DecodeNode(*static_cast<DictionaryValue*>(root_folder_value), NULL,
              bb_node);
   DecodeNode(*static_cast<DictionaryValue*>(other_folder_value), NULL,
              other_folder_node);
+  DecodeNode(*static_cast<DictionaryValue*>(synced_folder_value), NULL,
+             synced_folder_node);
   // Need to reset the type as decoding resets the type to FOLDER. Similarly
   // we need to reset the title as the title is persisted and restored from
   // the file.
   bb_node->set_type(BookmarkNode::BOOKMARK_BAR);
   other_folder_node->set_type(BookmarkNode::OTHER_NODE);
+  synced_folder_node->set_type(BookmarkNode::SYNCED);
   bb_node->set_title(l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_FOLDER_NAME));
   other_folder_node->set_title(
       l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_OTHER_FOLDER_NAME));
+  synced_folder_node->set_title(
+        l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_SYNCED_FOLDER_NAME));
 
   return true;
 }
 
 bool BookmarkCodec::DecodeChildren(const ListValue& child_value_list,
                                    BookmarkNode* parent) {
   for (size_t i = 0; i < child_value_list.GetSize(); ++i) {
     Value* child_value;
     if (!child_value_list.Get(i, &child_value))
       return false;
@@ skipping 107 matching lines @@
     if (!DecodeChildren(*static_cast<ListValue*>(child_values), node))
       return false;
   }
 
   node->set_title(title);
   node->set_date_added(date_added);
   return true;
 }
 
 void BookmarkCodec::ReassignIDs(BookmarkNode* bb_node,
-                                BookmarkNode* other_node) {
+                                BookmarkNode* other_node,
+                                BookmarkNode* synced_node) {
   maximum_id_ = 0;
   ReassignIDsHelper(bb_node);
   ReassignIDsHelper(other_node);
+  ReassignIDsHelper(synced_node);
   ids_reassigned_ = true;
 }
 
 void BookmarkCodec::ReassignIDsHelper(BookmarkNode* node) {
   DCHECK(node);
   node->set_id(++maximum_id_);
   for (int i = 0; i < node->child_count(); ++i)
     ReassignIDsHelper(node->GetChild(i));
 }
 
@@ skipping 24 matching lines @@
 
 void BookmarkCodec::InitializeChecksum() {
   MD5Init(&md5_context_);
 }
 
 void BookmarkCodec::FinalizeChecksum() {
   MD5Digest digest;
   MD5Final(&digest, &md5_context_);
   computed_checksum_ = MD5DigestToBase16(digest);
 }