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

chrome/browser/sync/profile_sync_service_session_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/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 105 matching lines @@
     sync_service_->set_num_expected_resumes(will_fail_association ? 0 : 1);
     sync_service_->RegisterDataTypeController(
         new SessionDataTypeController(&factory_, sync_service_.get()));
     profile()->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kSyncService, "token");
     sync_service_->Initialize();
     MessageLoop::current()->Run();
     return true;
   }
 
-  SyncBackendHost* backend() { return sync_service_->backend(); }
-
   // Path used in testing.
   ScopedTempDir temp_dir_;
   SessionServiceTestHelper helper_;
   SessionModelAssociator* model_associator_;
   SessionChangeProcessor* change_processor_;
   SessionID window_id_;
   ProfileSyncFactoryMock factory_;
   scoped_ptr<TestProfileSyncService> sync_service_;
   const gfx::Rect window_bounds_;
   bool notified_of_update_;
   NotificationRegistrar registrar_;
 };
 
 class CreateRootTask : public Task {
  public:
   explicit CreateRootTask(ProfileSyncServiceSessionTest* test)
       : test_(test), success_(false) {
   }
 
   virtual ~CreateRootTask() {}
   virtual void Run() {
-    success_ = ProfileSyncServiceTestHelper::CreateRoot(syncable::SESSIONS,
-        test_->sync_service(), test_->ids());
+    success_ = ProfileSyncServiceTestHelper::CreateRoot(
+        syncable::SESSIONS,
+        test_->sync_service()->GetUserShare(),
+        test_->ids());
   }
 
   bool success() { return success_; }
 
  private:
   ProfileSyncServiceSessionTest* test_;
   bool success_;
 };
 
 // Test that we can write this machine's session to a node and retrieve it.
 TEST_F(ProfileSyncServiceSessionTest, WriteSessionToNode) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
   ASSERT_EQ(model_associator_->GetSessionService(), helper_.service());
 
   // Check that the DataTypeController associated the models.
   bool has_nodes;
   ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes));
   ASSERT_TRUE(has_nodes);
   std::string machine_tag = model_associator_->GetCurrentMachineTag();
   int64 sync_id = model_associator_->GetSyncIdFromSessionTag(machine_tag);
   ASSERT_NE(sync_api::kInvalidId, sync_id);
 
   // Check that we can get the correct session specifics back from the node.
-  sync_api::ReadTransaction trans(sync_service_->
-      backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service_->GetUserShare());
   sync_api::ReadNode node(&trans);
   ASSERT_TRUE(node.InitByClientTagLookup(syncable::SESSIONS,
       machine_tag));
   const sync_pb::SessionSpecifics& specifics(node.GetSessionSpecifics());
   ASSERT_EQ(machine_tag, specifics.session_tag());
   ASSERT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   ASSERT_EQ(0, header_s.window_size());
 }
 
@@ skipping 125 matching lines @@
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
   int64 node_id = model_associator_->GetSyncIdFromSessionTag(
       model_associator_->GetCurrentMachineTag());
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_UPDATE;
   record->id = node_id;
   ASSERT_FALSE(notified_of_update_);
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(sync_service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
   ASSERT_TRUE(notified_of_update_);
 }
 
 // Test the DataTypeController on add.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionAdd) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   int64 node_id = model_associator_->GetSyncIdFromSessionTag(
       model_associator_->GetCurrentMachineTag());
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_ADD;
   record->id = node_id;
   ASSERT_FALSE(notified_of_update_);
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(sync_service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
   ASSERT_TRUE(notified_of_update_);
 }
 
 // Test the DataTypeController on delete.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionDelete) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   int64 node_id = model_associator_->GetSyncIdFromSessionTag(
       model_associator_->GetCurrentMachineTag());
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_DELETE;
   record->id = node_id;
   ASSERT_FALSE(notified_of_update_);
   {
-    sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(sync_service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
   ASSERT_TRUE(notified_of_update_);
 }
 // Test the TabNodePool when it starts off empty.
 TEST_F(ProfileSyncServiceSessionTest, TabNodePoolEmpty) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
@@ skipping 44 matching lines @@
   ASSERT_FALSE(model_associator_->tab_pool_.full());
   for (size_t i = 0; i < num_ids; ++i) {
     model_associator_->tab_pool_.FreeTabNode(node_ids[i]);
   }
   ASSERT_EQ(num_ids, model_associator_->tab_pool_.capacity());
   ASSERT_FALSE(model_associator_->tab_pool_.empty());
   ASSERT_TRUE(model_associator_->tab_pool_.full());
 }
 
 }  // namespace browser_sync