Create the managed_node at the ChromeBookmarkClient.

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>
 #include <stack>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/glue/bookmark_model_associator.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/base_bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/sync_driver/data_type_error_handler.h"
 #include "components/sync_driver/data_type_error_handler_mock.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 564 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());
     }
-    if (browser_index == bnode->parent()->child_count() - 1) {
+    // 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()) {
       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 =
+        BookmarkModelFactory::GetChromeBookmarkClientForProfile(&profile_);
+    ASSERT_TRUE(client);
+    ASSERT_FALSE(client->IsDescendantOfManagedNode(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));
   }
 
   void ExpectBrowserNodeKnown(int64 sync_id) {
@@ skipping 660 matching lines @@
                             int size,
                             int* running_count);
   void CompareWithTestData(const BookmarkNode* node,
                            const TestData* data,
                            int size,
                            int* running_count);
 
   void ExpectBookmarkModelMatchesTestData();
   void WriteTestDataToBookmarkModel();
 
+  // Output transaction versions of |node| and nodes under it to
+  // |node_versions|.
+  void GetTransactionVersions(const BookmarkNode* root,
+                              BookmarkNodeVersionMap* node_versions);
+
   // Verify transaction versions of bookmark nodes and sync nodes are equal
   // recursively. If node is in |version_expected|, versions should match
   // there, too.
   void ExpectTransactionVersionMatch(
       const BookmarkNode* node,
       const BookmarkNodeVersionMap& version_expected);
 
  private:
   const base::Time start_time_;
 
@@ skipping 668 matching lines @@
   ExpectModelMatch();
 
   // Change/delete existing meta info and verify.
   model_->DeleteNodeMetaInfo(folder_node, "folder");
   model_->SetNodeMetaInfo(node, "node", "changednodevalue");
   model_->DeleteNodeMetaInfo(node, "other");
   model_->SetNodeMetaInfo(node, "newkey", "newkeyvalue");
   ExpectModelMatch();
 }
 
-// Output transaction versions of |node| and nodes under it to |node_versions|.
-void GetTransactionVersions(
+void ProfileSyncServiceBookmarkTestWithData::GetTransactionVersions(
     const BookmarkNode* root,
     BookmarkNodeVersionMap* node_versions) {
+  ChromeBookmarkClient* client =
+      BookmarkModelFactory::GetChromeBookmarkClientForProfile(&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)
+    for (int i = 0; i < n->child_count(); ++i) {
+      if (client->IsDescendantOfManagedNode(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());
 
   BookmarkNodeVersionMap bnodes_versions;
   GetTransactionVersions(node, &bnodes_versions);
@@ skipping 132 matching lines @@
   ExpectModelMatch();
 
   // Then simulate the add call arriving late.
   change_processor_->BookmarkNodeAdded(model_, model_->bookmark_bar_node(), 0);
   ExpectModelMatch();
 }
 
 }  // namespace
 
 }  // namespace browser_sync