sync: add CleanupDisabledTypesCommand to purge data pertaining to previously...

chrome/browser/sync/engine/process_commit_response_command_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/string_util.h"
 #include "chrome/browser/sync/engine/mock_model_safe_workers.h"
 #include "chrome/browser/sync/engine/process_commit_response_command.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
@@ skipping 68 matching lines @@
   // Create an unsynced item in the database.  If item_id is a local ID, it
   // will be treated as a create-new.  Otherwise, if it's a server ID, we'll
   // fake the server data so that it looks like it exists on the server.
   // Returns the methandle of the created item in |metahandle_out| if not NULL.
   void CreateUnsyncedItem(const Id& item_id,
                           const Id& parent_id,
                           const string& name,
                           bool is_folder,
                           syncable::ModelType model_type,
                           int64* metahandle_out) {
-    ScopedDirLookup dir(syncdb().manager(), syncdb().name());
+    ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     Id predecessor_id = dir->GetLastChildId(&trans, parent_id);
     MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::ID, item_id);
     entry.Put(syncable::BASE_VERSION,
         item_id.ServerKnows() ? next_old_revision_++ : 0);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, is_folder);
@@ skipping 25 matching lines @@
     bool is_folder = true;
     int64 metahandle = 0;
     CreateUnsyncedItem(item_id, parent_id, name, is_folder, model_type,
                        &metahandle);
 
     // ProcessCommitResponseCommand consumes commit_ids from the session
     // state, so we need to update that.  O(n^2) because it's a test.
     commit_set_->AddCommitItem(metahandle, item_id, model_type);
     sync_state->set_commit_set(*commit_set_.get());
 
-    ScopedDirLookup dir(syncdb().manager(), syncdb().name());
+    ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry entry(&trans, syncable::GET_BY_ID, item_id);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::SYNCING, true);
 
     // ProcessCommitResponseCommand looks at both the commit message as well
     // as the commit response, so we need to synthesize both here.
     sync_pb::ClientToServerMessage* commit =
         sync_state->mutable_commit_message();
@@ skipping 75 matching lines @@
                                 "Pref 1", syncable::PREFERENCES);
   CreateUnprocessedCommitResult(pref_id2, id_factory_.root(),
                                 "Pref 2", syncable::PREFERENCES);
   CreateUnprocessedCommitResult(autofill_id1, id_factory_.root(),
                                 "Autofill 1", syncable::AUTOFILL);
   CreateUnprocessedCommitResult(autofill_id2, id_factory_.root(),
                                 "Autofill 2", syncable::AUTOFILL);
 
   command_.ExecuteImpl(session());
 
-  ScopedDirLookup dir(syncdb().manager(), syncdb().name());
+  ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
   ASSERT_TRUE(dir.good());
   ReadTransaction trans(dir, __FILE__, __LINE__);
   Id new_fid = dir->GetFirstChildId(&trans, id_factory_.root());
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(bookmark_folder_id.ServerKnows());
   EXPECT_FALSE(new_fid == bookmark_folder_id);
   Entry b_folder(&trans, syncable::GET_BY_ID, new_fid);
   ASSERT_TRUE(b_folder.good());
   ASSERT_EQ("A bookmark folder", b_folder.Get(NON_UNIQUE_NAME))
@@ skipping 33 matching lines @@
 // how this scenario used to fail, reversing the order for the second half
 // of the children.
 TEST_F(ProcessCommitResponseCommandTest, NewFolderCommitKeepsChildOrder) {
   // Create the parent folder, a new item whose ID will change on commit.
   Id folder_id = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(folder_id, id_factory_.root(), "A",
                                 syncable::BOOKMARKS);
 
   // Verify that the item is reachable.
   {
-    ScopedDirLookup dir(syncdb().manager(), syncdb().name());
+    ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(dir, __FILE__, __LINE__);
     ASSERT_EQ(folder_id, dir->GetFirstChildId(&trans, id_factory_.root()));
   }
 
   // The first 25 children of the parent folder will be part of the commit
   // batch.
   int batch_size = 25;
   int i = 0;
   for (; i < batch_size; ++i) {
@@ skipping 12 matching lines @@
     CreateUnsyncedItem(id, folder_id, StringPrintf("Item %d", i), false,
                        syncable::BOOKMARKS, NULL);
   }
 
   // Process the commit response for the parent folder and the first
   // 25 items.  This should apply the values indicated by
   // each CommitResponse_EntryResponse to the syncable Entries.  All new
   // items in the commit batch should have their IDs changed to server IDs.
   command_.ExecuteImpl(session());
 
-  ScopedDirLookup dir(syncdb().manager(), syncdb().name());
+  ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
   ASSERT_TRUE(dir.good());
   ReadTransaction trans(dir, __FILE__, __LINE__);
   // Lookup the parent folder by finding a child of the root.  We can't use
   // folder_id here, because it changed during the commit.
   Id new_fid = dir->GetFirstChildId(&trans, id_factory_.root());
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(folder_id.ServerKnows());
   EXPECT_TRUE(new_fid != folder_id);
   Entry parent(&trans, syncable::GET_BY_ID, new_fid);
@@ skipping 98 matching lines @@
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 
 }  // namespace browser_sync