Revert "Revert 84829 - Initial implementation of "Synced Bookmarks" folder."

chrome/browser/history/starred_url_database.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/history/starred_url_database.h"
 
 #include "app/sql/statement.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/history/history.h"
 
 // The following table is used to store star (aka bookmark) information. This
 // class derives from URLDatabase, which has its own schema.
 //
 // starred
 //   id                 Unique identifier (primary key) for the entry.
 //   type               Type of entry, if 0 this corresponds to a URL, 1 for
 //                      a system folder, 2 for a user created folder, 3 for
-//                      other.
+//                      other. Note that 4 (synced) will never appear in the
+//                      database because it was added after this storage was
+//                      deprecated.
 //   url_id             ID of the url, only valid if type == 0
 //   group_id           ID of the folder, only valid if type != 0. This id comes
 //                      from the UI and is NOT the same as id.
 //   title              User assigned title.
 //   date_added         Creation date.
 //   visual_order       Visual order within parent.
 //   parent_id          Folder ID of the parent this entry is contained in, if 0
 //                      entry is not in a folder.
 //   date_modified      Time the folder was last modified. See comments in
 //                      StarredEntry::date_folder_modified
@@ skipping 500 matching lines @@
     return false;
 
   // Create the bookmark bar and other folder nodes.
   history::StarredEntry entry;
   entry.type = history::StarredEntry::BOOKMARK_BAR;
   BookmarkNode bookmark_bar_node(0, GURL());
   bookmark_bar_node.Reset(entry);
   entry.type = history::StarredEntry::OTHER;
   BookmarkNode other_node(0, GURL());
   other_node.Reset(entry);
+  // NOTE(yfriedman): We don't do anything with the synced star node because it
+  // won't ever exist in the starred node DB. We only need to create it to pass
+  // to "encode".
+  entry.type = history::StarredEntry::SYNCED;
+  BookmarkNode synced_node(0, GURL());
+  synced_node.Reset(entry);
 
   std::map<history::UIStarID, history::StarID> folder_id_to_id_map;
   typedef std::map<history::StarID, BookmarkNode*> IDToNodeMap;
   IDToNodeMap id_to_node_map;
 
   history::UIStarID other_folder_folder_id = 0;
   history::StarID other_folder_id = 0;
 
   // Iterate through the entries building a mapping between folder_id and id.
   for (std::vector<history::StarredEntry>::const_iterator i = entries.begin();
@@ skipping 14 matching lines @@
   if (other_folder_folder_id) {
     id_to_node_map[other_folder_id] = &other_node;
     folder_id_to_id_map[other_folder_folder_id] = other_folder_id;
   }
 
   // Iterate through the entries again creating the nodes.
   for (std::vector<history::StarredEntry>::iterator i = entries.begin();
        i != entries.end(); ++i) {
     if (!i->parent_folder_id) {
       DCHECK(i->type == history::StarredEntry::BOOKMARK_BAR ||
+             i->type == history::StarredEntry::SYNCED ||
              i->type == history::StarredEntry::OTHER);
       // Only entries with no parent should be the bookmark bar and other
       // bookmarks folders.
       continue;
     }
 
     BookmarkNode* node = id_to_node_map[i->id];
     if (!node) {
       // Creating a node results in creating the parent. As such, it is
       // possible for the node representing a folder to have been created before
@@ skipping 17 matching lines @@
 
     // Add the node to its parent. |entries| is ordered by parent then
     // visual order so that we know we maintain visual order by always adding
     // to the end.
     parent->Add(node, parent->child_count());
   }
 
   // Save to file.
   BookmarkCodec encoder;
   scoped_ptr<Value> encoded_bookmarks(
-      encoder.Encode(&bookmark_bar_node, &other_node));
+      encoder.Encode(&bookmark_bar_node, &other_node, &synced_node));
   std::string content;
   base::JSONWriter::Write(encoded_bookmarks.get(), true, &content);
 
   return (file_util::WriteFile(path, content.c_str(),
                                static_cast<int>(content.length())) != -1);
 }
 
 }  // namespace history