Fixed ProfileSyncServiceBookmarkTest on iOS.

chrome/browser/sync/profile_sync_service_bookmark_unittest.cc

 // Copyright (c) 2012 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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <map>
 #include <queue>
@@ skipping 318 matching lines @@
   }
 
   virtual void SetUp() {
     test_user_share_.SetUp();
   }
 
   virtual void TearDown() {
     test_user_share_.TearDown();
   }
 
+  bool CanSyncNode(const BookmarkNode* node) {
+    return model_->client()->CanSyncNode(node);
+  }
+
   // Inserts a folder directly to the share.
   // Do not use this after model association is complete.
   //
   // This function differs from the AddFolder() function declared elsewhere in
   // this file in that it only affects the sync model.  It would be invalid to
   // change the sync model directly after ModelAssociation.  This function can
   // be invoked prior to model association to set up first-time sync model
   // association scenarios.
   int64 AddFolderToShare(syncer::WriteTransaction* trans, std::string title) {
     EXPECT_FALSE(model_associator_);
@@ skipping 250 matching lines @@
     if (browser_index == 0) {
       EXPECT_EQ(gnode.GetPredecessorId(), 0);
     } else {
       const BookmarkNode* bprev =
           bnode->parent()->GetChild(browser_index - 1);
       syncer::ReadNode gprev(trans);
       ASSERT_TRUE(InitSyncNodeFromChromeNode(bprev, &gprev));
       EXPECT_EQ(gnode.GetPredecessorId(), gprev.GetId());
       EXPECT_EQ(gnode.GetParentId(), gprev.GetParentId());
     }
-    // Note: the managed node comes next to the mobile node but isn't synced.
-    if (browser_index == bnode->parent()->child_count() - 1 ||
-        bnode == model_->mobile_node()) {
+    // Note: the managed node is the last child of the root_node but isn't
+    // synced; if CanSyncNode() is false then there is no next node to sync.
+    const BookmarkNode* bnext = NULL;
+    if (browser_index + 1 < bnode->parent()->child_count())
+        bnext = bnode->parent()->GetChild(browser_index + 1);
+    if (!bnext || !CanSyncNode(bnext)) {
       EXPECT_EQ(gnode.GetSuccessorId(), 0);
     } else {
-      const BookmarkNode* bnext =
-          bnode->parent()->GetChild(browser_index + 1);
       syncer::ReadNode gnext(trans);
       ASSERT_TRUE(InitSyncNodeFromChromeNode(bnext, &gnext));
       EXPECT_EQ(gnode.GetSuccessorId(), gnext.GetId());
       EXPECT_EQ(gnode.GetParentId(), gnext.GetParentId());
     }
     if (!bnode->empty())
       EXPECT_TRUE(gnode.GetFirstChildId());
   }
 
   void ExpectSyncerNodeMatching(const BookmarkNode* bnode) {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectSyncerNodeMatching(&trans, bnode);
   }
 
   void ExpectBrowserNodeMatching(syncer::BaseTransaction* trans,
                                  int64 sync_id) {
     EXPECT_TRUE(sync_id);
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
-
-    ChromeBookmarkClient* client =
-        ChromeBookmarkClientFactory::GetForProfile(&profile_);
-    ASSERT_TRUE(client);
-    ASSERT_FALSE(client->IsDescendantOfManagedNode(bnode));
+    ASSERT_TRUE(CanSyncNode(bnode));
 
     int64 id = model_associator_->GetSyncIdFromChromeId(bnode->id());
     EXPECT_EQ(id, sync_id);
     ExpectSyncerNodeMatching(trans, bnode);
   }
 
   void ExpectBrowserNodeUnknown(int64 sync_id) {
     EXPECT_FALSE(model_associator_->GetChromeNodeFromSyncId(sync_id));
   }
 
@@ skipping 1352 matching lines @@
   model_->DeleteNodeMetaInfo(folder_node, "folder");
   model_->SetNodeMetaInfo(node, "node", "changednodevalue");
   model_->DeleteNodeMetaInfo(node, "other");
   model_->SetNodeMetaInfo(node, "newkey", "newkeyvalue");
   ExpectModelMatch();
 }
 
 void ProfileSyncServiceBookmarkTestWithData::GetTransactionVersions(
     const BookmarkNode* root,
     BookmarkNodeVersionMap* node_versions) {
-  ChromeBookmarkClient* client =
-      ChromeBookmarkClientFactory::GetForProfile(&profile_);
-  ASSERT_TRUE(client);
-
   node_versions->clear();
   std::queue<const BookmarkNode*> nodes;
   nodes.push(root);
   while (!nodes.empty()) {
     const BookmarkNode* n = nodes.front();
     nodes.pop();
 
     int64 version = n->sync_transaction_version();
     EXPECT_NE(BookmarkNode::kInvalidSyncTransactionVersion, version);
 
     (*node_versions)[n->id()] = version;
     for (int i = 0; i < n->child_count(); ++i) {
-      if (client->IsDescendantOfManagedNode(n->GetChild(i)))
+      if (!CanSyncNode(n->GetChild(i)))
         continue;
       nodes.push(n->GetChild(i));
     }
   }
 }
 
 void ProfileSyncServiceBookmarkTestWithData::ExpectTransactionVersionMatch(
     const BookmarkNode* node,
     const BookmarkNodeVersionMap& version_expected) {
   syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
@@ skipping 135 matching lines @@
   ExpectModelMatch();
 
   // Then simulate the add call arriving late.
   change_processor_->BookmarkNodeAdded(model_, model_->bookmark_bar_node(), 0);
   ExpectModelMatch();
 }
 
 }  // namespace
 
 }  // namespace browser_sync