Format profile_sync_service_bookmark_unittest.cc

components/browser_sync/browser/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 <stddef.h>
 #include <stdint.h>
@@ skipping 83 matching lines @@
 }
 
 // FakeServerChange constructs a list of syncer::ChangeRecords while modifying
 // the sync model, and can pass the ChangeRecord list to a
 // syncer::SyncObserver (i.e., the ProfileSyncService) to test the client
 // change-application behavior.
 // Tests using FakeServerChange should be careful to avoid back-references,
 // since FakeServerChange will send the edits in the order specified.
 class FakeServerChange {
  public:
-  explicit FakeServerChange(syncer::WriteTransaction* trans) : trans_(trans) {
-  }
+  explicit FakeServerChange(syncer::WriteTransaction* trans) : trans_(trans) {}
 
   // Pretend that the server told the syncer to add a bookmark object.
   int64_t AddWithMetaInfo(const std::string& title,
                           const std::string& url,
                           const BookmarkNode::MetaInfoMap* meta_info_map,
                           bool is_folder,
                           int64_t parent_id,
                           int64_t predecessor_id) {
     syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
@@ skipping 145 matching lines @@
     node.SetBookmarkSpecifics(specifics);
     SetModified(id);
   }
 
   // Pass the fake change list to |service|.
   void ApplyPendingChanges(sync_driver::ChangeProcessor* processor) {
     processor->ApplyChangesFromSyncModel(
         trans_, 0, syncer::ImmutableChangeRecordList(&changes_));
   }
 
-  const syncer::ChangeRecordList& changes() {
-    return changes_;
-  }
+  const syncer::ChangeRecordList& changes() { return changes_; }
 
  private:
   // Helper function to push an ACTION_UPDATE record onto the back
   // of the changelist.
   void SetModified(int64_t id) {
     // Coalesce multi-property edits.
     if (!changes_.empty() && changes_.back().id == id &&
-        changes_.back().action ==
-        syncer::ChangeRecord::ACTION_UPDATE)
+        changes_.back().action == syncer::ChangeRecord::ACTION_UPDATE)
       return;
     syncer::ChangeRecord record;
     record.action = syncer::ChangeRecord::ACTION_UPDATE;
     record.id = id;
     changes_.push_back(record);
   }
 
   void SetNodeMetaInfo(const BookmarkNode::MetaInfoMap& meta_info_map,
                        sync_pb::BookmarkSpecifics* specifics) {
     specifics->clear_meta_info();
     // Deliberatly set MetaInfoMap entries in opposite order (compared
     // to the implementation in BookmarkChangeProcessor) to ensure that
     // (a) the implementation isn't sensitive to the order and
     // (b) the original meta info isn't blindly overwritten by
     //     BookmarkChangeProcessor unless there is a real change.
     BookmarkNode::MetaInfoMap::const_iterator it = meta_info_map.end();
     while (it != meta_info_map.begin()) {
       --it;
       sync_pb::MetaInfo* meta_info = specifics->add_meta_info();
       meta_info->set_key(it->first);
       meta_info->set_value(it->second);
     }
   }
 
   // The transaction on which everything happens.
-  syncer::WriteTransaction *trans_;
+  syncer::WriteTransaction* trans_;
 
   // The change list we construct.
   syncer::ChangeRecordList changes_;
   DISALLOW_COPY_AND_ASSIGN(FakeServerChange);
 };
 
 class ExtensiveChangesBookmarkModelObserver
     : public bookmarks::BaseBookmarkModelObserver {
  public:
   ExtensiveChangesBookmarkModelObserver()
       : started_count_(0),
         completed_count_at_started_(0),
         completed_count_(0) {}
 
   void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) override {
     ++started_count_;
     completed_count_at_started_ = completed_count_;
   }
 
   void ExtensiveBookmarkChangesEnded(BookmarkModel* model) override {
     ++completed_count_;
   }
 
   void BookmarkModelChanged() override {}
 
-  int get_started() const {
-    return started_count_;
-  }
+  int get_started() const { return started_count_; }
 
   int get_completed_count_at_started() const {
     return completed_count_at_started_;
   }
 
