Initial implementation of "Synced Bookmarks" folder.

chrome/browser/sync/glue/bookmark_model_associator.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/sync/glue/bookmark_model_associator.h"
 
 #include <stack>
 
+#include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/syncable/autofill_migration.h"
 #include "chrome/browser/sync/syncable/nigori_util.h"
 #include "chrome/browser/sync/util/cryptographer.h"
+#include "chrome/common/chrome_switches.h"
 #include "content/browser/browser_thread.h"
 
 namespace browser_sync {
 
 // The sync protocol identifies top-level entities by means of well-known tags,
 // which should not be confused with titles.  Each tag corresponds to a
 // singleton instance of a particular top-level node in a user's share; the
 // tags are consistent across users. The tags allow us to locate the specific
 // folders whose contents we care about synchronizing, without having to do a
 // lookup by name or path.  The tags should not be made user-visible.
 // For example, the tag "bookmark_bar" represents the permanent node for
 // bookmarks bar in Chrome. The tag "other_bookmarks" represents the permanent
 // folder Other Bookmarks in Chrome.
 //
 // It is the responsibility of something upstream (at time of writing,
 // the sync server) to create these tagged nodes when initializing sync
 // for the first time for a user.  Thus, once the backend finishes
 // initializing, the ProfileSyncService can rely on the presence of tagged
 // nodes.
 //
 // TODO(ncarter): Pull these tags from an external protocol specification
 // rather than hardcoding them here.
 static const char kBookmarkBarTag[] = "bookmark_bar";
+static const char kSyncedBookmarksTag[] = "synced_bookmarks";
 static const char kOtherBookmarksTag[] = "other_bookmarks";
 
 // Bookmark comparer for map of bookmark nodes.
 class BookmarkComparer {
  public:
   // Compares the two given nodes and returns whether node1 should appear
   // before node2 in strict weak ordering.
   bool operator()(const BookmarkNode* node1,
                   const BookmarkNode* node2) const {
     DCHECK(node1);
@@ skipping 172 matching lines @@
   if (iter == id_map_inverse_.end())
     return;
   id_map_.erase(iter->second->id());
   id_map_inverse_.erase(iter);
   dirty_associations_sync_ids_.erase(sync_id);
 }
 
 bool BookmarkModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(has_nodes);
   *has_nodes = false;
+  bool has_synced_folder = true;
   int64 bookmark_bar_sync_id;
   if (!GetSyncIdForTaggedNode(kBookmarkBarTag, &bookmark_bar_sync_id)) {
     return false;
   }
   int64 other_bookmarks_sync_id;
   if (!GetSyncIdForTaggedNode(kOtherBookmarksTag, &other_bookmarks_sync_id)) {
     return false;
   }
+  int64 synced_bookmarks_sync_id;
+  if (!GetSyncIdForTaggedNode(kSyncedBookmarksTag, &synced_bookmarks_sync_id)) {
+    has_synced_folder = false;
+  }
 
   sync_api::ReadTransaction trans(user_share_);
 
   sync_api::ReadNode bookmark_bar_node(&trans);
   if (!bookmark_bar_node.InitByIdLookup(bookmark_bar_sync_id)) {
     return false;
   }
 
   sync_api::ReadNode other_bookmarks_node(&trans);
   if (!other_bookmarks_node.InitByIdLookup(other_bookmarks_sync_id)) {
     return false;
   }
 
+  sync_api::ReadNode synced_bookmarks_node(&trans);
+  if (has_synced_folder &&
+      !synced_bookmarks_node.InitByIdLookup(synced_bookmarks_sync_id)) {
+    return false;
+  }
+
   // Sync model has user created nodes if either one of the permanent nodes
   // has children.
   *has_nodes = bookmark_bar_node.GetFirstChildId() != sync_api::kInvalidId ||
-      other_bookmarks_node.GetFirstChildId() != sync_api::kInvalidId;
+      other_bookmarks_node.GetFirstChildId() != sync_api::kInvalidId ||
+      (has_synced_folder &&
+          synced_bookmarks_node.GetFirstChildId() != sync_api::kInvalidId);
   return true;
 }
 
 bool BookmarkModelAssociator::NodesMatch(const BookmarkNode* bookmark,
     const sync_api::BaseNode* sync_node) const {
   if (bookmark->GetTitle() != WideToUTF16Hack(sync_node->GetTitle()))
     return false;
   if (bookmark->is_folder() != sync_node->GetIsFolder())
     return false;
   if (bookmark->is_url()) {
@@ skipping 69 matching lines @@
     LOG(ERROR) << "Server did not create top-level nodes.  Possibly we "
                << "are running against an out-of-date server?";
     return false;
   }
   if (!AssociateTaggedPermanentNode(bookmark_model_->GetBookmarkBarNode(),
                                     kBookmarkBarTag)) {
     LOG(ERROR) << "Server did not create top-level nodes.  Possibly we "
                << "are running against an out-of-date server?";
     return false;
   }
+  // We only need to ensure that the "synced bookmarks" folder exists on the
+  // server if the command line flag is set.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableSyncedBookmarksFolder) &&
+      !AssociateTaggedPermanentNode(bookmark_model_->synced_node(),
+                                    kSyncedBookmarksTag)) {
+    LOG(ERROR) << "Server did not create top-level synced nodes.  Possibly "
+               << "we are running against an out-of-date server?";
+    return false;
+  }
   int64 bookmark_bar_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->GetBookmarkBarNode()->id());
   DCHECK(bookmark_bar_sync_id != sync_api::kInvalidId);
   int64 other_bookmarks_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->other_node()->id());
   DCHECK(other_bookmarks_sync_id != sync_api::kInvalidId);
