sync: Add interfaces for per-type sync

sync/engine/directory_commit_contribution_unittest.cc

 // Copyright 2013 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 "sync/engine/sync_directory_commit_contribution.h"
+#include "sync/engine/directory_commit_contribution.h"
 
 #include "base/message_loop/message_loop.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_read_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "sync/test/engine/test_syncable_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
-class SyncDirectoryCommitContributionTest : public ::testing::Test {
+class DirectoryCommitContributionTest : public ::testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     dir_maker_.SetUp();
 
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     CreateTypeRoot(&trans, dir(), PREFERENCES);
     CreateTypeRoot(&trans, dir(), EXTENSIONS);
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 36 matching lines @@
     return dir_maker_.directory();
   }
 
   TestIdFactory id_factory_;
 
  private:
   base::MessageLoop loop_;  // Neeed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
 };
 
-// Verify that the SyncDirectoryCommitContribution contains only entries of its
+// Verify that the DirectoryCommitContribution contains only entries of its
 // specified type.
-TEST_F(SyncDirectoryCommitContributionTest, GatherByTypes) {
+TEST_F(DirectoryCommitContributionTest, GatherByTypes) {
   int64 pref1;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 5));
+  scoped_ptr<DirectoryCommitContribution> cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 5));
   ASSERT_EQ(2U, cc->GetNumEntries());
 
   const std::vector<int64>& metahandles = cc->metahandles_;
   EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
               metahandles.end());
   EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
               metahandles.end());
 
   cc->CleanUp();
 }
 
-// Verify that the SyncDirectoryCommitContributionTest builder function
+// Verify that the DirectoryCommitContributionTest builder function
 // truncates if necessary.
-TEST_F(SyncDirectoryCommitContributionTest, GatherAndTruncate) {
+TEST_F(DirectoryCommitContributionTest, GatherAndTruncate) {
   int64 pref1;
   int64 pref2;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     pref2 = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 1));
+  scoped_ptr<DirectoryCommitContribution> cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 1));
   ASSERT_EQ(1U, cc->GetNumEntries());
 
   int64 only_metahandle = cc->metahandles_[0];
   EXPECT_TRUE(only_metahandle == pref1 || only_metahandle == pref2);
 
   cc->CleanUp();
 }
 
-// Sanity check for building commits from SyncDirectoryCommitContributions.
+// Sanity check for building commits from DirectoryCommitContributions.
 // This test makes two CommitContribution objects of different types and uses
 // them to initialize a commit message.  Then it checks that the contents of the
 // commit message match those of the directory they came from.
-TEST_F(SyncDirectoryCommitContributionTest, PrepareCommit) {
+TEST_F(DirectoryCommitContributionTest, PrepareCommit) {
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> pref_cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
-  scoped_ptr<SyncDirectoryCommitContribution> ext_cc(
-      SyncDirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
+  scoped_ptr<DirectoryCommitContribution> pref_cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
+  scoped_ptr<DirectoryCommitContribution> ext_cc(
+      DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
   ext_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
 
   std::set<syncable::Id> ids_for_commit;
   ASSERT_EQ(3, commit_message.entries_size());
   for (int i = 0; i < commit_message.entries_size(); ++i) {
@@ skipping 17 matching lines @@
     }
   }
 
   pref_cc->CleanUp();
   ext_cc->CleanUp();
 }
 
 // Creates some unsynced items, pretends to commit them, and hands back a
 // specially crafted response to the syncer in order to test commit response
 // processing.  The response simulates a succesful commit scenario.
-TEST_F(SyncDirectoryCommitContributionTest, ProcessCommitResponse) {
+TEST_F(DirectoryCommitContributionTest, ProcessCommitResponse) {
   int64 pref1_handle;
   int64 pref2_handle;
   int64 ext1_handle;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
     pref1_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
     pref2_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
     ext1_handle = CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
   }
 
-  scoped_ptr<SyncDirectoryCommitContribution> pref_cc(
-      SyncDirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
-  scoped_ptr<SyncDirectoryCommitContribution> ext_cc(
-      SyncDirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
+  scoped_ptr<DirectoryCommitContribution> pref_cc(
+      DirectoryCommitContribution::Build(dir(), PREFERENCES, 25));
+  scoped_ptr<DirectoryCommitContribution> ext_cc(
+      DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25));
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
   ext_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
   ASSERT_EQ(3, commit_message.entries_size());
 
   sync_pb::ClientToServerResponse response;
   for (int i = 0; i < commit_message.entries_size(); ++i) {
@@ skipping 25 matching lines @@
     EXPECT_TRUE(e1.GetId().ServerKnows());
     EXPECT_FALSE(e1.GetSyncing());
     EXPECT_LT(0, e1.GetServerVersion());
   }
 
   pref_cc->CleanUp();
   ext_cc->CleanUp();
 }
 
 }  // namespace syncer