src/chrome/browser/sync/test/integration/two_client_bookmarks_sync_test.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/rand_util.h"
   6 #include "base/run_loop.h"
   7 #include "base/values.h"
   8 #include "chrome/browser/policy/profile_policy_connector_factory.h"
   9 #include "chrome/browser/profiles/profile.h"
  10 #include "chrome/browser/sync/test/integration/bookmarks_helper.h"
  11 #include "chrome/browser/sync/test/integration/passwords_helper.h"
  12 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
  13 #include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
  14 #include "chrome/browser/sync/test/integration/sync_test.h"
  15 #include "components/policy/core/common/mock_configuration_policy_provider.h"
  16 #include "components/policy/core/common/policy_map.h"
  17 #include "policy/policy_constants.h"
  18 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
  19 #include "testing/gmock/include/gmock/gmock.h"
  20 #include "ui/base/layout.h"
  21
  22 using bookmarks_helper::AddFolder;
  23 using bookmarks_helper::AddURL;
  24 using bookmarks_helper::AllModelsMatch;
  25 using bookmarks_helper::AllModelsMatchVerifier;
  26 using bookmarks_helper::ContainsDuplicateBookmarks;
  27 using bookmarks_helper::CountBookmarksWithTitlesMatching;
  28 using bookmarks_helper::CreateFavicon;
  29 using bookmarks_helper::GetBookmarkBarNode;
  30 using bookmarks_helper::GetManagedNode;
  31 using bookmarks_helper::GetOtherNode;
  32 using bookmarks_helper::GetSyncedBookmarksNode;
  33 using bookmarks_helper::GetUniqueNodeByURL;
  34 using bookmarks_helper::HasNodeWithURL;
  35 using bookmarks_helper::IndexedFolderName;
  36 using bookmarks_helper::IndexedSubfolderName;
  37 using bookmarks_helper::IndexedSubsubfolderName;
  38 using bookmarks_helper::IndexedURL;
  39 using bookmarks_helper::IndexedURLTitle;
  40 using bookmarks_helper::Move;
  41 using bookmarks_helper::Remove;
  42 using bookmarks_helper::RemoveAll;
  43 using bookmarks_helper::ReverseChildOrder;
  44 using bookmarks_helper::SetFavicon;
  45 using bookmarks_helper::SetTitle;
  46 using bookmarks_helper::SetURL;
  47 using bookmarks_helper::SortChildren;
  48 using passwords_helper::SetDecryptionPassphrase;
  49 using passwords_helper::SetEncryptionPassphrase;
  50 using sync_integration_test_util::AwaitCommitActivityCompletion;
  51 using sync_integration_test_util::AwaitPassphraseAccepted;
  52 using sync_integration_test_util::AwaitPassphraseRequired;
  53
  54 namespace {
  55
  56 const char kGenericURL[] = "http://www.host.ext:1234/path/filename";
  57 const char kGenericURLTitle[] = "URL Title";
  58 const char kGenericFolderName[] = "Folder Name";
  59 const char kGenericSubfolderName[] = "Subfolder Name";
  60 const char kValidPassphrase[] = "passphrase!";
  61
  62 }  // namespace
  63
  64 class TwoClientBookmarksSyncTest : public SyncTest {
  65  public:
  66   TwoClientBookmarksSyncTest() : SyncTest(TWO_CLIENT) {}
  67   virtual ~TwoClientBookmarksSyncTest() {}
  68
  69   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
  70     SyncTest::TearDownInProcessBrowserTestFixture();
  71     policy_provider_.Shutdown();
  72   }
  73
  74  protected:
  75   // Needs to be deleted after all Profiles are deleted.
  76   policy::MockConfigurationPolicyProvider policy_provider_;
  77
  78  private:
  79   DISALLOW_COPY_AND_ASSIGN(TwoClientBookmarksSyncTest);
  80 };
  81
  82 class LegacyTwoClientBookmarksSyncTest : public SyncTest {
  83  public:
  84   LegacyTwoClientBookmarksSyncTest() : SyncTest(TWO_CLIENT_LEGACY) {}
  85   virtual ~LegacyTwoClientBookmarksSyncTest() {}
  86
  87  private:
  88   DISALLOW_COPY_AND_ASSIGN(LegacyTwoClientBookmarksSyncTest);
  89 };
  90
  91 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, Sanity) {
  92   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  93   ASSERT_TRUE(AllModelsMatchVerifier());
  94
  95   GURL google_url("http://www.google.com");
  96   ASSERT_TRUE(AddURL(0, "Google", google_url) != NULL);
  97   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
  98   ASSERT_TRUE(AddURL(1, "Yahoo", GURL("http://www.yahoo.com")) != NULL);
  99   ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 100   ASSERT_TRUE(AllModelsMatchVerifier());
 101
 102   const BookmarkNode* new_folder = AddFolder(0, 2, "New Folder");
 103   Move(0, GetUniqueNodeByURL(0, google_url), new_folder, 0);
 104   SetTitle(0, GetBookmarkBarNode(0)->GetChild(0), "Yahoo!!");
 105   ASSERT_TRUE(AddURL(0, GetBookmarkBarNode(0), 1, "CNN",
 106       GURL("http://www.cnn.com")) != NULL);
 107   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 108   ASSERT_TRUE(AllModelsMatchVerifier());
 109
 110   ASSERT_TRUE(AddURL(1, "Facebook", GURL("http://www.facebook.com")) != NULL);
 111   ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 112   ASSERT_TRUE(AllModelsMatchVerifier());
 113
 114   SortChildren(1, GetBookmarkBarNode(1));
 115   ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 116   ASSERT_TRUE(AllModelsMatchVerifier());
 117
 118   DisableVerifier();
 119   SetTitle(0, GetUniqueNodeByURL(0, google_url), "Google++");
 120   SetTitle(1, GetUniqueNodeByURL(1, google_url), "Google--");
 121   ASSERT_TRUE(AwaitQuiescence());
 122   ASSERT_TRUE(AllModelsMatch());
 123 }
 124
 125 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SimultaneousURLChanges) {
 126   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 127   ASSERT_TRUE(AllModelsMatchVerifier());
 128
 129   GURL initial_url("http://www.google.com");
 130   GURL second_url("http://www.google.com/abc");
 131   GURL third_url("http://www.google.com/def");
 132   std::string title = "Google";
 133
 134   ASSERT_TRUE(AddURL(0, title, initial_url) != NULL);
 135   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 136
 137   DisableVerifier();
 138   ASSERT_TRUE(SetURL(
 139       0, GetUniqueNodeByURL(0, initial_url), second_url) != NULL);
 140   ASSERT_TRUE(SetURL(
 141       1, GetUniqueNodeByURL(1, initial_url), third_url) != NULL);
 142   ASSERT_TRUE(AwaitQuiescence());
 143   ASSERT_TRUE(AllModelsMatch());
 144
 145   SetTitle(0, GetBookmarkBarNode(0)->GetChild(0), "Google1");
 146   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 147   ASSERT_TRUE(AllModelsMatch());
 148 }
 149
 150 // Test Scribe ID - 370558.
 151 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_AddFirstFolder) {
 152   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 153   ASSERT_TRUE(AllModelsMatchVerifier());
 154
 155   ASSERT_TRUE(AddFolder(0, kGenericFolderName) != NULL);
 156   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 157   ASSERT_TRUE(AllModelsMatchVerifier());
 158 }
 159
 160 // Test Scribe ID - 370559.
 161 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 162                        SC_AddFirstBMWithoutFavicon) {
 163   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 164   ASSERT_TRUE(AllModelsMatchVerifier());
 165
 166   ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 167   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 168   ASSERT_TRUE(AllModelsMatchVerifier());
 169 }
 170
 171 // Test Scribe ID - 370489.
 172 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_AddFirstBMWithFavicon) {
 173   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 174   ASSERT_TRUE(AllModelsMatchVerifier());
 175
 176   const GURL page_url(kGenericURL);
 177   const GURL icon_url("http://www.google.com/favicon.ico");
 178
 179   const BookmarkNode* bookmark = AddURL(0, kGenericURLTitle, page_url);
 180
 181   ASSERT_TRUE(bookmark != NULL);
 182   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 183   SetFavicon(0, bookmark, icon_url, CreateFavicon(SK_ColorWHITE),
 184              bookmarks_helper::FROM_UI);
 185   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 186   ASSERT_TRUE(AllModelsMatchVerifier());
 187 }
 188
 189 // Test that the history service logic for not losing the hidpi versions of
 190 // favicons as a result of sync does not result in dropping sync updates.
 191 // In particular, the synced 16x16 favicon bitmap should overwrite 16x16
 192 // favicon bitmaps on all clients. (Though non-16x16 favicon bitmaps
 193 // are unchanged).
 194 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_SetFaviconHiDPI) {
 195   // Set the supported scale factors to include 2x such that CreateFavicon()
 196   // creates a favicon with hidpi representations and that methods in the
 197   // FaviconService request hidpi favicons.
 198   std::vector<ui::ScaleFactor> supported_scale_factors;
 199   supported_scale_factors.push_back(ui::SCALE_FACTOR_100P);
 200   supported_scale_factors.push_back(ui::SCALE_FACTOR_200P);
 201   ui::SetSupportedScaleFactors(supported_scale_factors);
 202
 203   const GURL page_url(kGenericURL);
 204   const GURL icon_url1("http://www.google.com/favicon1.ico");
 205   const GURL icon_url2("http://www.google.com/favicon2.ico");
 206
 207   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 208   ASSERT_TRUE(AllModelsMatchVerifier());
 209
 210   const BookmarkNode* bookmark0 = AddURL(0, kGenericURLTitle, page_url);
 211   ASSERT_TRUE(bookmark0 != NULL);
 212   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 213   SetFavicon(0, bookmark0, icon_url1, CreateFavicon(SK_ColorWHITE),
 214              bookmarks_helper::FROM_UI);
 215   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 216   ASSERT_TRUE(AllModelsMatchVerifier());
 217
 218   const BookmarkNode* bookmark1 = GetUniqueNodeByURL(1, page_url);
 219   SetFavicon(1, bookmark1, icon_url1, CreateFavicon(SK_ColorBLUE),
 220              bookmarks_helper::FROM_UI);
 221   ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 222   ASSERT_TRUE(AllModelsMatchVerifier());
 223
 224   SetFavicon(0, bookmark0, icon_url2, CreateFavicon(SK_ColorGREEN),
 225              bookmarks_helper::FROM_UI);
 226   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 227   ASSERT_TRUE(AllModelsMatchVerifier());
 228 }
 229
 230 // Test Scribe ID - 370560.
 231 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_AddNonHTTPBMs) {
 232   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 233   ASSERT_TRUE(AllModelsMatchVerifier());
 234
 235   ASSERT_TRUE(AddURL(
 236       0, "FTP UR", GURL("ftp://user:password@host:1234/path")) != NULL);
 237   ASSERT_TRUE(AddURL(0, "File UR", GURL("file://host/path")) != NULL);
 238   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 239   ASSERT_TRUE(AllModelsMatchVerifier());
 240 }
 241
 242 // Test Scribe ID - 370561.
 243 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 244                        SC_AddFirstBMUnderFolder) {
 245   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 246   ASSERT_TRUE(AllModelsMatchVerifier());
 247
 248   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 249   ASSERT_TRUE(folder != NULL);
 250   ASSERT_TRUE(AddURL(
 251       0, folder, 0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 252   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 253   ASSERT_TRUE(AllModelsMatchVerifier());
 254 }
 255
 256 // Test Scribe ID - 370562.
 257 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 258                        SC_AddSeveralBMsUnderBMBarAndOtherBM) {
 259   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 260   ASSERT_TRUE(AllModelsMatchVerifier());
 261
 262   for (int i = 0; i < 20; ++i) {
 263     std::string title = IndexedURLTitle(i);
 264     GURL url = GURL(IndexedURL(i));
 265     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 266     ASSERT_TRUE(AddURL(
 267         0, GetOtherNode(0), i, title, url) != NULL);
 268   }
 269   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 270   ASSERT_TRUE(AllModelsMatchVerifier());
 271 }
 272
 273 // Test Scribe ID - 370563.
 274 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 275                        SC_AddSeveralBMsAndFolders) {
 276   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 277   ASSERT_TRUE(AllModelsMatchVerifier());
 278
 279   for (int i = 0; i < 15; ++i) {
 280     if (base::RandDouble() > 0.6) {
 281       std::string title = IndexedURLTitle(i);
 282       GURL url = GURL(IndexedURL(i));
 283       ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 284     } else {
 285       std::string title = IndexedFolderName(i);
 286       const BookmarkNode* folder = AddFolder(0, i, title);
 287       ASSERT_TRUE(folder != NULL);
 288       if (base::RandDouble() > 0.4) {
 289         for (int i = 0; i < 20; ++i) {
 290           std::string title = IndexedURLTitle(i);
 291           GURL url = GURL(IndexedURL(i));
 292           ASSERT_TRUE(
 293               AddURL(0, folder, i, title, url) != NULL);
 294         }
 295       }
 296     }
 297   }
 298   for (int i = 0; i < 10; i++) {
 299     std::string title = IndexedURLTitle(i);
 300     GURL url = GURL(IndexedURL(i));
 301     ASSERT_TRUE(AddURL(0, GetOtherNode(0), i, title, url) != NULL);
 302   }
 303   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 304   ASSERT_TRUE(AllModelsMatchVerifier());
 305 }
 306
 307 // Test Scribe ID - 370641.
 308 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 309                        SC_DuplicateBMWithDifferentURLSameName) {
 310   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 311   ASSERT_TRUE(AllModelsMatchVerifier());
 312
 313   GURL url0 = GURL(IndexedURL(0));
 314   GURL url1 = GURL(IndexedURL(1));
 315   ASSERT_TRUE(AddURL(0, kGenericURLTitle, url0) != NULL);
 316   ASSERT_TRUE(AddURL(0, kGenericURLTitle, url1) != NULL);
 317   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 318   ASSERT_TRUE(AllModelsMatchVerifier());
 319 }
 320
 321 // Test Scribe ID - 370639 - Add bookmarks with different name and same URL.
 322 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 323                        SC_DuplicateBookmarksWithSameURL) {
 324   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 325   ASSERT_TRUE(AllModelsMatchVerifier());
 326
 327   std::string title0 = IndexedURLTitle(0);
 328   std::string title1 = IndexedURLTitle(1);
 329   ASSERT_TRUE(AddURL(0, title0, GURL(kGenericURL)) != NULL);
 330   ASSERT_TRUE(AddURL(0, title1, GURL(kGenericURL)) != NULL);
 331   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 332   ASSERT_TRUE(AllModelsMatchVerifier());
 333 }
 334
 335 // Test Scribe ID - 371817.
 336 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMName) {
 337   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 338   ASSERT_TRUE(AllModelsMatchVerifier());
 339
 340   std::string title = IndexedURLTitle(1);
 341   const BookmarkNode* bookmark = AddURL(0, title, GURL(kGenericURL));
 342   ASSERT_TRUE(bookmark != NULL);
 343   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 344   ASSERT_TRUE(AllModelsMatchVerifier());
 345
 346   std::string new_title = IndexedURLTitle(2);
 347   SetTitle(0, bookmark, new_title);
 348   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 349   ASSERT_TRUE(AllModelsMatchVerifier());
 350 }
 351
 352 // Test Scribe ID - 371822.
 353 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMURL) {
 354   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 355   ASSERT_TRUE(AllModelsMatchVerifier());
 356
 357   GURL url = GURL(IndexedURL(1));
 358   const BookmarkNode* bookmark = AddURL(0, kGenericURLTitle, url);
 359   ASSERT_TRUE(bookmark != NULL);
 360   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 361   ASSERT_TRUE(AllModelsMatchVerifier());
 362
 363   GURL new_url = GURL(IndexedURL(2));
 364   ASSERT_TRUE(SetURL(0, bookmark, new_url) != NULL);
 365   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 366   ASSERT_TRUE(AllModelsMatchVerifier());
 367 }
 368
 369
 370 // Test Scribe ID - 371818 - Renaming the same bookmark name twice.
 371 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 372                        SC_TwiceRenamingBookmarkName) {
 373   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 374   ASSERT_TRUE(AllModelsMatchVerifier());
 375
 376   std::string title = IndexedURLTitle(1);
 377   const BookmarkNode* bookmark = AddURL(0, title, GURL(kGenericURL));
 378   ASSERT_TRUE(bookmark != NULL);
 379   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 380   ASSERT_TRUE(AllModelsMatchVerifier());
 381
 382   std::string new_title = IndexedURLTitle(2);
 383   SetTitle(0, bookmark, new_title);
 384   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 385   ASSERT_TRUE(AllModelsMatchVerifier());
 386
 387   SetTitle(0, bookmark, title);
 388   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 389   ASSERT_TRUE(AllModelsMatchVerifier());
 390 }
 391
 392 // Test Scribe ID - 371823 - Renaming the same bookmark URL twice.
 393 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 394                        SC_TwiceRenamingBookmarkURL) {
 395   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 396   ASSERT_TRUE(AllModelsMatchVerifier());
 397
 398   GURL url = GURL(IndexedURL(1));
 399   const BookmarkNode* bookmark = AddURL(0, kGenericURLTitle, url);
 400   ASSERT_TRUE(bookmark != NULL);
 401   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 402   ASSERT_TRUE(AllModelsMatchVerifier());
 403
 404   GURL new_url = GURL(IndexedURL(2));
 405   ASSERT_TRUE(SetURL(0, bookmark, new_url) != NULL);
 406   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 407   ASSERT_TRUE(AllModelsMatchVerifier());
 408
 409   ASSERT_TRUE(SetURL(0, bookmark, url) != NULL);
 410   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 411   ASSERT_TRUE(AllModelsMatchVerifier());
 412 }
 413
 414 // Test Scribe ID - 371824.
 415 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMFolder) {
 416   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 417   ASSERT_TRUE(AllModelsMatchVerifier());
 418
 419   std::string title = IndexedFolderName(1);
 420   const BookmarkNode* folder = AddFolder(0, title);
 421   ASSERT_TRUE(AddURL(
 422       0, folder, 0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 423   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 424   ASSERT_TRUE(AllModelsMatchVerifier());
 425
 426   std::string new_title = IndexedFolderName(2);
 427   SetTitle(0, folder, new_title);
 428   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 429   ASSERT_TRUE(AllModelsMatchVerifier());
 430 }
 431
 432 // Test Scribe ID - 371825.
 433 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameEmptyBMFolder) {
 434   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 435   ASSERT_TRUE(AllModelsMatchVerifier());
 436
 437   std::string title = IndexedFolderName(1);
 438   const BookmarkNode* folder = AddFolder(0, title);
 439   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 440   ASSERT_TRUE(AllModelsMatchVerifier());
 441
 442   std::string new_title = IndexedFolderName(2);
 443   SetTitle(0, folder, new_title);
 444   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 445   ASSERT_TRUE(AllModelsMatchVerifier());
 446 }
 447
 448 // Test Scribe ID - 371826.
 449 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 450                        SC_RenameBMFolderWithLongHierarchy) {
 451   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 452   ASSERT_TRUE(AllModelsMatchVerifier());
 453
 454   std::string title = IndexedFolderName(1);
 455   const BookmarkNode* folder = AddFolder(0, title);
 456   ASSERT_TRUE(folder != NULL);
 457   for (int i = 0; i < 120; ++i) {
 458     if (base::RandDouble() > 0.15) {
 459       std::string title = IndexedURLTitle(i);
 460       GURL url = GURL(IndexedURL(i));
 461       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 462     } else {
 463       std::string title = IndexedSubfolderName(i);
 464       ASSERT_TRUE(AddFolder(0, folder, i, title) != NULL);
 465     }
 466   }
 467   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 468   ASSERT_TRUE(AllModelsMatchVerifier());
 469
 470   std::string new_title = IndexedFolderName(2);
 471   SetTitle(0, folder, new_title);
 472   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 473   ASSERT_TRUE(AllModelsMatchVerifier());
 474 }
 475
 476 // Test Scribe ID - 371827.
 477 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 478                        SC_RenameBMFolderThatHasParentAndChildren) {
 479   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 480   ASSERT_TRUE(AllModelsMatchVerifier());
 481
 482   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 483   ASSERT_TRUE(folder != NULL);
 484   for (int i = 1; i < 15; ++i) {
 485     std::string title = IndexedURLTitle(i);
 486     GURL url = GURL(IndexedURL(i));
 487     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 488   }
 489   std::string title = IndexedSubfolderName(1);
 490   const BookmarkNode* subfolder = AddFolder(0, folder, 0, title);
 491   for (int i = 0; i < 120; ++i) {
 492     if (base::RandDouble() > 0.15) {
 493       std::string title = IndexedURLTitle(i);
 494       GURL url = GURL(IndexedURL(i));
 495       ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
 496     } else {
 497       std::string title = IndexedSubsubfolderName(i);
 498       ASSERT_TRUE(AddFolder(0, subfolder, i, title) != NULL);
 499     }
 500   }
 501   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 502   ASSERT_TRUE(AllModelsMatchVerifier());
 503
 504   std::string new_title = IndexedSubfolderName(2);
 505   SetTitle(0, subfolder, new_title);
 506   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 507   ASSERT_TRUE(AllModelsMatchVerifier());
 508 }
 509
 510 // Test Scribe ID - 371828.
 511 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMNameAndURL) {
 512   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 513   ASSERT_TRUE(AllModelsMatchVerifier());
 514
 515   GURL url = GURL(IndexedURL(1));
 516   std::string title = IndexedURLTitle(1);
 517   const BookmarkNode* bookmark = AddURL(0, title, url);
 518   ASSERT_TRUE(bookmark != NULL);
 519   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 520   ASSERT_TRUE(AllModelsMatchVerifier());
 521
 522   GURL new_url = GURL(IndexedURL(2));
 523   std::string new_title = IndexedURLTitle(2);
 524   bookmark = SetURL(0, bookmark, new_url);
 525   ASSERT_TRUE(bookmark != NULL);
 526   SetTitle(0, bookmark, new_title);
 527   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 528   ASSERT_TRUE(AllModelsMatchVerifier());
 529 }
 530
 531 // Test Scribe ID - 371832.
 532 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 533                        SC_DeleteBMEmptyAccountAfterwards) {
 534   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 535   ASSERT_TRUE(AllModelsMatchVerifier());
 536
 537   ASSERT_TRUE(AddURL(
 538       0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 539   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 540   ASSERT_TRUE(AllModelsMatchVerifier());
 541
 542   Remove(0, GetBookmarkBarNode(0), 0);
 543   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 544   ASSERT_TRUE(AllModelsMatchVerifier());
 545 }
 546
 547 // Test Scribe ID - 371833.
 548 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 549                        SC_DelBMNonEmptyAccountAfterwards) {
 550   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 551   ASSERT_TRUE(AllModelsMatchVerifier());
 552
 553   for (int i = 0; i < 20; ++i) {
 554     std::string title = IndexedURLTitle(i);
 555     GURL url = GURL(IndexedURL(i));
 556     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 557   }
 558   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 559   ASSERT_TRUE(AllModelsMatchVerifier());
 560
 561   Remove(0, GetBookmarkBarNode(0), 0);
 562   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 563   ASSERT_TRUE(AllModelsMatchVerifier());
 564 }
 565
 566 // Test Scribe ID - 371835.
 567 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 568                        SC_DelFirstBMUnderBMFoldNonEmptyFoldAfterwards) {
 569   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 570   ASSERT_TRUE(AllModelsMatchVerifier());
 571
 572   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 573   ASSERT_TRUE(folder != NULL);
 574   for (int i = 0; i < 10; ++i) {
 575     std::string title = IndexedURLTitle(i);
 576     GURL url = GURL(IndexedURL(i));
 577     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 578   }
 579   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 580   ASSERT_TRUE(AllModelsMatchVerifier());
 581
 582   Remove(0, folder, 0);
 583   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 584   ASSERT_TRUE(AllModelsMatchVerifier());
 585 }
 586
 587 // Test Scribe ID - 371836.
 588 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 589                        SC_DelLastBMUnderBMFoldNonEmptyFoldAfterwards) {
 590   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 591   ASSERT_TRUE(AllModelsMatchVerifier());
 592
 593   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 594   ASSERT_TRUE(folder != NULL);
 595   for (int i = 0; i < 10; ++i) {
 596     std::string title = IndexedURLTitle(i);
 597     GURL url = GURL(IndexedURL(i));
 598     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 599   }
 600   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 601   ASSERT_TRUE(AllModelsMatchVerifier());
 602
 603   Remove(0, folder, folder->child_count() - 1);
 604   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 605   ASSERT_TRUE(AllModelsMatchVerifier());
 606 }
 607
 608 // Test Scribe ID - 371856.
 609 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 610                        SC_DelMiddleBMUnderBMFoldNonEmptyFoldAfterwards) {
 611   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 612   ASSERT_TRUE(AllModelsMatchVerifier());
 613
 614   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 615   ASSERT_TRUE(folder != NULL);
 616   for (int i = 0; i < 10; ++i) {
 617     std::string title = IndexedURLTitle(i);
 618     GURL url = GURL(IndexedURL(i));
 619     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 620   }
 621   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 622   ASSERT_TRUE(AllModelsMatchVerifier());
 623
 624   Remove(0, folder, 4);
 625   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 626   ASSERT_TRUE(AllModelsMatchVerifier());
 627 }
 628
 629 // Test Scribe ID - 371857.
 630 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 631                        SC_DelBMsUnderBMFoldEmptyFolderAfterwards) {
 632   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 633   ASSERT_TRUE(AllModelsMatchVerifier());
 634
 635   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 636   ASSERT_TRUE(folder != NULL);
 637   for (int i = 0; i < 10; ++i) {
 638     std::string title = IndexedURLTitle(i);
 639     GURL url = GURL(IndexedURL(i));
 640     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 641   }
 642   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 643   ASSERT_TRUE(AllModelsMatchVerifier());
 644
 645   int child_count = folder->child_count();
 646   for (int i = 0; i < child_count; ++i) {
 647     Remove(0, folder, 0);
 648   }
 649   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 650   ASSERT_TRUE(AllModelsMatchVerifier());
 651 }
 652
 653 // Test Scribe ID - 371858.
 654 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 655                        SC_DelEmptyBMFoldEmptyAccountAfterwards) {
 656   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 657   ASSERT_TRUE(AllModelsMatchVerifier());
 658
 659   ASSERT_TRUE(AddFolder(0, kGenericFolderName) != NULL);
 660   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 661   ASSERT_TRUE(AllModelsMatchVerifier());
 662
 663   Remove(0, GetBookmarkBarNode(0), 0);
 664   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 665   ASSERT_TRUE(AllModelsMatchVerifier());
 666 }
 667
 668 // Test Scribe ID - 371869.
 669 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 670                        SC_DelEmptyBMFoldNonEmptyAccountAfterwards) {
 671   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 672   ASSERT_TRUE(AllModelsMatchVerifier());
 673
 674   ASSERT_TRUE(AddFolder(0, kGenericFolderName) != NULL);
 675   for (int i = 1; i < 15; ++i) {
 676     if (base::RandDouble() > 0.6) {
 677       std::string title = IndexedURLTitle(i);
 678       GURL url = GURL(IndexedURL(i));
 679       ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 680     } else {
 681       std::string title = IndexedFolderName(i);
 682       ASSERT_TRUE(AddFolder(0, i, title) != NULL);
 683     }
 684   }
 685   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 686   ASSERT_TRUE(AllModelsMatchVerifier());
 687
 688   Remove(0, GetBookmarkBarNode(0), 0);
 689   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 690   ASSERT_TRUE(AllModelsMatchVerifier());
 691 }
 692
 693 // Test Scribe ID - 371879.
 694 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 695                        SC_DelBMFoldWithBMsNonEmptyAccountAfterwards) {
 696   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 697   ASSERT_TRUE(AllModelsMatchVerifier());
 698
 699   ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 700   const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
 701   ASSERT_TRUE(folder != NULL);
 702   for (int i = 2; i < 10; ++i) {
 703     if (base::RandDouble() > 0.6) {
 704       std::string title = IndexedURLTitle(i);
 705       GURL url = GURL(IndexedURL(i));
 706       ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 707     } else {
 708       std::string title = IndexedFolderName(i);
 709       ASSERT_TRUE(AddFolder(0, i, title) != NULL);
 710     }
 711   }
 712   for (int i = 0; i < 15; ++i) {
 713     std::string title = IndexedURLTitle(i);
 714     GURL url = GURL(IndexedURL(i));
 715     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 716   }
 717   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 718   ASSERT_TRUE(AllModelsMatchVerifier());
 719
 720   Remove(0, GetBookmarkBarNode(0), 1);
 721   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 722   ASSERT_TRUE(AllModelsMatchVerifier());
 723 }
 724
 725 // Test Scribe ID - 371880.
 726 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 727                        SC_DelBMFoldWithBMsAndBMFoldsNonEmptyACAfterwards) {
 728   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 729   ASSERT_TRUE(AllModelsMatchVerifier());
 730
 731   ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 732   const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
 733   ASSERT_TRUE(folder != NULL);
 734   for (int i = 2; i < 10; ++i) {
 735     if (base::RandDouble() > 0.6) {
 736       std::string title = IndexedURLTitle(i);
 737       GURL url = GURL(IndexedURL(i));
 738       ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 739     } else {
 740       std::string title = IndexedFolderName(i);
 741       ASSERT_TRUE(AddFolder(0, i, title) != NULL);
 742     }
 743   }
 744   for (int i = 0; i < 10; ++i) {
 745     if (base::RandDouble() > 0.6) {
 746       std::string title = IndexedURLTitle(i);
 747       GURL url = GURL(IndexedURL(i));
 748       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 749     } else {
 750       std::string title = IndexedSubfolderName(i);
 751       const BookmarkNode* subfolder =
 752           AddFolder(0, folder, i, title);
 753       ASSERT_TRUE(subfolder != NULL);
 754       if (base::RandDouble() > 0.3) {
 755         for (int j = 0; j < 10; ++j) {
 756           if (base::RandDouble() > 0.6) {
 757             std::string title = IndexedURLTitle(j);
 758             GURL url = GURL(IndexedURL(j));
 759             ASSERT_TRUE(AddURL(
 760                 0, subfolder, j, title, url) != NULL);
 761           } else {
 762             std::string title = IndexedSubsubfolderName(j);
 763             ASSERT_TRUE(AddFolder(
 764                 0, subfolder, j, title) != NULL);
 765           }
 766         }
 767       }
 768     }
 769   }
 770   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 771   ASSERT_TRUE(AllModelsMatchVerifier());
 772
 773   Remove(0, GetBookmarkBarNode(0), 1);
 774   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 775   ASSERT_TRUE(AllModelsMatchVerifier());
 776 }
 777
 778 // Test Scribe ID - 371882.
 779 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 780                        SC_DelBMFoldWithParentAndChildrenBMsAndBMFolds) {
 781   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 782   ASSERT_TRUE(AllModelsMatchVerifier());
 783
 784   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 785   ASSERT_TRUE(folder != NULL);
 786   for (int i = 1; i < 11; ++i) {
 787     std::string title = IndexedURLTitle(i);
 788     GURL url = GURL(IndexedURL(i));
 789     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 790   }
 791   const BookmarkNode* subfolder =
 792       AddFolder(0, folder, 0, kGenericSubfolderName);
 793   ASSERT_TRUE(subfolder != NULL);
 794   for (int i = 0; i < 30; ++i) {
 795     if (base::RandDouble() > 0.2) {
 796       std::string title = IndexedURLTitle(i);
 797       GURL url = GURL(IndexedURL(i));
 798       ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
 799     } else {
 800       std::string title = IndexedSubsubfolderName(i);
 801       ASSERT_TRUE(AddFolder(0, subfolder, i, title) != NULL);
 802     }
 803   }
 804   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 805   ASSERT_TRUE(AllModelsMatchVerifier());
 806
 807   Remove(0, folder, 0);
 808   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 809   ASSERT_TRUE(AllModelsMatchVerifier());
 810 }
 811
 812 // Test Scribe ID - 371931.
 813 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 814                        SC_ReverseTheOrderOfTwoBMs) {
 815   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 816   ASSERT_TRUE(AllModelsMatchVerifier());
 817
 818   GURL url0 = GURL(IndexedURL(0));
 819   GURL url1 = GURL(IndexedURL(1));
 820   std::string title0 = IndexedURLTitle(0);
 821   std::string title1 = IndexedURLTitle(1);
 822   const BookmarkNode* bookmark0 = AddURL(0, 0, title0, url0);
 823   const BookmarkNode* bookmark1 = AddURL(0, 1, title1, url1);
 824   ASSERT_TRUE(bookmark0 != NULL);
 825   ASSERT_TRUE(bookmark1 != NULL);
 826   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 827   ASSERT_TRUE(AllModelsMatchVerifier());
 828
 829   Move(0, bookmark0, GetBookmarkBarNode(0), 2);
 830   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 831   ASSERT_TRUE(AllModelsMatchVerifier());
 832 }
 833
 834 // Test Scribe ID - 371933.
 835 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_ReverseTheOrderOf10BMs) {
 836   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 837   ASSERT_TRUE(AllModelsMatchVerifier());
 838
 839   for (int i = 0; i < 10; ++i) {
 840     std::string title = IndexedURLTitle(i);
 841     GURL url = GURL(IndexedURL(i));
 842     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 843   }
 844   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 845   ASSERT_TRUE(AllModelsMatchVerifier());
 846
 847   ReverseChildOrder(0, GetBookmarkBarNode(0));
 848   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 849   ASSERT_TRUE(AllModelsMatchVerifier());
 850 }
 851
 852 // Test Scribe ID - 371954.
 853 // flaky on Windows: http://crbug.com/412169
 854 #if defined(OS_WIN)
 855 #define MAYBE_SC_MovingBMsFromBMBarToBMFolder DISABLED_SC_MovingBMsFromBMBarToBMFolder
 856 #else
 857 #define MAYBE_SC_MovingBMsFromBMBarToBMFolder SC_MovingBMsFromBMBarToBMFolder
 858 #endif
 859 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 860                        MAYBE_SC_MovingBMsFromBMBarToBMFolder) {
 861   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 862   ASSERT_TRUE(AllModelsMatchVerifier());
 863
 864   ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 865   const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
 866   ASSERT_TRUE(folder != NULL);
 867   for (int i = 2; i < 10; ++i) {
 868     std::string title = IndexedURLTitle(i);
 869     GURL url = GURL(IndexedURL(i));
 870     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
 871   }
 872   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 873   ASSERT_TRUE(AllModelsMatchVerifier());
 874
 875   int num_bookmarks_to_move =
 876       GetBookmarkBarNode(0)->child_count() - 2;
 877   for (int i = 0; i < num_bookmarks_to_move; ++i) {
 878     Move(
 879         0, GetBookmarkBarNode(0)->GetChild(2), folder, i);
 880     ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 881     ASSERT_TRUE(AllModelsMatchVerifier());
 882   }
 883 }
 884
 885 // Test Scribe ID - 371957.
 886 // flaky on Windows: http://crbug.com/412169
 887 #if defined(OS_WIN)
 888 #define MAYBE_SC_MovingBMsFromBMFoldToBMBar DISABLED_SC_MovingBMsFromBMFoldToBMBar
 889 #else
 890 #define MAYBE_SC_MovingBMsFromBMFoldToBMBar SC_MovingBMsFromBMFoldToBMBar
 891 #endif
 892 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 893                        MAYBE_SC_MovingBMsFromBMFoldToBMBar) {
 894   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 895   ASSERT_TRUE(AllModelsMatchVerifier());
 896
 897   ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
 898   const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
 899   ASSERT_TRUE(folder != NULL);
 900   for (int i = 0; i < 10; ++i) {
 901     std::string title = IndexedURLTitle(i);
 902     GURL url = GURL(IndexedURL(i));
 903     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 904   }
 905   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 906   ASSERT_TRUE(AllModelsMatchVerifier());
 907
 908   int num_bookmarks_to_move = folder->child_count() - 2;
 909   for (int i = 0; i < num_bookmarks_to_move; ++i) {
 910     Move(0, folder->GetChild(0), GetBookmarkBarNode(0), i);
 911     ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 912     ASSERT_TRUE(AllModelsMatchVerifier());
 913   }
 914 }
 915
 916 // Test Scribe ID - 371961.
 917 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 918                        SC_MovingBMsFromParentBMFoldToChildBMFold) {
 919   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 920   ASSERT_TRUE(AllModelsMatchVerifier());
 921
 922   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 923   ASSERT_TRUE(folder != NULL);
 924   for (int i = 0; i < 3; ++i) {
 925     std::string title = IndexedURLTitle(i);
 926     GURL url = GURL(IndexedURL(i));
 927     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 928   }
 929   const BookmarkNode* subfolder =
 930       AddFolder(0, folder, 3, kGenericSubfolderName);
 931   ASSERT_TRUE(subfolder != NULL);
 932   for (int i = 0; i < 10; ++i) {
 933     std::string title = IndexedURLTitle(i + 3);
 934     GURL url = GURL(IndexedURL(i + 3));
 935     ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
 936   }
 937   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 938   ASSERT_TRUE(AllModelsMatchVerifier());
 939
 940   for (int i = 0; i < 3; ++i) {
 941     GURL url = GURL(IndexedURL(i));
 942     Move(0, GetUniqueNodeByURL(0, url), subfolder, i + 10);
 943   }
 944   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 945   ASSERT_TRUE(AllModelsMatchVerifier());
 946 }
 947
 948 // Test Scribe ID - 371964.
 949 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
 950                        SC_MovingBMsFromChildBMFoldToParentBMFold) {
 951   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 952   ASSERT_TRUE(AllModelsMatchVerifier());
 953
 954   const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
 955   ASSERT_TRUE(folder != NULL);
 956   for (int i = 0; i < 3; ++i) {
 957     std::string title = IndexedURLTitle(i);
 958     GURL url = GURL(IndexedURL(i));
 959     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 960   }
 961   const BookmarkNode* subfolder =
 962       AddFolder(0, folder, 3, kGenericSubfolderName);
 963   ASSERT_TRUE(subfolder != NULL);
 964   for (int i = 0; i < 5; ++i) {
 965     std::string title = IndexedURLTitle(i + 3);
 966     GURL url = GURL(IndexedURL(i + 3));
 967     ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
 968   }
 969   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 970   ASSERT_TRUE(AllModelsMatchVerifier());
 971
 972   for (int i = 0; i < 3; ++i) {
 973     GURL url = GURL(IndexedURL(i + 3));
 974     Move(0, GetUniqueNodeByURL(0, url), folder, i + 4);
 975   }
 976   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 977   ASSERT_TRUE(AllModelsMatchVerifier());
 978 }
 979
 980 // Test Scribe ID - 371967.
 981 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_HoistBMs10LevelUp) {
 982   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 983   ASSERT_TRUE(AllModelsMatchVerifier());
 984
 985   const BookmarkNode* folder = GetBookmarkBarNode(0);
 986   const BookmarkNode* folder_L0 = NULL;
 987   const BookmarkNode* folder_L10 = NULL;
 988   for (int level = 0; level < 15; ++level) {
 989     int num_bookmarks = base::RandInt(0, 9);
 990     for (int i = 0; i < num_bookmarks; ++i) {
 991       std::string title = IndexedURLTitle(i);
 992       GURL url = GURL(IndexedURL(i));
 993       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
 994     }
 995     std::string title = IndexedFolderName(level);
 996     folder = AddFolder(0, folder, folder->child_count(), title);
 997     ASSERT_TRUE(folder != NULL);
 998     if (level == 0) folder_L0 = folder;
 999     if (level == 10) folder_L10 = folder;
1000   }
1001   for (int i = 0; i < 3; ++i) {
1002     std::string title = IndexedURLTitle(i + 10);
1003     GURL url = GURL(IndexedURL(i + 10));
1004     ASSERT_TRUE(AddURL(0, folder_L10, i, title, url) != NULL);
1005   }
1006   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1007   ASSERT_TRUE(AllModelsMatchVerifier());
1008
1009   GURL url10 = GURL(IndexedURL(10));
1010   Move(0, GetUniqueNodeByURL(
1011       0, url10), folder_L0, folder_L0->child_count());
1012   GURL url11 = GURL(IndexedURL(11));
1013   Move(0, GetUniqueNodeByURL(0, url11), folder_L0, 0);
1014   GURL url12 = GURL(IndexedURL(12));
1015   Move(0, GetUniqueNodeByURL(0, url12), folder_L0, 1);
1016   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1017   ASSERT_TRUE(AllModelsMatchVerifier());
1018 }
1019
1020 // Test Scribe ID - 371968.
1021 // Flaky. http://crbug.com/107744.
1022 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_SinkBMs10LevelDown) {
1023   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1024   ASSERT_TRUE(AllModelsMatchVerifier());
1025
1026   const BookmarkNode* folder = GetBookmarkBarNode(0);
1027   const BookmarkNode* folder_L0 = NULL;
1028   const BookmarkNode* folder_L10 = NULL;
1029   for (int level = 0; level < 15; ++level) {
1030     int num_bookmarks = base::RandInt(0, 9);
1031     for (int i = 0; i < num_bookmarks; ++i) {
1032       std::string title = IndexedURLTitle(i);
1033       GURL url = GURL(IndexedURL(i));
1034       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1035     }
1036     std::string title = IndexedFolderName(level);
1037     folder = AddFolder(0, folder, folder->child_count(), title);
1038     ASSERT_TRUE(folder != NULL);
1039     if (level == 0) folder_L0 = folder;
1040     if (level == 10) folder_L10 = folder;
1041   }
1042   for (int i = 0; i < 3; ++i) {
1043     std::string title = IndexedURLTitle(i + 10);
1044     GURL url = GURL(IndexedURL(i + 10));
1045     ASSERT_TRUE(AddURL(0, folder_L0, 0, title, url) != NULL);
1046   }
1047   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1048   ASSERT_TRUE(AllModelsMatchVerifier());
1049
1050   GURL url10 = GURL(IndexedURL(10));
1051   Move(0, GetUniqueNodeByURL(0, url10), folder_L10, folder_L10->child_count());
1052   GURL url11 = GURL(IndexedURL(11));
1053   Move(0, GetUniqueNodeByURL(0, url11), folder_L10, 0);
1054   GURL url12 = GURL(IndexedURL(12));
1055   Move(0, GetUniqueNodeByURL(0, url12), folder_L10, 1);
1056   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1057   ASSERT_TRUE(AllModelsMatchVerifier());
1058 }
1059
1060 // Test Scribe ID - 371980.
1061 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1062                        SC_SinkEmptyBMFold5LevelsDown) {
1063   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1064   ASSERT_TRUE(AllModelsMatchVerifier());
1065
1066   const BookmarkNode* folder = GetBookmarkBarNode(0);
1067   const BookmarkNode* folder_L5 = NULL;
1068   for (int level = 0; level < 15; ++level) {
1069     int num_bookmarks = base::RandInt(0, 9);
1070     for (int i = 0; i < num_bookmarks; ++i) {
1071       std::string title = IndexedURLTitle(i);
1072       GURL url = GURL(IndexedURL(i));
1073       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1074     }
1075     std::string title = IndexedFolderName(level);
1076     folder = AddFolder(
1077         0, folder, folder->child_count(), title);
1078     ASSERT_TRUE(folder != NULL);
1079     if (level == 5) folder_L5 = folder;
1080   }
1081   folder = AddFolder(
1082       0, GetBookmarkBarNode(0)->child_count(), kGenericFolderName);
1083   ASSERT_TRUE(folder != NULL);
1084   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1085   ASSERT_TRUE(AllModelsMatchVerifier());
1086
1087   Move(0, folder, folder_L5, folder_L5->child_count());
1088   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1089   ASSERT_TRUE(AllModelsMatchVerifier());
1090 }
1091
1092 // Test Scribe ID - 371997.
1093 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1094                        SC_SinkNonEmptyBMFold5LevelsDown) {
1095   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1096   ASSERT_TRUE(AllModelsMatchVerifier());
1097
1098   const BookmarkNode* folder = GetBookmarkBarNode(0);
1099   const BookmarkNode* folder_L5 = NULL;
1100   for (int level = 0; level < 6; ++level) {
1101     int num_bookmarks = base::RandInt(0, 9);
1102     for (int i = 0; i < num_bookmarks; ++i) {
1103       std::string title = IndexedURLTitle(i);
1104       GURL url = GURL(IndexedURL(i));
1105       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1106     }
1107     std::string title = IndexedFolderName(level);
1108     folder = AddFolder(0, folder, folder->child_count(), title);
1109     ASSERT_TRUE(folder != NULL);
1110     if (level == 5) folder_L5 = folder;
1111   }
1112   folder = AddFolder(
1113       0, GetBookmarkBarNode(0)->child_count(), kGenericFolderName);
1114   ASSERT_TRUE(folder != NULL);
1115   for (int i = 0; i < 10; ++i) {
1116     std::string title = IndexedURLTitle(i);
1117     GURL url = GURL(IndexedURL(i));
1118     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1119   }
1120   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1121   ASSERT_TRUE(AllModelsMatchVerifier());
1122
1123   Move(0, folder, folder_L5, folder_L5->child_count());
1124   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1125   ASSERT_TRUE(AllModelsMatchVerifier());
1126 }
1127
1128 // Test Scribe ID - 372006.
1129 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1130                        SC_HoistFolder5LevelsUp) {
1131   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1132   ASSERT_TRUE(AllModelsMatchVerifier());
1133
1134   const BookmarkNode* folder = GetBookmarkBarNode(0);
1135   const BookmarkNode* folder_L5 = NULL;
1136   for (int level = 0; level < 6; ++level) {
1137     int num_bookmarks = base::RandInt(0, 9);
1138     for (int i = 0; i < num_bookmarks; ++i) {
1139       std::string title = IndexedURLTitle(i);
1140       GURL url = GURL(IndexedURL(i));
1141       ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1142     }
1143     std::string title = IndexedFolderName(level);
1144     folder = AddFolder(
1145         0, folder, folder->child_count(), title);
1146     ASSERT_TRUE(folder != NULL);
1147     if (level == 5) folder_L5 = folder;
1148   }
1149   folder = AddFolder(
1150       0, folder_L5, folder_L5->child_count(), kGenericFolderName);
1151   ASSERT_TRUE(folder != NULL);
1152   for (int i = 0; i < 10; ++i) {
1153     std::string title = IndexedURLTitle(i);
1154     GURL url = GURL(IndexedURL(i));
1155     ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1156   }
1157   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1158   ASSERT_TRUE(AllModelsMatchVerifier());
1159
1160   Move(0, folder, GetBookmarkBarNode(0), GetBookmarkBarNode(0)->child_count());
1161   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1162   ASSERT_TRUE(AllModelsMatchVerifier());
1163 }
1164
1165 // Test Scribe ID - 372026.
1166 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1167                        SC_ReverseTheOrderOfTwoBMFolders) {
1168   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1169   ASSERT_TRUE(AllModelsMatchVerifier());
1170
1171   for (int i = 0; i < 2; ++i) {
1172     std::string title = IndexedFolderName(i);
1173     const BookmarkNode* folder = AddFolder(0, i, title);
1174     ASSERT_TRUE(folder != NULL);
1175     for (int j = 0; j < 10; ++j) {
1176       std::string title = IndexedURLTitle(j);
1177       GURL url = GURL(IndexedURL(j));
1178       ASSERT_TRUE(AddURL(0, folder, j, title, url) != NULL);
1179     }
1180   }
1181   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1182   ASSERT_TRUE(AllModelsMatchVerifier());
1183
1184   ReverseChildOrder(0, GetBookmarkBarNode(0));
1185   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1186   ASSERT_TRUE(AllModelsMatchVerifier());
1187 }
1188
1189 // Test Scribe ID - 372028.
1190 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1191                        SC_ReverseTheOrderOfTenBMFolders) {
1192   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1193   ASSERT_TRUE(AllModelsMatchVerifier());
1194
1195   for (int i = 0; i < 10; ++i) {
1196     std::string title = IndexedFolderName(i);
1197     const BookmarkNode* folder = AddFolder(0, i, title);
1198     ASSERT_TRUE(folder != NULL);
1199     for (int j = 0; j < 10; ++j) {
1200       std::string title = IndexedURLTitle(1000 * i + j);
1201       GURL url = GURL(IndexedURL(j));
1202       ASSERT_TRUE(AddURL(0, folder, j, title, url) != NULL);
1203     }
1204   }
1205   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1206   ASSERT_TRUE(AllModelsMatchVerifier());
1207
1208   ReverseChildOrder(0, GetBookmarkBarNode(0));
1209   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1210   ASSERT_TRUE(AllModelsMatchVerifier());
1211 }
1212
1213 // Test Scribe ID - 373379.
1214 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1215                        MC_BiDirectionalPushAddingBM) {
1216   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1217   ASSERT_TRUE(AllModelsMatchVerifier());
1218
1219   DisableVerifier();
1220   for (int i = 0; i < 2; ++i) {
1221     std::string title0 = IndexedURLTitle(2*i);
1222     GURL url0 = GURL(IndexedURL(2*i));
1223     ASSERT_TRUE(AddURL(0, title0, url0) != NULL);
1224     std::string title1 = IndexedURLTitle(2*i+1);
1225     GURL url1 = GURL(IndexedURL(2*i+1));
1226     ASSERT_TRUE(AddURL(1, title1, url1) != NULL);
1227   }
1228   ASSERT_TRUE(AwaitQuiescence());
1229   ASSERT_TRUE(AllModelsMatch());
1230   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1231 }
1232
1233 // Test Scribe ID - 373503.
1234 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1235                        MC_BiDirectionalPush_AddingSameBMs) {
1236   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1237   ASSERT_TRUE(AllModelsMatchVerifier());
1238
1239   // Note: When a racy commit is done with identical bookmarks, it is possible
1240   // for duplicates to exist after sync completes. See http://crbug.com/19769.
1241   DisableVerifier();
1242   for (int i = 0; i < 2; ++i) {
1243     std::string title = IndexedURLTitle(i);
1244     GURL url = GURL(IndexedURL(i));
1245     ASSERT_TRUE(AddURL(0, title, url) != NULL);
1246     ASSERT_TRUE(AddURL(1, title, url) != NULL);
1247   }
1248   ASSERT_TRUE(AwaitQuiescence());
1249   ASSERT_TRUE(AllModelsMatch());
1250 }
1251
1252 // Test Scribe ID - 373506.
1253 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1254                        MC_BootStrapEmptyStateEverywhere) {
1255   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1256   ASSERT_TRUE(AwaitQuiescence());
1257   ASSERT_TRUE(AllModelsMatchVerifier());
1258 }
1259
1260 // Test Scribe ID - 373505.
1261 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1262                        MC_Merge_CaseInsensitivity_InNames) {
1263   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1264   DisableVerifier();
1265
1266   const BookmarkNode* folder0 = AddFolder(0, "Folder");
1267   ASSERT_TRUE(folder0 != NULL);
1268   ASSERT_TRUE(AddURL(0, folder0, 0, "Bookmark 0", GURL(kGenericURL)) != NULL);
1269   ASSERT_TRUE(AddURL(0, folder0, 1, "Bookmark 1", GURL(kGenericURL)) != NULL);
1270   ASSERT_TRUE(AddURL(0, folder0, 2, "Bookmark 2", GURL(kGenericURL)) != NULL);
1271
1272   const BookmarkNode* folder1 = AddFolder(1, "fOlDeR");
1273   ASSERT_TRUE(folder1 != NULL);
1274   ASSERT_TRUE(AddURL(1, folder1, 0, "bOoKmArK 0", GURL(kGenericURL)) != NULL);
1275   ASSERT_TRUE(AddURL(1, folder1, 1, "BooKMarK 1", GURL(kGenericURL)) != NULL);
1276   ASSERT_TRUE(AddURL(1, folder1, 2, "bOOKMARK 2", GURL(kGenericURL)) != NULL);
1277
1278   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1279   ASSERT_TRUE(AwaitQuiescence());
1280   ASSERT_TRUE(AllModelsMatch());
1281   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1282 }
1283
1284 // Test Scribe ID - 373508.
1285 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1286                        MC_SimpleMergeOfDifferentBMModels) {
1287   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1288   DisableVerifier();
1289
1290   for (int i = 0; i < 3; ++i) {
1291     std::string title = IndexedURLTitle(i);
1292     GURL url = GURL(IndexedURL(i));
1293     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1294     ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1295   }
1296
1297   for (int i = 3; i < 10; ++i) {
1298     std::string title0 = IndexedURLTitle(i);
1299     GURL url0 = GURL(IndexedURL(i));
1300     ASSERT_TRUE(AddURL(0, i, title0, url0) != NULL);
1301     std::string title1 = IndexedURLTitle(i+7);
1302     GURL url1 = GURL(IndexedURL(i+7));
1303     ASSERT_TRUE(AddURL(1, i, title1, url1) != NULL);
1304   }
1305
1306   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1307   ASSERT_TRUE(AwaitQuiescence());
1308   ASSERT_TRUE(AllModelsMatch());
1309   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1310 }
1311
1312 // Test Scribe ID - 386586.
1313 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1314                        MC_MergeSimpleBMHierarchyUnderBMBar) {
1315   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1316   DisableVerifier();
1317
1318   for (int i = 0; i < 3; ++i) {
1319     std::string title = IndexedURLTitle(i);
1320     GURL url = GURL(IndexedURL(i));
1321     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1322     ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1323   }
1324
1325   for (int i = 3; i < 10; ++i) {
1326     std::string title = IndexedURLTitle(i);
1327     GURL url = GURL(IndexedURL(i));
1328     ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1329   }
1330
1331   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1332   ASSERT_TRUE(AwaitQuiescence());
1333   ASSERT_TRUE(AllModelsMatch());
1334   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1335 }
1336
1337 // Test Scribe ID - 386589.
1338 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1339                        MC_MergeSimpleBMHierarchyEqualSetsUnderBMBar) {
1340   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1341   DisableVerifier();
1342
1343   for (int i = 0; i < 3; ++i) {
1344     std::string title = IndexedURLTitle(i);
1345     GURL url = GURL(IndexedURL(i));
1346     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1347     ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1348   }
1349
1350   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1351   ASSERT_TRUE(AwaitQuiescence());
1352   ASSERT_TRUE(AllModelsMatch());
1353   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1354 }
1355
1356 // Test Scribe ID - 373504 - Merge bookmark folders with different bookmarks.
1357 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1358                        MC_MergeBMFoldersWithDifferentBMs) {
1359   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1360   DisableVerifier();
1361
1362   const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1363   ASSERT_TRUE(folder0 != NULL);
1364   const BookmarkNode* folder1 = AddFolder(1, kGenericFolderName);
1365   ASSERT_TRUE(folder1 != NULL);
1366   for (int i = 0; i < 2; ++i) {
1367     std::string title0 = IndexedURLTitle(2*i);
1368     GURL url0 = GURL(IndexedURL(2*i));
1369     ASSERT_TRUE(AddURL(0, folder0, i, title0, url0) != NULL);
1370     std::string title1 = IndexedURLTitle(2*i+1);
1371     GURL url1 = GURL(IndexedURL(2*i+1));
1372     ASSERT_TRUE(AddURL(1, folder1, i, title1, url1) != NULL);
1373   }
1374   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1375   ASSERT_TRUE(AwaitQuiescence());
1376   ASSERT_TRUE(AllModelsMatch());
1377   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1378 }
1379
1380 // Test Scribe ID - 373509 - Merge moderately complex bookmark models.
1381 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1382                        MC_MergeDifferentBMModelsModeratelyComplex) {
1383   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1384   DisableVerifier();
1385
1386   for (int i = 0; i < 25; ++i) {
1387     std::string title0 = IndexedURLTitle(i);
1388     GURL url0 = GURL(IndexedURL(i));
1389     ASSERT_TRUE(AddURL(0, i, title0, url0) != NULL);
1390     std::string title1 = IndexedURLTitle(i+50);
1391     GURL url1 = GURL(IndexedURL(i+50));
1392     ASSERT_TRUE(AddURL(1, i, title1, url1) != NULL);
1393   }
1394   for (int i = 25; i < 30; ++i) {
1395     std::string title0 = IndexedFolderName(i);
1396     const BookmarkNode* folder0 = AddFolder(0, i, title0);
1397     ASSERT_TRUE(folder0 != NULL);
1398     std::string title1 = IndexedFolderName(i+50);
1399     const BookmarkNode* folder1 = AddFolder(1, i, title1);
1400     ASSERT_TRUE(folder1 != NULL);
1401     for (int j = 0; j < 5; ++j) {
1402       std::string title0 = IndexedURLTitle(i+5*j);
1403       GURL url0 = GURL(IndexedURL(i+5*j));
1404       ASSERT_TRUE(AddURL(0, folder0, j, title0, url0) != NULL);
1405       std::string title1 = IndexedURLTitle(i+5*j+50);
1406       GURL url1 = GURL(IndexedURL(i+5*j+50));
1407       ASSERT_TRUE(AddURL(1, folder1, j, title1, url1) != NULL);
1408     }
1409   }
1410   for (int i = 100; i < 125; ++i) {
1411     std::string title = IndexedURLTitle(i);
1412     GURL url = GURL(IndexedURL(i));
1413     ASSERT_TRUE(AddURL(0, title, url) != NULL);
1414     ASSERT_TRUE(AddURL(1, title, url) != NULL);
1415   }
1416   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1417   ASSERT_TRUE(AwaitQuiescence());
1418   ASSERT_TRUE(AllModelsMatch());
1419   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1420 }
1421
1422 // TCM ID - 3675271 - Merge simple bookmark subset under bookmark folder.
1423 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1424                        MC_MergeSimpleBMHierarchySubsetUnderBMFolder) {
1425   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1426   DisableVerifier();
1427
1428   for (int i = 0; i < 2; ++i) {
1429     const BookmarkNode* folder = AddFolder(i, kGenericFolderName);
1430     ASSERT_TRUE(folder != NULL);
1431     for (int j = 0; j < 4; ++j) {
1432       if (base::RandDouble() < 0.5) {
1433         std::string title = IndexedURLTitle(j);
1434         GURL url = GURL(IndexedURL(j));
1435         ASSERT_TRUE(AddURL(i, folder, j, title, url) != NULL);
1436       } else {
1437         std::string title = IndexedFolderName(j);
1438         ASSERT_TRUE(AddFolder(i, folder, j, title) != NULL);
1439       }
1440     }
1441   }
1442   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1443   ASSERT_TRUE(AwaitQuiescence());
1444   ASSERT_TRUE(AllModelsMatch());
1445   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1446 }
1447
1448 // TCM ID - 3727284 - Merge subsets of bookmark under bookmark bar.
1449 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1450                        MC_MergeSimpleBMHierarchySubsetUnderBookmarkBar) {
1451   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1452   DisableVerifier();
1453
1454   for (int i = 0; i < 4; ++i) {
1455     std::string title = IndexedURLTitle(i);
1456     GURL url = GURL(IndexedURL(i));
1457     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1458   }
1459
1460   for (int j = 0; j < 2; ++j) {
1461     std::string title = IndexedURLTitle(j);
1462     GURL url = GURL(IndexedURL(j));
1463     ASSERT_TRUE(AddURL(1, j, title, url) != NULL);
1464   }
1465
1466   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1467   ASSERT_TRUE(AwaitQuiescence());
1468   ASSERT_TRUE(AllModelsMatch());
1469   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1470   ASSERT_FALSE(ContainsDuplicateBookmarks(1));
1471 }
1472
1473 // TCM ID - 3659294 - Merge simple bookmark hierarchy under bookmark folder.
1474 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1475                        MC_Merge_SimpleBMHierarchy_Under_BMFolder) {
1476   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1477   DisableVerifier();
1478
1479   const BookmarkNode* folder0 = AddFolder(0, 0, kGenericFolderName);
1480   ASSERT_TRUE(folder0 != NULL);
1481   ASSERT_TRUE(AddURL(
1482       0, folder0, 0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1483   ASSERT_TRUE(AddFolder(0, folder0, 1, IndexedSubfolderName(2)) != NULL);
1484   ASSERT_TRUE(AddURL(
1485       0, folder0, 2, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1486   ASSERT_TRUE(AddFolder(0, folder0, 3, IndexedSubfolderName(4)) != NULL);
1487
1488   const BookmarkNode* folder1 = AddFolder(1, 0, kGenericFolderName);
1489   ASSERT_TRUE(folder1 != NULL);
1490   ASSERT_TRUE(AddFolder(1, folder1, 0, IndexedSubfolderName(0)) != NULL);
1491   ASSERT_TRUE(AddFolder(1, folder1, 1, IndexedSubfolderName(2)) != NULL);
1492   ASSERT_TRUE(AddURL(
1493       1, folder1, 2, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1494   ASSERT_TRUE(AddFolder(1, folder1, 3, IndexedSubfolderName(5)) != NULL);
1495   ASSERT_TRUE(AddURL(
1496       1, folder1, 4, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1497
1498   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1499   ASSERT_TRUE(AwaitQuiescence());
1500   ASSERT_TRUE(AllModelsMatch());
1501   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1502 }
1503
1504 // TCM ID - 3711273 - Merge disjoint sets of bookmark hierarchy under bookmark
1505 // folder.
1506 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1507                        MC_Merge_SimpleBMHierarchy_DisjointSets_Under_BMFolder) {
1508   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1509   DisableVerifier();
1510
1511   const BookmarkNode* folder0 =
1512       AddFolder(0, 0, kGenericFolderName);
1513   ASSERT_TRUE(folder0 != NULL);
1514   ASSERT_TRUE(AddURL(
1515       0, folder0, 0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1516   ASSERT_TRUE(AddFolder(0, folder0, 1, IndexedSubfolderName(2)) != NULL);
1517   ASSERT_TRUE(AddURL(
1518       0, folder0, 2, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1519   ASSERT_TRUE(AddFolder(0, folder0, 3, IndexedSubfolderName(4)) != NULL);
1520
1521   const BookmarkNode* folder1 = AddFolder(1, 0, kGenericFolderName);
1522   ASSERT_TRUE(folder1 != NULL);
1523   ASSERT_TRUE(AddFolder(1, folder1, 0, IndexedSubfolderName(5)) != NULL);
1524   ASSERT_TRUE(AddFolder(1, folder1, 1, IndexedSubfolderName(6)) != NULL);
1525   ASSERT_TRUE(AddURL(
1526       1, folder1, 2, IndexedURLTitle(7), GURL(IndexedURL(7))) != NULL);
1527   ASSERT_TRUE(AddURL(
1528       1, folder1, 3, IndexedURLTitle(8), GURL(IndexedURL(8))) != NULL);
1529
1530   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1531   ASSERT_TRUE(AwaitQuiescence());
1532   ASSERT_TRUE(AllModelsMatch());
1533   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1534 }
1535
1536 // TCM ID - 3639296 - Merge disjoint sets of bookmark hierarchy under bookmark
1537 // bar.
1538 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1539     MC_Merge_SimpleBMHierarchy_DisjointSets_Under_BookmarkBar) {
1540   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1541   DisableVerifier();
1542
1543   for (int i = 0; i < 3; ++i) {
1544     std::string title = IndexedURLTitle(i+1);
1545     GURL url = GURL(IndexedURL(i+1));
1546     ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1547   }
1548
1549   for (int j = 0; j < 3; ++j) {
1550     std::string title = IndexedURLTitle(j+4);
1551     GURL url = GURL(IndexedURL(j+4));
1552     ASSERT_TRUE(AddURL(0, j, title, url) != NULL);
1553   }
1554
1555   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1556   ASSERT_TRUE(AwaitQuiescence());
1557   ASSERT_TRUE(AllModelsMatch());
1558   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1559 }
1560
1561 // TCM ID - 3616282 - Merge sets of duplicate bookmarks under bookmark bar.
1562 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1563                        MC_Merge_SimpleBMHierarchy_DuplicateBMs_Under_BMBar) {
1564   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1565   DisableVerifier();
1566
1567   // Let's add duplicate set of bookmark {1,2,2,3,3,3,4,4,4,4} to client0.
1568   int node_index = 0;
1569   for (int i = 1; i < 5 ; ++i) {
1570     for (int j = 0; j < i; ++j) {
1571       std::string title = IndexedURLTitle(i);
1572       GURL url = GURL(IndexedURL(i));
1573       ASSERT_TRUE(AddURL(0, node_index, title, url) != NULL);
1574       ++node_index;
1575     }
1576   }
1577   // Let's add a set of bookmarks {1,2,3,4} to client1.
1578   for (int i = 0; i < 4; ++i) {
1579     std::string title = IndexedURLTitle(i+1);
1580     GURL url = GURL(IndexedURL(i+1));
1581     ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1582   }
1583
1584   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1585   ASSERT_TRUE(AwaitQuiescence());
1586   ASSERT_TRUE(AllModelsMatch());
1587
1588   for (int i = 1; i < 5 ; ++i) {
1589     ASSERT_TRUE(CountBookmarksWithTitlesMatching(1, IndexedURLTitle(i)) == i);
1590   }
1591 }
1592
1593 // TCM ID - 6593872.
1594 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, DisableBookmarks) {
1595   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1596   ASSERT_TRUE(AllModelsMatchVerifier());
1597
1598   ASSERT_TRUE(GetClient(1)->DisableSyncForDatatype(syncer::BOOKMARKS));
1599   ASSERT_TRUE(AddFolder(1, kGenericFolderName) != NULL);
1600   ASSERT_TRUE(AwaitQuiescence());
1601   ASSERT_FALSE(AllModelsMatch());
1602
1603   ASSERT_TRUE(GetClient(1)->EnableSyncForDatatype(syncer::BOOKMARKS));
1604   ASSERT_TRUE(AwaitQuiescence());
1605   ASSERT_TRUE(AllModelsMatch());
1606 }
1607
1608 // TCM ID - 7343544.
1609 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, DisableSync) {
1610   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1611   ASSERT_TRUE(AllModelsMatchVerifier());
1612
1613   ASSERT_TRUE(GetClient(1)->DisableSyncForAllDatatypes());
1614   ASSERT_TRUE(AddFolder(0, IndexedFolderName(0)) != NULL);
1615   ASSERT_TRUE(AwaitCommitActivityCompletion(GetSyncService((0))));
1616   ASSERT_FALSE(AllModelsMatch());
1617
1618   ASSERT_TRUE(AddFolder(1, IndexedFolderName(1)) != NULL);
1619   ASSERT_FALSE(AllModelsMatch());
1620
1621   ASSERT_TRUE(GetClient(1)->EnableSyncForAllDatatypes());
1622   ASSERT_TRUE(AwaitQuiescence());
1623   ASSERT_TRUE(AllModelsMatch());
1624 }
1625
1626 // TCM ID - 3662298 - Test adding duplicate folder - Both with different BMs
1627 // underneath.
1628 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, MC_DuplicateFolders) {
1629   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1630   DisableVerifier();
1631
1632   const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1633   ASSERT_TRUE(folder0 != NULL);
1634   const BookmarkNode* folder1 = AddFolder(1, kGenericFolderName);
1635   ASSERT_TRUE(folder1 != NULL);
1636   for (int i = 0; i < 5; ++i) {
1637     std::string title0 = IndexedURLTitle(i);
1638     GURL url0 = GURL(IndexedURL(i));
1639     ASSERT_TRUE(AddURL(0, folder0, i, title0, url0) != NULL);
1640     std::string title1 = IndexedURLTitle(i+5);
1641     GURL url1 = GURL(IndexedURL(i+5));
1642     ASSERT_TRUE(AddURL(1, folder1, i, title1, url1) != NULL);
1643   }
1644
1645   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1646   ASSERT_TRUE(AwaitQuiescence());
1647   ASSERT_TRUE(AllModelsMatch());
1648   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1649 }
1650
1651 // This test fails when run with FakeServer and FakeServerInvalidationService.
1652 IN_PROC_BROWSER_TEST_F(LegacyTwoClientBookmarksSyncTest, MC_DeleteBookmark) {
1653   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1654   ASSERT_TRUE(GetClient(1)->DisableSyncForDatatype(syncer::BOOKMARKS));
1655
1656   const GURL bar_url("http://example.com/bar");
1657   const GURL other_url("http://example.com/other");
1658
1659   ASSERT_TRUE(AddURL(0, GetBookmarkBarNode(0), 0, "bar", bar_url) != NULL);
1660   ASSERT_TRUE(AddURL(0, GetOtherNode(0), 0, "other", other_url) != NULL);
1661
1662   ASSERT_TRUE(AwaitCommitActivityCompletion(GetSyncService((0))));
1663
1664   ASSERT_TRUE(HasNodeWithURL(0, bar_url));
1665   ASSERT_TRUE(HasNodeWithURL(0, other_url));
1666   ASSERT_FALSE(HasNodeWithURL(1, bar_url));
1667   ASSERT_FALSE(HasNodeWithURL(1, other_url));
1668
1669   Remove(0, GetBookmarkBarNode(0), 0);
1670   ASSERT_TRUE(AwaitCommitActivityCompletion(GetSyncService((0))));
1671
1672   ASSERT_FALSE(HasNodeWithURL(0, bar_url));
1673   ASSERT_TRUE(HasNodeWithURL(0, other_url));
1674
1675   ASSERT_TRUE(GetClient(1)->EnableSyncForDatatype(syncer::BOOKMARKS));
1676   ASSERT_TRUE(AwaitQuiescence());
1677
1678   ASSERT_FALSE(HasNodeWithURL(0, bar_url));
1679   ASSERT_TRUE(HasNodeWithURL(0, other_url));
1680   ASSERT_FALSE(HasNodeWithURL(1, bar_url));
1681   ASSERT_TRUE(HasNodeWithURL(1, other_url));
1682 }
1683
1684 // TCM ID - 3719307 - Test a scenario of updating the name of the same bookmark
1685 // from two clients at the same time.
1686 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1687                        MC_BookmarkNameChangeConflict) {
1688   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1689
1690   const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1691   ASSERT_TRUE(folder0 != NULL);
1692   for (int i = 0; i < 3; ++i) {
1693     std::string title = IndexedURLTitle(i);
1694     GURL url = GURL(IndexedURL(i));
1695     ASSERT_TRUE(AddURL(0, folder0, i, title, url) != NULL);
1696   }
1697   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1698   ASSERT_TRUE(AllModelsMatchVerifier());
1699   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1700
1701   DisableVerifier();
1702   GURL url(IndexedURL(0));
1703   SetTitle(0, GetUniqueNodeByURL(0, url), "Title++");
1704   SetTitle(1, GetUniqueNodeByURL(1, url), "Title--");
1705
1706   ASSERT_TRUE(AwaitQuiescence());
1707   ASSERT_TRUE(AllModelsMatch());
1708   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1709 }
1710
1711 // TCM ID - 3672299 - Test a scenario of updating the URL of the same bookmark
1712 // from two clients at the same time.
1713 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1714                        MC_BookmarkURLChangeConflict) {
1715   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1716
1717   const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1718   ASSERT_TRUE(folder0 != NULL);
1719   for (int i = 0; i < 3; ++i) {
1720     std::string title = IndexedURLTitle(i);
1721     GURL url = GURL(IndexedURL(i));
1722     ASSERT_TRUE(AddURL(0, folder0, i, title, url) != NULL);
1723   }
1724   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1725   ASSERT_TRUE(AllModelsMatchVerifier());
1726   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1727
1728   DisableVerifier();
1729   GURL url(IndexedURL(0));
1730   ASSERT_TRUE(SetURL(
1731       0, GetUniqueNodeByURL(0, url), GURL("http://www.google.com/00")));
1732   ASSERT_TRUE(SetURL(
1733       1, GetUniqueNodeByURL(1, url), GURL("http://www.google.com/11")));
1734
1735   ASSERT_TRUE(AwaitQuiescence());
1736   ASSERT_TRUE(AllModelsMatch());
1737   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1738 }
1739
1740 // TCM ID - 3699290 - Test a scenario of updating the BM Folder name from two
1741 // clients at the same time.
1742 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1743                        MC_FolderNameChangeConflict) {
1744   ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1745   DisableVerifier();
1746
1747   const BookmarkNode* folderA[2];
1748   const BookmarkNode* folderB[2];
1749   const BookmarkNode* folderC[2];
1750
1751   // Create empty folder A on both clients.
1752   folderA[0] = AddFolder(0, IndexedFolderName(0));
1753   ASSERT_TRUE(folderA[0] != NULL);
1754   folderA[1] = AddFolder(1, IndexedFolderName(0));
1755   ASSERT_TRUE(folderA[1] != NULL);
1756
1757   // Create folder B with bookmarks on both clients.
1758   folderB[0] = AddFolder(0, IndexedFolderName(1));
1759   ASSERT_TRUE(folderB[0] != NULL);
1760   folderB[1] = AddFolder(1, IndexedFolderName(1));
1761   ASSERT_TRUE(folderB[1] != NULL);
1762   for (int i = 0; i < 3; ++i) {
1763     std::string title = IndexedURLTitle(i);
1764     GURL url = GURL(IndexedURL(i));
1765     ASSERT_TRUE(AddURL(0, folderB[0], i, title, url) != NULL);
1766   }
1767
1768   // Create folder C with bookmarks and subfolders on both clients.
1769   folderC[0] = AddFolder(0, IndexedFolderName(2));
1770   ASSERT_TRUE(folderC[0] != NULL);
1771   folderC[1] = AddFolder(1, IndexedFolderName(2));
1772   ASSERT_TRUE(folderC[1] != NULL);
1773   for (int i = 0; i < 3; ++i) {
1774     std::string folder_name = IndexedSubfolderName(i);
1775     const BookmarkNode* subfolder = AddFolder(0, folderC[0], i, folder_name);
1776     ASSERT_TRUE(subfolder != NULL);
1777     for (int j = 0; j < 3; ++j) {
1778       std::string title = IndexedURLTitle(j);
1779       GURL url = GURL(IndexedURL(j));
1780       ASSERT_TRUE(AddURL(0, subfolder, j, title, url) != NULL);
1781     }
1782   }
1783
1784   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1785   ASSERT_TRUE(AwaitQuiescence());
1786   ASSERT_TRUE(AllModelsMatch());
1787   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1788
1789   // Simultaneously rename folder A on both clients.
1790   SetTitle(0, folderA[0], "Folder A++");
1791   SetTitle(1, folderA[1], "Folder A--");
1792   ASSERT_TRUE(AwaitQuiescence());
1793   ASSERT_TRUE(AllModelsMatch());
1794   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1795
1796   // Simultaneously rename folder B on both clients.
1797   SetTitle(0, folderB[0], "Folder B++");
1798   SetTitle(1, folderB[1], "Folder B--");
1799   ASSERT_TRUE(AwaitQuiescence());
1800   ASSERT_TRUE(AllModelsMatch());
1801   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1802
1803   // Simultaneously rename folder C on both clients.
1804   SetTitle(0, folderC[0], "Folder C++");
1805   SetTitle(1, folderC[1], "Folder C--");
1806   ASSERT_TRUE(AwaitQuiescence());
1807   ASSERT_TRUE(AllModelsMatch());
1808   ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1809 }
1810
1811 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1812                        SingleClientEnabledEncryption) {
1813   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1814   ASSERT_TRUE(AllModelsMatchVerifier());
1815
1816   ASSERT_TRUE(EnableEncryption(0));
1817   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1818   ASSERT_TRUE(IsEncryptionComplete(0));
1819   ASSERT_TRUE(IsEncryptionComplete(1));
1820   ASSERT_TRUE(AllModelsMatchVerifier());
1821 }
1822
1823 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1824                        SingleClientEnabledEncryptionAndChanged) {
1825   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1826   ASSERT_TRUE(AllModelsMatchVerifier());
1827
1828   ASSERT_TRUE(EnableEncryption(0));
1829   ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1830   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1831   ASSERT_TRUE(IsEncryptionComplete(0));
1832   ASSERT_TRUE(IsEncryptionComplete(1));
1833   ASSERT_TRUE(AllModelsMatchVerifier());
1834 }
1835
1836 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1837                        BothClientsEnabledEncryption) {
1838   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1839   ASSERT_TRUE(AllModelsMatchVerifier());
1840
1841   ASSERT_TRUE(EnableEncryption(0));
1842   ASSERT_TRUE(EnableEncryption(1));
1843   ASSERT_TRUE(AwaitQuiescence());
1844   ASSERT_TRUE(IsEncryptionComplete(0));
1845   ASSERT_TRUE(IsEncryptionComplete(1));
1846   ASSERT_TRUE(AllModelsMatchVerifier());
1847 }
1848
1849 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1850                        SingleClientEnabledEncryptionBothChanged) {
1851   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1852   ASSERT_TRUE(AllModelsMatchVerifier());
1853
1854   ASSERT_TRUE(EnableEncryption(0));
1855   ASSERT_TRUE(AwaitQuiescence());
1856   ASSERT_TRUE(IsEncryptionComplete(0));
1857   ASSERT_TRUE(IsEncryptionComplete(1));
1858   ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1859   ASSERT_TRUE(AddURL(0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1860   ASSERT_TRUE(AwaitQuiescence());
1861   ASSERT_TRUE(AllModelsMatchVerifier());
1862   ASSERT_TRUE(IsEncryptionComplete(0));
1863   ASSERT_TRUE(IsEncryptionComplete(1));
1864 }
1865
1866 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1867                        SingleClientEnabledEncryptionAndChangedMultipleTimes) {
1868   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1869   ASSERT_TRUE(AllModelsMatchVerifier());
1870
1871   ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1872   ASSERT_TRUE(EnableEncryption(0));
1873   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1874   ASSERT_TRUE(IsEncryptionComplete(0));
1875   ASSERT_TRUE(IsEncryptionComplete(1));
1876   ASSERT_TRUE(AllModelsMatchVerifier());
1877
1878   ASSERT_TRUE(AddURL(0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1879   ASSERT_TRUE(AddFolder(0, IndexedFolderName(0)) != NULL);
1880   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1881   ASSERT_TRUE(AllModelsMatchVerifier());
1882 }
1883
1884 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1885                        FirstClientEnablesEncryptionWithPassSecondChanges) {
1886   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1887   ASSERT_TRUE(AllModelsMatchVerifier());
1888
1889   // Add initial bookmarks.
1890   ASSERT_TRUE(AddURL(0, 0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1891   ASSERT_TRUE(AddURL(0, 1, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1892   ASSERT_TRUE(AddURL(0, 2, IndexedURLTitle(2), GURL(IndexedURL(2))) != NULL);
1893   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1894   ASSERT_TRUE(AllModelsMatchVerifier());
1895
1896   // Set a passphrase and enable encryption on Client 0. Client 1 will not
1897   // understand the bookmark updates.
1898   SetEncryptionPassphrase(0, kValidPassphrase, ProfileSyncService::EXPLICIT);
1899   ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService((0))));
1900   ASSERT_TRUE(EnableEncryption(0));
1901   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1902   ASSERT_TRUE(IsEncryptionComplete(0));
1903   ASSERT_TRUE(IsEncryptionComplete(1));
1904   ASSERT_TRUE(GetSyncService((1))->IsPassphraseRequired());
1905
1906   // Client 1 adds bookmarks between the first two and between the second two.
1907   ASSERT_TRUE(AddURL(0, 1, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1908   ASSERT_TRUE(AddURL(0, 3, IndexedURLTitle(4), GURL(IndexedURL(4))) != NULL);
1909   EXPECT_FALSE(AllModelsMatchVerifier());
1910   EXPECT_FALSE(AllModelsMatch());
1911
1912   // Set the passphrase. Everything should resolve.
1913   ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService((1))));
1914   ASSERT_TRUE(SetDecryptionPassphrase(1, kValidPassphrase));
1915   ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService((1))));
1916   ASSERT_TRUE(AwaitQuiescence());
1917   EXPECT_TRUE(AllModelsMatch());
1918   ASSERT_EQ(0,
1919             GetClient(1)->GetLastSessionSnapshot().num_encryption_conflicts());
1920
1921   // Ensure everything is syncing normally by appending a final bookmark.
1922   ASSERT_TRUE(AddURL(1, 5, IndexedURLTitle(5), GURL(IndexedURL(5))) != NULL);
1923   ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
1924   EXPECT_TRUE(AllModelsMatch());
1925   ASSERT_EQ(0,
1926             GetClient(1)->GetLastSessionSnapshot().num_encryption_conflicts());
1927 }
1928
1929 // Deliberately racy rearranging of bookmarks to test that our conflict resolver
1930 // code results in a consistent view across machines (no matter what the final
1931 // order is).
1932 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, RacyPositionChanges) {
1933   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1934   ASSERT_TRUE(AllModelsMatchVerifier());
1935
1936   // Add initial bookmarks.
1937   size_t num_bookmarks = 5;
1938   for (size_t i = 0; i < num_bookmarks; ++i) {
1939     ASSERT_TRUE(AddURL(0, i, IndexedURLTitle(i), GURL(IndexedURL(i))) != NULL);
1940   }
1941
1942   // Once we make diverging changes the verifer is helpless.
1943   ASSERT_TRUE(AwaitQuiescence());
1944   ASSERT_TRUE(AllModelsMatchVerifier());
1945   DisableVerifier();
1946
1947   // Make changes on client 0.
1948   for (size_t i = 0; i < num_bookmarks; ++i) {
1949     const BookmarkNode* node = GetUniqueNodeByURL(0, GURL(IndexedURL(i)));
1950     int rand_pos = base::RandInt(0, num_bookmarks-1);
1951     DVLOG(1) << "Moving client 0's bookmark " << i << " to position "
1952              << rand_pos;
1953     Move(0, node, node->parent(), rand_pos);
1954   }
1955
1956   // Make changes on client 1.
1957   for (size_t i = 0; i < num_bookmarks; ++i) {
1958     const BookmarkNode* node = GetUniqueNodeByURL(1, GURL(IndexedURL(i)));
1959     int rand_pos = base::RandInt(0, num_bookmarks-1);
1960     DVLOG(1) << "Moving client 1's bookmark " << i << " to position "
1961              << rand_pos;
1962     Move(1, node, node->parent(), rand_pos);
1963   }
1964
1965   ASSERT_TRUE(AwaitQuiescence());
1966   ASSERT_TRUE(AllModelsMatch());
1967
1968   // Now make changes to client 1 first.
1969   for (size_t i = 0; i < num_bookmarks; ++i) {
1970     const BookmarkNode* node = GetUniqueNodeByURL(1, GURL(IndexedURL(i)));
1971     int rand_pos = base::RandInt(0, num_bookmarks-1);
1972     DVLOG(1) << "Moving client 1's bookmark " << i << " to position "
1973              << rand_pos;
1974     Move(1, node, node->parent(), rand_pos);
1975   }
1976
1977   // Make changes on client 0.
1978   for (size_t i = 0; i < num_bookmarks; ++i) {
1979     const BookmarkNode* node = GetUniqueNodeByURL(0, GURL(IndexedURL(i)));
1980     int rand_pos = base::RandInt(0, num_bookmarks-1);
1981     DVLOG(1) << "Moving client 0's bookmark " << i << " to position "
1982              << rand_pos;
1983     Move(0, node, node->parent(), rand_pos);
1984   }
1985
1986   ASSERT_TRUE(AwaitQuiescence());
1987   ASSERT_TRUE(AllModelsMatch());
1988 }
1989
1990 // Trigger the server side creation of Synced Bookmarks. Ensure both clients
1991 // remain syncing afterwards. Add bookmarks to the synced bookmarks folder
1992 // and ensure both clients receive the boomkmark.
1993 IN_PROC_BROWSER_TEST_F(LegacyTwoClientBookmarksSyncTest,
1994                        CreateSyncedBookmarks) {
1995   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1996   ASSERT_TRUE(AllModelsMatchVerifier());
1997
1998   TriggerCreateSyncedBookmarks();
1999
2000   // Add a bookmark on Client 0 and ensure it syncs over. This will also trigger
2001   // both clients downloading the new Synced Bookmarks folder.
2002   ASSERT_TRUE(AddURL(0, "Google", GURL("http://www.google.com")));
2003   ASSERT_TRUE(AwaitQuiescence());
2004   ASSERT_TRUE(AllModelsMatch());
2005
2006   // Now add a bookmark within the Synced Bookmarks folder and ensure it syncs
2007   // over.
2008   const BookmarkNode* synced_bookmarks = GetSyncedBookmarksNode(0);
2009   ASSERT_TRUE(synced_bookmarks);
2010   ASSERT_TRUE(AddURL(0, synced_bookmarks, 0, "Google2",
2011                      GURL("http://www.google2.com")));
2012   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
2013   ASSERT_TRUE(AllModelsMatch());
2014 }
2015
2016 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
2017                        BookmarkAllNodesRemovedEvent) {
2018
2019   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
2020   ASSERT_TRUE(AllModelsMatchVerifier());
2021
2022   // Starting state:
2023   // other_node
2024   //    -> folder0
2025   //      -> tier1_a
2026   //        -> http://mail.google.com
2027   //        -> http://www.google.com
2028   //      -> http://news.google.com
2029   //      -> http://yahoo.com
2030   //    -> http://www.cnn.com
2031   // bookmark_bar
2032   // -> empty_folder
2033   // -> folder1
2034   //    -> http://yahoo.com
2035   // -> http://gmail.com
2036
2037   const BookmarkNode* folder0 = AddFolder(0, GetOtherNode(0), 0, "folder0");
2038   const BookmarkNode* tier1_a = AddFolder(0, folder0, 0, "tier1_a");
2039   ASSERT_TRUE(AddURL(0, folder0, 1, "News", GURL("http://news.google.com")));
2040   ASSERT_TRUE(AddURL(0, folder0, 2, "Yahoo", GURL("http://www.yahoo.com")));
2041   ASSERT_TRUE(AddURL(0, tier1_a, 0, "Gmai", GURL("http://mail.google.com")));
2042   ASSERT_TRUE(AddURL(0, tier1_a, 1, "Google", GURL("http://www.google.com")));
2043   ASSERT_TRUE(
2044       AddURL(0, GetOtherNode(0), 1, "CNN", GURL("http://www.cnn.com")));
2045
2046   ASSERT_TRUE(AddFolder(0, GetBookmarkBarNode(0), 0, "empty_folder"));
2047   const BookmarkNode* folder1 =
2048       AddFolder(0, GetBookmarkBarNode(0), 1, "folder1");
2049   ASSERT_TRUE(AddURL(0, folder1, 0, "Yahoo", GURL("http://www.yahoo.com")));
2050   ASSERT_TRUE(
2051       AddURL(0, GetBookmarkBarNode(0), 2, "Gmai", GURL("http://gmail.com")));
2052
2053   ASSERT_TRUE(AwaitQuiescence());
2054   ASSERT_TRUE(AllModelsMatch());
2055
2056   // Remove all
2057   RemoveAll(0);
2058
2059   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
2060   // Verify other node has no children now.
2061   EXPECT_EQ(0, GetOtherNode(0)->child_count());
2062   EXPECT_EQ(0, GetBookmarkBarNode(0)->child_count());
2063   ASSERT_TRUE(AllModelsMatch());
2064 }
2065
2066 // Verifies that managed bookmarks (installed by policy) don't get synced.
2067 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, ManagedBookmarks) {
2068   // Make sure the first Profile has an overridden policy provider.
2069   EXPECT_CALL(policy_provider_, IsInitializationComplete(testing::_))
2070       .WillRepeatedly(testing::Return(true));
2071   policy::ProfilePolicyConnectorFactory::GetInstance()->PushProviderForTesting(
2072       &policy_provider_);
2073
2074   // Set up sync.
2075   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
2076   ASSERT_TRUE(AllModelsMatchVerifier());
2077
2078   // Verify that there are no managed bookmarks at startup in either profile.
2079   // The Managed Bookmarks folder should not be visible at this stage.
2080   const BookmarkNode* managed_node0 = GetManagedNode(0);
2081   ASSERT_TRUE(managed_node0->empty());
2082   ASSERT_FALSE(managed_node0->IsVisible());
2083   const BookmarkNode* managed_node1 = GetManagedNode(1);
2084   ASSERT_TRUE(managed_node1->empty());
2085   ASSERT_FALSE(managed_node1->IsVisible());
2086
2087   // Verify that the bookmark bar node is empty on both profiles too.
2088   const BookmarkNode* bar_node0 = GetBookmarkBarNode(0);
2089   ASSERT_TRUE(bar_node0->empty());
2090   ASSERT_TRUE(bar_node0->IsVisible());
2091   const BookmarkNode* bar_node1 = GetBookmarkBarNode(1);
2092   ASSERT_TRUE(bar_node1->empty());
2093   ASSERT_TRUE(bar_node1->IsVisible());
2094
2095   // Verify that adding a bookmark is observed by the second Profile.
2096   GURL google_url("http://www.google.com");
2097   ASSERT_TRUE(AddURL(0, "Google", google_url) != NULL);
2098   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
2099   ASSERT_TRUE(AllModelsMatchVerifier());
2100   ASSERT_EQ(1, bar_node0->child_count());
2101   ASSERT_EQ(1, bar_node1->child_count());
2102
2103   // Set the ManagedBookmarks policy for the first Profile,
2104   // which will add one new managed bookmark.
2105   base::DictionaryValue* bookmark = new base::DictionaryValue();
2106   bookmark->SetString("name", "Managed bookmark");
2107   bookmark->SetString("url", "youtube.com");
2108   base::ListValue* list = new base::ListValue();
2109   list->Append(bookmark);
2110   policy::PolicyMap policy;
2111   policy.Set(policy::key::kManagedBookmarks,
2112              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
2113              list, NULL);
2114   policy_provider_.UpdateChromePolicy(policy);
2115   base::RunLoop().RunUntilIdle();
2116
2117   // Now add another user bookmark and wait for it to sync.
2118   ASSERT_TRUE(AddURL(0, "Google 2", google_url) != NULL);
2119   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
2120   ASSERT_TRUE(AllModelsMatchVerifier());
2121
2122   EXPECT_FALSE(GetSyncService(0)->HasUnrecoverableError());
2123   EXPECT_FALSE(GetSyncService(1)->HasUnrecoverableError());
2124
2125   // Verify that the managed bookmark exists in the local model of the first
2126   // Profile, and has a child node.
2127   ASSERT_EQ(1, managed_node0->child_count());
2128   ASSERT_TRUE(managed_node0->IsVisible());
2129   EXPECT_EQ(GURL("http://youtube.com/"), managed_node0->GetChild(0)->url());
2130
2131   // Verify that the second Profile didn't get this node.
2132   ASSERT_EQ(0, managed_node1->child_count());
2133 }