Changes the visibility of the 'mobile' node based on whether

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 168 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_);
   DCHECK(user_share_);
   DCHECK(unrecoverable_error_handler_);
 }
 
 BookmarkModelAssociator::~BookmarkModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
+void BookmarkModelAssociator::UpdateMobileNodeVisibility() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(bookmark_model_->IsLoaded());
+
+  bookmark_model_->SetMobileFolderVisible(
+      id_map_.find(bookmark_model_->mobile_node()->id()) != id_map_.end());
+}
+
 bool BookmarkModelAssociator::DisassociateModels(SyncError* error) {
   id_map_.clear();
   id_map_inverse_.clear();
   dirty_associations_sync_ids_.clear();
   return true;
 }
 
 int64 BookmarkModelAssociator::GetSyncIdFromChromeId(const int64& node_id) {
   BookmarkIdToSyncIdMap::const_iterator iter = id_map_.find(node_id);
   return iter == id_map_.end() ? sync_api::kInvalidId : iter->second;
@@ skipping 22 matching lines @@
                                         int64 sync_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int64 node_id = node->id();
   DCHECK_NE(sync_id, sync_api::kInvalidId);
   DCHECK(id_map_.find(node_id) == id_map_.end());
   DCHECK(id_map_inverse_.find(sync_id) == id_map_inverse_.end());
   id_map_[node_id] = sync_id;
   id_map_inverse_[sync_id] = node;
   dirty_associations_sync_ids_.insert(sync_id);
   PostPersistAssociationsTask();
+  UpdateMobileNodeVisibility();
 }
 
 void BookmarkModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SyncIdToBookmarkNodeMap::iterator iter = id_map_inverse_.find(sync_id);
   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);
@@ skipping 120 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;
   }
-  // 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));
+  if (!AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
+                                    kMobileBookmarksTag) &&
+      // The mobile folder only need exist if kCreateMobileBookmarksFolder is
+      // set.
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kCreateMobileBookmarksFolder)) {
+    error->Reset(FROM_HERE, kServerError, model_type());
+    return false;
+  }
   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());
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kCreateMobileBookmarksFolder)) {
+    DCHECK_NE(sync_api::kInvalidId, mobile_bookmarks_sync_id);
+  }
 
   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;
-  // Can't fail here as the mobile folder may not exist.
-  ignore_result(
-      GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_id));
+  if (!GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_id) &&
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kCreateMobileBookmarksFolder)) {
+    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_->bookmark_bar_node());
   id_index.AddAll(bookmark_model_->other_node());
   id_index.AddAll(bookmark_model_->mobile_node());
 
   std::stack<int64> dfs_stack;
   if (mobile_bookmarks_id != -1)
@@ skipping 57 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