[Sync] Refactored ProfileSyncService and remove its backend() function

chrome/browser/sync/profile_sync_service_preference_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 <map>
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/stl_util-inl.h"
 #include "base/string_piece.h"
@@ skipping 77 matching lines @@
     service_->RegisterDataTypeController(
         new PreferenceDataTypeController(&factory_,
                                          service_.get()));
     profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kSyncService, "token");
     service_->Initialize();
     MessageLoop::current()->Run();
     return true;
   }
 
-  SyncBackendHost* backend() { return service_->backend_.get(); }
-
   const Value& GetPreferenceValue(const std::string& name) {
     const PrefService::Preference* preference =
         prefs_->FindPreference(name.c_str());
     return *preference->GetValue();
   }
 
   // Caller gets ownership of the returned value.
   const Value* GetSyncedValue(const std::string& name) {
-    sync_api::ReadTransaction trans(service_->backend()->GetUserShareHandle());
+    sync_api::ReadTransaction trans(service_->GetUserShare());
     sync_api::ReadNode node(&trans);
 
     int64 node_id = model_associator_->GetSyncIdFromChromeId(name);
     if (node_id == sync_api::kInvalidId)
       return NULL;
     if (!node.InitByIdLookup(node_id))
       return NULL;
 
     const sync_pb::PreferenceSpecifics& specifics(
         node.GetPreferenceSpecifics());
 
     JSONReader reader;
     return reader.JsonToValue(specifics.value(), false, false);
   }
 
   int64 WriteSyncedValue(sync_api::WriteNode& node,
                          const std::string& name,
                          const Value& value) {
     if (!PreferenceModelAssociator::WritePreferenceToNode(name, value, &node))
       return sync_api::kInvalidId;
     return node.GetId();
   }
 
   int64 SetSyncedValue(const std::string& name, const Value& value) {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShare());
     sync_api::ReadNode root(&trans);
     if (!root.InitByTagLookup(browser_sync::kPreferencesTag))
       return sync_api::kInvalidId;
 
     sync_api::WriteNode tag_node(&trans);
     sync_api::WriteNode node(&trans);
 
     int64 node_id = model_associator_->GetSyncIdFromChromeId(name);
     if (node_id == sync_api::kInvalidId) {
       if (tag_node.InitByClientTagLookup(syncable::PREFERENCES, name))
@@ skipping 68 matching lines @@
 };
 
 TEST_F(ProfileSyncServicePreferenceTest, WritePreferenceToNode) {
   prefs_->SetString(prefs::kHomePage, example_url0_);
   CreateRootTask task(this, syncable::PREFERENCES);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
-  sync_api::WriteTransaction trans(service_->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(service_->GetUserShare());
   sync_api::WriteNode node(&trans);
   EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES,
                                          prefs::kHomePage));
 
   EXPECT_TRUE(PreferenceModelAssociator::WritePreferenceToNode(
       pref->name(), *pref->GetValue(), &node));
   EXPECT_EQ(UTF8ToWide(prefs::kHomePage), node.GetTitle());
   const sync_pb::PreferenceSpecifics& specifics(node.GetPreferenceSpecifics());
   EXPECT_EQ(std::string(prefs::kHomePage), specifics.name());
 
@@ skipping 122 matching lines @@
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url1_));
   ASSERT_NE(SetSyncedValue(prefs::kHomePage, *expected), sync_api::kInvalidId);
   int64 node_id = model_associator_->GetSyncIdFromChromeId(prefs::kHomePage);
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_UPDATE;
   record->id = node_id;
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
 
   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(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_ADD;
   record->id = node_id;
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
   EXPECT_EQ(node_id,
             model_associator_->GetSyncIdFromChromeId(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(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_ADD;
   record->id = node_id;
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
 
   // 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(
@@ skipping 12 matching lines @@
 
   // An incoming sync transaction shouldn't change the user 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(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_UPDATE;
   record->id = node_id;
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
   EXPECT_TRUE(managed_value->Equals(
       prefs_->GetManagedPref(prefs::kHomePage)));
   EXPECT_TRUE(user_value->Equals(
       prefs_->GetUserPref(prefs::kHomePage)));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedPreferences) {
   CreateRootTask task(this, syncable::PREFERENCES);
@@ skipping 18 matching lines @@
 
   // 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(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_ADD;
   record->id = node_id;
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
 
   // 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)));
 }