-  int get_completed() const {
-    return completed_count_;
-  }
+  int get_completed() const { return completed_count_; }
 
  private:
   int started_count_;
   int completed_count_at_started_;
   int completed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensiveChangesBookmarkModelObserver);
 };
 
 class ProfileSyncServiceBookmarkTest : public testing::Test {
@@ skipping 129 matching lines @@
       return 0;
     return node.GetTotalNodeCount();
   }
 
   // Creates the bookmark root node and the permanent nodes if they don't
   // already exist.
   bool CreatePermanentBookmarkNodes() {
     bool root_exists = false;
     syncer::ModelType type = syncer::BOOKMARKS;
     {
-      syncer::WriteTransaction trans(FROM_HERE,
-                                     test_user_share_.user_share());
+      syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
       syncer::ReadNode uber_root(&trans);
       uber_root.InitByRootLookup();
 
       syncer::ReadNode root(&trans);
       root_exists = (root.InitTypeRoot(type) == BaseNode::INIT_OK);
     }
 
     if (!root_exists) {
       if (!syncer::TestUserShare::CreateRoot(type,
                                              test_user_share_.user_share()))
@@ skipping 48 matching lines @@
     model_associator_.reset(new BookmarkModelAssociator(
         model_.get(), sync_client_.get(), test_user_share_.user_share(),
         &mock_error_handler_, kExpectMobileBookmarks));
 
     local_merge_result_ = syncer::SyncMergeResult(syncer::BOOKMARKS);
     syncer_merge_result_ = syncer::SyncMergeResult(syncer::BOOKMARKS);
     int local_count_before = model_->root_node()->GetTotalNodeCount();
     int syncer_count_before = GetSyncBookmarkCount();
 
     syncer::SyncError error = model_associator_->AssociateModels(
-        &local_merge_result_,
-        &syncer_merge_result_);
+        &local_merge_result_, &syncer_merge_result_);
     if (error.IsSet())
       return false;
 
     base::RunLoop().RunUntilIdle();
 
     // Verify the merge results were calculated properly.
     EXPECT_EQ(local_count_before,
               local_merge_result_.num_items_before_association());
     EXPECT_EQ(syncer_count_before,
               syncer_merge_result_.num_items_before_association());
@@ skipping 33 matching lines @@
 
     base::RunLoop().RunUntilIdle();
 
     // TODO(akalin): Actually close the database and flush it to disk
     // (and make StartSync reload from disk).  This would require
     // refactoring TestUserShare.
   }
 
   bool InitSyncNodeFromChromeNode(const BookmarkNode* bnode,
                                   BaseNode* sync_node) {
-    return model_associator_->InitSyncNodeFromChromeId(bnode->id(),
-                                                       sync_node);
+    return model_associator_->InitSyncNodeFromChromeId(bnode->id(), sync_node);
   }
 
   void ExpectSyncerNodeMatching(syncer::BaseTransaction* trans,
                                 const BookmarkNode* bnode) {
     std::string truncated_title = base::UTF16ToUTF8(bnode->GetTitle());
     syncer::SyncAPINameToServerName(truncated_title, &truncated_title);
     base::TruncateUTF8ToByteSize(truncated_title, 255, &truncated_title);
     syncer::ServerNameToSyncAPIName(truncated_title, &truncated_title);
 
     syncer::ReadNode gnode(trans);
     ASSERT_TRUE(InitSyncNodeFromChromeNode(bnode, &gnode));
     // Non-root node titles and parents must match.
     if (!model_->is_permanent_node(bnode)) {
       EXPECT_EQ(truncated_title, gnode.GetTitle());
-      EXPECT_EQ(
-          model_associator_->GetChromeNodeFromSyncId(gnode.GetParentId()),
-          bnode->parent());
+      EXPECT_EQ(model_associator_->GetChromeNodeFromSyncId(gnode.GetParentId()),
+                bnode->parent());
     }
     EXPECT_EQ(bnode->is_folder(), gnode.GetIsFolder());
     if (bnode->is_url())
       EXPECT_EQ(bnode->url(), GURL(gnode.GetBookmarkSpecifics().url()));
 
     // Check that meta info matches.
     const BookmarkNode::MetaInfoMap* meta_info_map = bnode->GetMetaInfoMap();
     sync_pb::BookmarkSpecifics specifics = gnode.GetBookmarkSpecifics();
     if (!meta_info_map) {
       EXPECT_EQ(0, specifics.meta_info_size());
     } else {
       EXPECT_EQ(meta_info_map->size(),
                 static_cast<size_t>(specifics.meta_info_size()));
       for (int i = 0; i < specifics.meta_info_size(); i++) {
         BookmarkNode::MetaInfoMap::const_iterator it =
             meta_info_map->find(specifics.meta_info(i).key());
         EXPECT_TRUE(it != meta_info_map->end());
         EXPECT_EQ(it->second, specifics.meta_info(i).value());
       }
     }
 
     // Check for position matches.
     int browser_index = bnode->parent()->GetIndexOf(bnode);
     if (browser_index == 0) {
       EXPECT_EQ(gnode.GetPredecessorId(), 0);
     } else {
-      const BookmarkNode* bprev =
-          bnode->parent()->GetChild(browser_index - 1);
+      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 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);
+      bnext = bnode->parent()->GetChild(browser_index + 1);
     if (!bnext || !CanSyncNode(bnext)) {
       EXPECT_EQ(gnode.GetSuccessorId(), 0);
     } else {
       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());
@@ skipping 63 matching lines @@
     const BookmarkNode* root = model_->root_node();
     EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 1);
     EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 2);
 
     std::stack<int64_t> stack;
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
       int64_t id = stack.top();
       stack.pop();
