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, 4 for synced.

[sky, 2011/05/12 16:29:13]

At one point bookmarks were saved in the db (this file), and not in the json
file. Anyone that stills has their bookmarks in the db is NOT going to have the
synced folder. Hopefully the only you should have to change in this file is the
call to encoder.Encode.

[Yaron, 2011/05/12 18:19:23]

So we never actually write to this DB anymore, you're saying I should revert
everything except encode, including updating the enum? Well actually, I need to
update the enum for encode to make sense. Comment included below..

 //   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 21 matching lines @@
       break;
     case 1:
       entry->type = history::StarredEntry::BOOKMARK_BAR;
       break;
     case 2:
       entry->type = history::StarredEntry::USER_FOLDER;
       break;
     case 3:
       entry->type = history::StarredEntry::OTHER;
       break;
+    case 4:
+      entry->type = history::StarredEntry::SYNCED;
+      break;
     default:
       NOTREACHED();
       break;
   }
   entry->title = s.ColumnString16(2);
   entry->date_added = base::Time::FromInternalValue(s.ColumnInt64(3));
   entry->visual_order = s.ColumnInt(4);
   entry->parent_folder_id = s.ColumnInt64(5);
   entry->url_id = s.ColumnInt64(7);
   entry->folder_id = s.ColumnInt64(8);
@@ skipping 127 matching lines @@
       break;
     case history::StarredEntry::BOOKMARK_BAR:
       statement.BindInt(0, 1);
       break;
     case history::StarredEntry::USER_FOLDER:
       statement.BindInt(0, 2);
       break;
     case history::StarredEntry::OTHER:
       statement.BindInt(0, 3);
       break;
+    case history::StarredEntry::SYNCED:
+      statement.BindInt(0, 4);
+      break;
     default:
       NOTREACHED();
   }
   statement.BindInt64(1, url_id);
   statement.BindInt64(2, folder_id);
   statement.BindString16(3, title);
   statement.BindInt64(4, date_added.ToInternalValue());
   statement.BindInt(5, visual_order);
   statement.BindInt64(6, parent_folder_id);
   statement.BindInt64(7, base::Time().ToInternalValue());
@@ skipping 223 matching lines @@
         0, entry.folder_id, 0, UTF8ToUTF16("other"), base::Time::Now(), 0,
         history::StarredEntry::OTHER);
     if (!entry.id) {
       NOTREACHED() << "Unable to create other bookmarks folder";
       return false;
     }
     entry.type = StarredEntry::OTHER;
     StarredNode* other_node = new StarredNode(entry);
     roots->insert(other_node);
   }
 

[Yaron, 2011/05/12 18:19:23]

Looks like I should just revert this part?

+  // Make sure the synced node exists.
+  StarredNode* synced_node = GetNodeByType(*roots, StarredEntry::SYNCED);
+  if (!synced_node) {
+    LOG(WARNING) << "No bookmark synced folder in database";
+    StarredEntry entry;
+    entry.folder_id = GetMaxFolderID() + 1;
+    if (entry.folder_id == 2) {
+      NOTREACHED() << "Unable to get new id for synced bookmarks folder";
+      return false;
+    }
+    entry.id = CreateStarredEntryRow(
+        0, entry.folder_id, 0, UTF8ToUTF16("synced"), base::Time::Now(), 0,
+        history::StarredEntry::SYNCED);
+    if (!entry.id) {
+      NOTREACHED() << "Unable to create synced bookmarks folder";
+      return false;
+    }
+    entry.type = StarredEntry::SYNCED;
+    StarredNode* synced_node = new StarredNode(entry);
+    roots->insert(synced_node);
+  }
+
   // We could potentially make sure only one folder with type
   // BOOKMARK_BAR/OTHER, but history backend enforces this.
 
   // Nuke any entries with no url.
   for (std::set<StarID>::const_iterator i = empty_url_ids.begin();
        i != empty_url_ids.end(); ++i) {
     LOG(WARNING) << "Bookmark exists with no URL";
     if (!DeleteStarredEntryRow(*i)) {
       NOTREACHED() << "Unable to delete bookmark";
       return false;
@@ skipping 68 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);
+  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 synced_folder_folder_id = 0;
+  history::StarID synced_folder_id = 0;
+
   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();
        i != entries.end(); ++i) {
     if (i->type != history::StarredEntry::URL) {
       folder_id_to_id_map[i->folder_id] = i->id;
       if (i->type == history::StarredEntry::OTHER) {
         other_folder_id = i->id;
         other_folder_folder_id = i->folder_id;
       }
+      if (i->type == history::StarredEntry::SYNCED) {
+        synced_folder_id = i->id;
+        synced_folder_folder_id = i->folder_id;
+      }
     }
   }
 
   // Register the bookmark bar and other folder nodes in the maps.
   id_to_node_map[HistoryService::kBookmarkBarID] = &bookmark_bar_node;
   folder_id_to_id_map[HistoryService::kBookmarkBarID] =
       HistoryService::kBookmarkBarID;
   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;
   }
+  if (synced_folder_folder_id) {
+    id_to_node_map[synced_folder_id] = &synced_node;
+    folder_id_to_id_map[synced_folder_folder_id] = synced_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