[Sync] Move ChangeRecord into its own file (change_record.{h,cc})

chrome/browser/sync/profile_sync_service_preference_unittest.cc

 // Copyright (c) 2011 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 <map>
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/stl_util.h"
 #include "base/string_piece.h"
 #include "base/task.h"
 #include "base/tracked.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/api/sync_data.h"
 #include "chrome/browser/sync/glue/generic_change_processor.h"
 #include "chrome/browser/sync/glue/preference_data_type_controller.h"
 #include "chrome/browser/sync/glue/syncable_service_adapter.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
+#include "chrome/browser/sync/internal_api/change_record.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/read_transaction.h"
-#include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/common/json_value_serializer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONReader;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::PreferenceDataTypeController;
 using browser_sync::SyncBackendHost;
 using browser_sync::SyncableServiceAdapter;
-using sync_api::SyncManager;
+using sync_api::ChangeRecord;
 using testing::_;
 using testing::Invoke;
 using testing::Return;
 
 typedef std::map<const std::string, const Value*> PreferenceValues;
 
 ACTION_P4(BuildPrefSyncComponents, profile_sync_service, pref_sync_service,
     model_associator_ptr, change_processor_ptr) {
   sync_api::UserShare* user_share = profile_sync_service->GetUserShare();
   *change_processor_ptr = new GenericChangeProcessor(pref_sync_service,
@@ skipping 113 matching lines @@
     sync_api::WriteNode node(&trans);
 
     if (tag_node.InitByClientTagLookup(syncable::PREFERENCES, name))
       return WriteSyncedValue(name, value, &tag_node);
     if (node.InitUniqueByCreation(syncable::PREFERENCES, root, name))
       return WriteSyncedValue(name, value, &node);
 
     return sync_api::kInvalidId;
   }
 
-  SyncManager::ChangeRecord* MakeChangeRecord(int64 node_id,
-      SyncManager::ChangeRecord::Action action) {
-    SyncManager::ChangeRecord* record = new SyncManager::ChangeRecord();
-    record->action = action;
-    record->id = node_id;
-    return record;
+  sync_api::ImmutableChangeRecordList MakeSingletonChangeRecordList(

[Nicolas Zea, 2011/09/16 21:20:26]

Maybe pull this into test_profile_sync_service.h?

[akalin, 2011/09/16 21:50:36]

Moved into ProfileSyncServiceTestHelper in abstract_profile_sync_service_test.h

+      int64 node_id, ChangeRecord::Action action) {
+    ChangeRecord record;
+    record.action = action;
+    record.id = node_id;
+    sync_api::ChangeRecordList records(1, record);
+    return sync_api::ImmutableChangeRecordList(&records);
   }
 
   bool IsSynced(const std::string& pref_name) {
     return pref_sync_service_->registered_preferences().count(pref_name) > 0;
   }
 
   std::string ValueString(const Value& value) {
     std::string serialized;
     JSONStringValueSerializer json(&serialized);
     json.Serialize(value);
@@ skipping 187 matching lines @@
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionUpdate) {
   profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_);
   CreateRootTask task(this, syncable::PREFERENCES);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url1_));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *expected);
   ASSERT_NE(node_id, sync_api::kInvalidId);
-  scoped_ptr<SyncManager::ChangeRecord> record(MakeChangeRecord(
-      node_id, SyncManager::ChangeRecord::ACTION_UPDATE));
   {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
-    change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
+    change_processor_->ApplyChangesFromSyncModel(
+        &trans,
+        MakeSingletonChangeRecordList(node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionAdd) {
   CreateRootTask task(this, syncable::PREFERENCES);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *expected);
   ASSERT_NE(node_id, sync_api::kInvalidId);
-  scoped_ptr<SyncManager::ChangeRecord> record(MakeChangeRecord(
-      node_id, SyncManager::ChangeRecord::ACTION_ADD));
   {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
-    change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
+    change_processor_->ApplyChangesFromSyncModel(
+        &trans,
+        MakeSingletonChangeRecordList(node_id, ChangeRecord::ACTION_ADD));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
   EXPECT_EQ(1U,
       pref_sync_service_->registered_preferences().count(prefs::kHomePage));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeUnknownPreference) {
   CreateRootTask task(this, syncable::PREFERENCES);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
   int64 node_id = SetSyncedValue("unknown preference", *expected);
   ASSERT_NE(node_id, sync_api::kInvalidId);
-  scoped_ptr<SyncManager::ChangeRecord> record(MakeChangeRecord(
-      node_id, SyncManager::ChangeRecord::ACTION_UPDATE));
   {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
-    change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
+    change_processor_->ApplyChangesFromSyncModel(
+        &trans,
+        MakeSingletonChangeRecordList(node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   // Nothing interesting happens on the client when it gets an update
   // of an unknown preference.  We just should not crash.
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, ManagedPreferences) {
   // Make the homepage preference managed.
   scoped_ptr<Value> managed_value(
       Value::CreateStringValue("http://example.com"));
   prefs_->SetManagedPref(prefs::kHomePage, managed_value->DeepCopy());
 
   CreateRootTask task(this, syncable::PREFERENCES);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   // Changing the homepage preference should not sync anything.
   scoped_ptr<Value> user_value(
       Value::CreateStringValue("http://chromium..com"));
   prefs_->SetUserPref(prefs::kHomePage, user_value->DeepCopy());
   EXPECT_EQ(NULL, GetSyncedValue(prefs::kHomePage));
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   scoped_ptr<Value> sync_value(
       Value::CreateStringValue("http://crbug.com"));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value);
   ASSERT_NE(node_id, sync_api::kInvalidId);
-  scoped_ptr<SyncManager::ChangeRecord> record(MakeChangeRecord(
-      node_id, SyncManager::ChangeRecord::ACTION_UPDATE));
   {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
-    change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
+    change_processor_->ApplyChangesFromSyncModel(
+        &trans,
+        MakeSingletonChangeRecordList(node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   EXPECT_TRUE(managed_value->Equals(prefs_->GetManagedPref(prefs::kHomePage)));
   EXPECT_TRUE(sync_value->Equals(prefs_->GetUserPref(prefs::kHomePage)));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedPreferences) {
   CreateRootTask task(this, syncable::PREFERENCES);
   ASSERT_TRUE(StartSyncService(&task, false));
@@ skipping 37 matching lines @@
   scoped_ptr<Value> managed_value(
       Value::CreateStringValue("http://example.com/managed"));
   profile_->GetTestingPrefService()->SetManagedPref(
       prefs::kHomePage, managed_value->DeepCopy());
 
   // Change the sync value.
   scoped_ptr<Value> sync_value(
       Value::CreateStringValue("http://example.com/sync"));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value);
   ASSERT_NE(node_id, sync_api::kInvalidId);
-  scoped_ptr<SyncManager::ChangeRecord> record(MakeChangeRecord(
-      node_id, SyncManager::ChangeRecord::ACTION_ADD));
   {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
-    change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
+    change_processor_->ApplyChangesFromSyncModel(
+        &trans,
+        MakeSingletonChangeRecordList(node_id, ChangeRecord::ACTION_ADD));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   // The pref value should still be the one dictated by policy.
   EXPECT_TRUE(managed_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 
   // Switch kHomePage back to unmanaged.
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
 
   // Sync value should be picked up.
   EXPECT_TRUE(sync_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 }