-      if (!id) continue;
+      if (!id)
+        continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
       syncer::ReadNode gnode(trans);
       ASSERT_EQ(BaseNode::INIT_OK, gnode.InitByIdLookup(id));
       stack.push(gnode.GetSuccessorId());
       if (gnode.GetIsFolder())
         stack.push(gnode.GetFirstChildId());
     }
   }
 
   void ExpectModelMatch() {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
   int64_t mobile_bookmarks_id() {
-    return
-        model_associator_->GetSyncIdFromChromeId(model_->mobile_node()->id());
+    return model_associator_->GetSyncIdFromChromeId(
+        model_->mobile_node()->id());
   }
 
   int64_t other_bookmarks_id() {
-    return
-        model_associator_->GetSyncIdFromChromeId(model_->other_node()->id());
+    return model_associator_->GetSyncIdFromChromeId(model_->other_node()->id());
   }
 
   int64_t bookmark_bar_id() {
     return model_associator_->GetSyncIdFromChromeId(
         model_->bookmark_bar_node()->id());
   }
 
   BookmarkModel* model() { return model_.get(); }
 
   syncer::TestUserShare* test_user_share() { return &test_user_share_; }
@@ skipping 389 matching lines @@
   int64_t u1 = adds.AddURL("Some old site", "ftp://nifty.andrew.cmu.edu/",
                            bookmark_bar_id(), f2);
   int64_t u2 = adds.AddURL("Nifty", "ftp://nifty.andrew.cmu.edu/", f1, 0);
   // u3 is a duplicate URL
   int64_t u3 = adds.AddURL("Nifty2", "ftp://nifty.andrew.cmu.edu/", f1, u2);
   // u4 is a duplicate title, different URL.
   adds.AddURL("Some old site", "http://slog.thestranger.com/",
               bookmark_bar_id(), u1);
   // u5 tests an empty-string title.
   std::string javascript_url(
-      "javascript:(function(){var w=window.open(" \
-      "'about:blank','gnotesWin','location=0,menubar=0," \
-      "scrollbars=0,status=0,toolbar=0,width=300," \
+      "javascript:(function(){var w=window.open("
+      "'about:blank','gnotesWin','location=0,menubar=0,"
+      "scrollbars=0,status=0,toolbar=0,width=300,"
       "height=300,resizable');});");
   adds.AddURL(std::string(), javascript_url, other_bookmarks_id(), 0);
   int64_t u6 = adds.AddURL("Sync1", "http://www.syncable.edu/",
                            mobile_bookmarks_id(), 0);
 
   syncer::ChangeRecordList::const_iterator it;
   // The bookmark model shouldn't yet have seen any of the nodes of |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeUnknown(it->id);
 
@@ skipping 166 matching lines @@
   // Now reboot the sync service, forcing a merge step.
   StopSync();
   LoadBookmarkModel(LOAD_FROM_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
   // Things ought not to have changed.
   EXPECT_EQ(model()->other_node()->child_count(), child_count);
   ExpectModelMatch();
 }
 
-
 // Test strings that might pose a problem if the titles ever became used as
 // file names in the sync backend.
 TEST_F(ProfileSyncServiceBookmarkTest, CornerCaseNames) {
   // TODO(ncarter): Bug 1570238 explains the failure of this test.
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
   const char* names[] = {
       // The empty string.
       "",
       // Illegal Windows filenames.
-      "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4",
-      "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3",
-      "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
+      "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5",
+      "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5",
+      "LPT6", "LPT7", "LPT8", "LPT9",
       // Current/parent directory markers.
       ".", "..", "...",
       // Files created automatically by the Windows shell.
       "Thumbs.db", ".DS_Store",
       // Names including Win32-illegal characters, and path separators.
       "foo/bar", "foo\\bar", "foo?bar", "foo:bar", "foo|bar", "foo\"bar",
       "foo'bar", "foo<bar", "foo>bar", "foo%bar", "foo*bar", "foo]bar",
       "foo[bar",
       // A name with title > 255 characters
       "012345678901234567890123456789012345678901234567890123456789012345678901"
       "234567890123456789012345678901234567890123456789012345678901234567890123"
       "456789012345678901234567890123456789012345678901234567890123456789012345"
       "678901234567890123456789012345678901234567890123456789012345678901234567"
-      "890123456789"
-  };
+      "890123456789"};
   // Create both folders and bookmarks using each name.
   GURL url("http://www.doublemint.com");
   for (size_t i = 0; i < arraysize(names); ++i) {
     model()->AddFolder(model()->other_node(), 0, base::ASCIIToUTF16(names[i]));
     model()->AddURL(model()->other_node(), 0, base::ASCIIToUTF16(names[i]),
                     url);
   }
 
   // Verify that the browser model matches the sync model.
   EXPECT_EQ(static_cast<size_t>(model()->other_node()->child_count()),
@@ skipping 274 matching lines @@
 // |
 // +-- Mobile bookmarks
 //     |-- f5
 //     |   |-- f5u1, http://www.f5u1.com/
 //     |-- f6
 //     |   |-- f6u1, http://www.f6u1.com/
 //     |   |-- f6u2, http://www.f6u2.com/
 //     +-- u5, http://www.u5.com/
 
 static TestData kBookmarkBarChildren[] = {
-  { "u2", "http://www.u2.com/" },
-  { "f1", NULL },
-  { "u1", "http://www.u1.com/" },
-  { "f2", NULL },
+    {"u2", "http://www.u2.com/"},
+    {"f1", NULL},
+    {"u1", "http://www.u1.com/"},
+    {"f2", NULL},
 };
 static TestData kF1Children[] = {
-  { "f1u4", "http://www.f1u4.com/" },
-  { "f1u2", "http://www.f1u2.com/" },
-  { "f1u3", "http://www.f1u3.com/" },
-  { "f1u1", "http://www.f1u1.com/" },
+    {"f1u4", "http://www.f1u4.com/"},
+    {"f1u2", "http://www.f1u2.com/"},
+    {"f1u3", "http://www.f1u3.com/"},
+    {"f1u1", "http://www.f1u1.com/"},
 };
 static TestData kF2Children[] = {
-  { "f2u2", "http://www.f2u2.com/" },
-  { "f2u4", "http://www.f2u4.com/" },
-  { "f2u3", "http://www.f2u3.com/" },
-  { "f2u1", "http://www.f2u1.com/" },
+    {"f2u2", "http://www.f2u2.com/"},
+    {"f2u4", "http://www.f2u4.com/"},
+    {"f2u3", "http://www.f2u3.com/"},
+    {"f2u1", "http://www.f2u1.com/"},
 };
 
-static TestData kOtherBookmarkChildren[] = {
-  { "f3", NULL },
-  { "u4", "http://www.u4.com/" },
-  { "u3", "http://www.u3.com/" },
-  { "f4", NULL },
-  { "dup", NULL },
-  { "dup", NULL },
-  { "  ls  ", "http://www.ls.com/" }
-};
+static TestData kOtherBookmarkChildren[] = {{"f3", NULL},
+                                            {"u4", "http://www.u4.com/"},
+                                            {"u3", "http://www.u3.com/"},
+                                            {"f4", NULL},
+                                            {"dup", NULL},
+                                            {"dup", NULL},
+                                            {"  ls  ", "http://www.ls.com/"}};
 static TestData kF3Children[] = {
-  { "f3u4", "http://www.f3u4.com/" },
-  { "f3u2", "http://www.f3u2.com/" },
-  { "f3u3", "http://www.f3u3.com/" },
-  { "f3u1", "http://www.f3u1.com/" },
+    {"f3u4", "http://www.f3u4.com/"},
+    {"f3u2", "http://www.f3u2.com/"},
+    {"f3u3", "http://www.f3u3.com/"},
+    {"f3u1", "http://www.f3u1.com/"},
 };
 static TestData kF4Children[] = {
-  { "f4u1", "http://www.f4u1.com/" },
-  { "f4u2", "http://www.f4u2.com/" },
-  { "f4u3", "http://www.f4u3.com/" },
-  { "f4u4", "http://www.f4u4.com/" },
+    {"f4u1", "http://www.f4u1.com/"},
+    {"f4u2", "http://www.f4u2.com/"},
+    {"f4u3", "http://www.f4u3.com/"},
+    {"f4u4", "http://www.f4u4.com/"},
 };
 static TestData kDup1Children[] = {
-  { "dupu1", "http://www.dupu1.com/" },
+    {"dupu1", "http://www.dupu1.com/"},
 };
 static TestData kDup2Children[] = {
-  { "dupu2", "http://www.dupu2.com/" },
+    {"dupu2", "http://www.dupu2.com/"},
 };
 
 static TestData kMobileBookmarkChildren[] = {
-  { "f5", NULL },
-  { "f6", NULL },
-  { "u5", "http://www.u5.com/" },
+    {"f5", NULL},
+    {"f6", NULL},
+    {"u5", "http://www.u5.com/"},
 };
 static TestData kF5Children[] = {
-  { "f5u1", "http://www.f5u1.com/" },
-  { "f5u2", "http://www.f5u2.com/" },
+    {"f5u1", "http://www.f5u1.com/"},
+    {"f5u2", "http://www.f5u2.com/"},
 };
 static TestData kF6Children[] = {
-  { "f6u1", "http://www.f6u1.com/" },
-  { "f6u2", "http://www.f6u2.com/" },
+    {"f6u1", "http://www.f6u1.com/"},
+    {"f6u2", "http://www.f6u2.com/"},
 };
 
 }  // anonymous namespace.
 
-ProfileSyncServiceBookmarkTestWithData::
-ProfileSyncServiceBookmarkTestWithData()
-    : start_time_(base::Time::Now()) {
-}
+ProfileSyncServiceBookmarkTestWithData::ProfileSyncServiceBookmarkTestWithData()
+    : start_time_(base::Time::Now()) {}
 
 void ProfileSyncServiceBookmarkTestWithData::PopulateFromTestData(
     const BookmarkNode* node,
     const TestData* data,
     int size,
     int* running_count) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   for (int i = 0; i < size; ++i) {
@@ skipping 41 matching lines @@
     }
     (*running_count)++;
   }
 }
 
 // TODO(munjal): We should implement some way of generating random data and can
 // use the same seed to generate the same sequence.
 void ProfileSyncServiceBookmarkTestWithData::WriteTestDataToBookmarkModel() {
   const BookmarkNode* bookmarks_bar_node = model()->bookmark_bar_node();
   int count = 0;
-  PopulateFromTestData(bookmarks_bar_node,
-                       kBookmarkBarChildren,
-                       arraysize(kBookmarkBarChildren),
-                       &count);
+  PopulateFromTestData(bookmarks_bar_node, kBookmarkBarChildren,
+                       arraysize(kBookmarkBarChildren), &count);
 
   ASSERT_GE(bookmarks_bar_node->child_count(), 4);
   const BookmarkNode* f1_node = bookmarks_bar_node->GetChild(1);
   PopulateFromTestData(f1_node, kF1Children, arraysize(kF1Children), &count);
   const BookmarkNode* f2_node = bookmarks_bar_node->GetChild(3);
   PopulateFromTestData(f2_node, kF2Children, arraysize(kF2Children), &count);
 
   const BookmarkNode* other_bookmarks_node = model()->other_node();
-  PopulateFromTestData(other_bookmarks_node,
-                       kOtherBookmarkChildren,
-                       arraysize(kOtherBookmarkChildren),
-                       &count);
+  PopulateFromTestData(other_bookmarks_node, kOtherBookmarkChildren,
+                       arraysize(kOtherBookmarkChildren), &count);
 
   ASSERT_GE(other_bookmarks_node->child_count(), 6);
   const BookmarkNode* f3_node = other_bookmarks_node->GetChild(0);
   PopulateFromTestData(f3_node, kF3Children, arraysize(kF3Children), &count);
   const BookmarkNode* f4_node = other_bookmarks_node->GetChild(3);
   PopulateFromTestData(f4_node, kF4Children, arraysize(kF4Children), &count);
   const BookmarkNode* dup_node = other_bookmarks_node->GetChild(4);
   PopulateFromTestData(dup_node, kDup1Children, arraysize(kDup1Children),
                        &count);
   dup_node = other_bookmarks_node->GetChild(5);
   PopulateFromTestData(dup_node, kDup2Children, arraysize(kDup2Children),
                        &count);
 
   const BookmarkNode* mobile_bookmarks_node = model()->mobile_node();
-  PopulateFromTestData(mobile_bookmarks_node,
-                       kMobileBookmarkChildren,
-                       arraysize(kMobileBookmarkChildren),
-                       &count);
+  PopulateFromTestData(mobile_bookmarks_node, kMobileBookmarkChildren,
+                       arraysize(kMobileBookmarkChildren), &count);
 
   ASSERT_GE(mobile_bookmarks_node->child_count(), 3);
   const BookmarkNode* f5_node = mobile_bookmarks_node->GetChild(0);
   PopulateFromTestData(f5_node, kF5Children, arraysize(kF5Children), &count);
   const BookmarkNode* f6_node = mobile_bookmarks_node->GetChild(1);
   PopulateFromTestData(f6_node, kF6Children, arraysize(kF6Children), &count);
 
   ExpectBookmarkModelMatchesTestData();
 }
 
 void ProfileSyncServiceBookmarkTestWithData::
     ExpectBookmarkModelMatchesTestData() {
   const BookmarkNode* bookmark_bar_node = model()->bookmark_bar_node();
   int count = 0;
-  CompareWithTestData(bookmark_bar_node,
-                      kBookmarkBarChildren,
-                      arraysize(kBookmarkBarChildren),
-                      &count);
+  CompareWithTestData(bookmark_bar_node, kBookmarkBarChildren,
+                      arraysize(kBookmarkBarChildren), &count);
 
   ASSERT_GE(bookmark_bar_node->child_count(), 4);
   const BookmarkNode* f1_node = bookmark_bar_node->GetChild(1);
   CompareWithTestData(f1_node, kF1Children, arraysize(kF1Children), &count);
   const BookmarkNode* f2_node = bookmark_bar_node->GetChild(3);
   CompareWithTestData(f2_node, kF2Children, arraysize(kF2Children), &count);
 
   const BookmarkNode* other_bookmarks_node = model()->other_node();
-  CompareWithTestData(other_bookmarks_node,
-                      kOtherBookmarkChildren,
-                      arraysize(kOtherBookmarkChildren),
-                      &count);
+  CompareWithTestData(other_bookmarks_node, kOtherBookmarkChildren,
+                      arraysize(kOtherBookmarkChildren), &count);
 
   ASSERT_GE(other_bookmarks_node->child_count(), 6);
   const BookmarkNode* f3_node = other_bookmarks_node->GetChild(0);
   CompareWithTestData(f3_node, kF3Children, arraysize(kF3Children), &count);
   const BookmarkNode* f4_node = other_bookmarks_node->GetChild(3);
   CompareWithTestData(f4_node, kF4Children, arraysize(kF4Children), &count);
   const BookmarkNode* dup_node = other_bookmarks_node->GetChild(4);
   CompareWithTestData(dup_node, kDup1Children, arraysize(kDup1Children),
                       &count);
   dup_node = other_bookmarks_node->GetChild(5);
   CompareWithTestData(dup_node, kDup2Children, arraysize(kDup2Children),
                       &count);
 
   const BookmarkNode* mobile_bookmarks_node = model()->mobile_node();
-  CompareWithTestData(mobile_bookmarks_node,
-                      kMobileBookmarkChildren,
-                      arraysize(kMobileBookmarkChildren),
-                      &count);
+  CompareWithTestData(mobile_bookmarks_node, kMobileBookmarkChildren,
+                      arraysize(kMobileBookmarkChildren), &count);
 
   ASSERT_GE(mobile_bookmarks_node->child_count(), 3);
   const BookmarkNode* f5_node = mobile_bookmarks_node->GetChild(0);
   CompareWithTestData(f5_node, kF5Children, arraysize(kF5Children), &count);
   const BookmarkNode* f6_node = mobile_bookmarks_node->GetChild(1);
   CompareWithTestData(f6_node, kF6Children, arraysize(kF6Children), &count);
 }
 
 // Tests persistence of the profile sync service by unloading the
 // database and then reloading it from disk.
@@ skipping 693 matching lines @@
   EXPECT_EQ(syncer::kInvalidId, sync_id);
 
   // Verify that Sync ignores deleting this node.
   model()->Remove(node);
   EXPECT_EQ(sync_bookmark_count, GetSyncBookmarkCount());
 }
 
 }  // namespace
 
 }  // namespace browser_sync