+  int64 synced_bookmarks_sync_id = GetSyncIdFromChromeId(
+       bookmark_model_->synced_node()->id());
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableSyncedBookmarksFolder)) {
+    DCHECK(synced_bookmarks_sync_id != sync_api::kInvalidId);
+  }
 
   std::stack<int64> dfs_stack;
+  if (synced_bookmarks_sync_id != sync_api::kInvalidId)
+    dfs_stack.push(synced_bookmarks_sync_id);
   dfs_stack.push(other_bookmarks_sync_id);
   dfs_stack.push(bookmark_bar_sync_id);
 
   sync_api::WriteTransaction trans(user_share_);
 
   while (!dfs_stack.empty()) {
     int64 sync_parent_id = dfs_stack.top();
     dfs_stack.pop();
 
     sync_api::ReadNode sync_parent(&trans);
@@ skipping 112 matching lines @@
   int64 bookmark_bar_id;
   if (!GetSyncIdForTaggedNode(kBookmarkBarTag, &bookmark_bar_id)) {
     // We should always be able to find the permanent nodes.
     return false;
   }
   int64 other_bookmarks_id;
   if (!GetSyncIdForTaggedNode(kOtherBookmarksTag, &other_bookmarks_id)) {
     // We should always be able to find the permanent nodes.
     return false;
   }
+  int64 synced_bookmarks_id = -1;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableSyncedBookmarksFolder) &&
+      !GetSyncIdForTaggedNode(kSyncedBookmarksTag, &synced_bookmarks_id)) {
+    // We should always be able to find the permanent nodes.
+    return false;
+  }
 
   // Build a bookmark node ID index since we are going to repeatedly search for
   // bookmark nodes by their IDs.
   BookmarkNodeIdIndex id_index;
   id_index.AddAll(bookmark_model_->GetBookmarkBarNode());
   id_index.AddAll(bookmark_model_->other_node());
+  id_index.AddAll(bookmark_model_->synced_node());
 
   std::stack<int64> dfs_stack;
+  if (synced_bookmarks_id != -1)
+    dfs_stack.push(synced_bookmarks_id);
   dfs_stack.push(other_bookmarks_id);
   dfs_stack.push(bookmark_bar_id);
 
   sync_api::ReadTransaction trans(user_share_);
 
   // Count total number of nodes in sync model so that we can compare that
   // with the total number of nodes in the bookmark model.
   size_t sync_node_count = 0;
   while (!dfs_stack.empty()) {
     int64 parent_id = dfs_stack.top();
     dfs_stack.pop();
     ++sync_node_count;
     sync_api::ReadNode sync_parent(&trans);
     if (!sync_parent.InitByIdLookup(parent_id)) {
       return false;
     }
 
     int64 external_id = sync_parent.GetExternalId();
     if (external_id == 0)
       return false;
 
     const BookmarkNode* node = id_index.Find(external_id);
     if (!node)
       return false;
 
     // Don't try to call NodesMatch on permanent nodes like bookmark bar and
     // other bookmarks. They are not expected to match.
     if (node != bookmark_model_->GetBookmarkBarNode() &&
+        node != bookmark_model_->synced_node() &&
         node != bookmark_model_->other_node() &&
         !NodesMatch(node, &sync_parent))
       return false;
 
     Associate(node, sync_parent.GetId());
 
     // Add all children of the current node to the stack.
     int64 child_id = sync_parent.GetFirstChildId();
     while (child_id != sync_api::kInvalidId) {
       dfs_stack.push(child_id);
@@ skipping 17 matching lines @@
 bool BookmarkModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(user_share_);
   const syncable::ModelTypeSet& encrypted_types =
       GetEncryptedDataTypes(trans.GetWrappedTrans());
   return encrypted_types.count(syncable::BOOKMARKS) == 0 ||
       trans.GetCryptographer()->is_ready();
 }
 
 }  // namespace browser_sync