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"
@@ skipping 49 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 202 matching lines @@
   StarredNode* bookmark_node =
       GetNodeByType(*roots, StarredEntry::BOOKMARK_BAR);
   if (!bookmark_node) {
     LOG(WARNING) << "No bookmark bar folder in database";
     // If there is no bookmark bar entry in the db things are really
     // screwed. Return false, which won't trigger migration and we'll just
     // drop the tables.
     return false;
   }
 
+  // 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;
+    // TODO (yfriedman): Is this index right?
+    if (entry.folder_id == 1) {
+      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);
+  }
+
   // Make sure the other node exists.
   StarredNode* other_node = GetNodeByType(*roots, StarredEntry::OTHER);
   if (!other_node) {
     LOG(WARNING) << "No bookmark other folder in database";
     StarredEntry entry;
     entry.folder_id = GetMaxFolderID() + 1;
     if (entry.folder_id == 1) {
       NOTREACHED() << "Unable to get new id for other bookmarks folder";
       return false;
     }
@@ skipping 90 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