Changes BookmarkModelAssociator not to fail if mobile folder doesn't

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"
@@ skipping 350 matching lines @@
   if (!AssociateTaggedPermanentNode(bookmark_model_->other_node(),
                                     kOtherBookmarksTag)) {
     error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
   if (!AssociateTaggedPermanentNode(bookmark_model_->bookmark_bar_node(),
                                     kBookmarkBarTag)) {
     error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
-  if (!AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
-                                    kMobileBookmarksTag)) {
-    error->Reset(FROM_HERE, kServerError, model_type());
-    return false;
-  }
+  // The mobile folder isn't always present on the backend, so we don't fail if
+  // it doesn't exist.
+  ignore_result(AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
+                                             kMobileBookmarksTag));
   int64 bookmark_bar_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->bookmark_bar_node()->id());
   DCHECK_NE(bookmark_bar_sync_id, sync_api::kInvalidId);
   int64 other_bookmarks_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->other_node()->id());
   DCHECK_NE(other_bookmarks_sync_id, sync_api::kInvalidId);
   int64 mobile_bookmarks_sync_id = GetSyncIdFromChromeId(
        bookmark_model_->mobile_node()->id());
-  DCHECK_NE(mobile_bookmarks_sync_id, sync_api::kInvalidId);
 
   std::stack<int64> dfs_stack;
   if (mobile_bookmarks_sync_id != sync_api::kInvalidId)
     dfs_stack.push(mobile_bookmarks_sync_id);
   dfs_stack.push(other_bookmarks_sync_id);
   dfs_stack.push(bookmark_bar_sync_id);
 
   sync_api::WriteTransaction trans(FROM_HERE, user_share_);
 
   while (!dfs_stack.empty()) {
@@ skipping 123 matching lines @@
   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 mobile_bookmarks_id = -1;
-  if (!GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_id)) {
-    // We should always be able to find the permanent nodes.
-    return false;
-  }
+  // Can't fail here as the mobile folder may not exist.
+  ignore_result(
+      GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_id));
 
   // 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_->bookmark_bar_node());
   id_index.AddAll(bookmark_model_->other_node());
   id_index.AddAll(bookmark_model_->mobile_node());
 
   std::stack<int64> dfs_stack;
-  dfs_stack.push(mobile_bookmarks_id);
+  if (mobile_bookmarks_id != -1)
+    dfs_stack.push(mobile_bookmarks_id);
   dfs_stack.push(other_bookmarks_id);
   dfs_stack.push(bookmark_bar_id);
 
   sync_api::ReadTransaction trans(FROM_HERE, 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();
@@ skipping 46 matching lines @@
 bool BookmarkModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, user_share_);
   const syncable::ModelTypeSet& encrypted_types =
       sync_api::GetEncryptedTypes(&trans);
   return encrypted_types.count(syncable::BOOKMARKS) == 0 ||
       trans.GetCryptographer()->is_ready();
 }
 
 }  // namespace browser_sync