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

chrome/browser/sync/glue/session_model_associator.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 "chrome/browser/sync/glue/session_model_associator.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 37 matching lines @@
     const std::string& id,
     sync_api::BaseNode* sync_node) {
   NOTREACHED();
   return false;
 }
 
 bool SessionModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(CalledOnValidThread());
   CHECK(has_nodes);
   *has_nodes = false;
-  sync_api::ReadTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service_->GetUserShare());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(kSessionsTag)) {
     LOG(ERROR) << kNoSessionsFolderError;
     return false;
   }
   // The sync model has user created nodes iff the sessions folder has
   // any children.
   *has_nodes = root.GetFirstChildId() != sync_api::kInvalidId;
   return true;
 }
 
 int64 SessionModelAssociator::GetSyncIdFromChromeId(const size_t& id) {
   DCHECK(CalledOnValidThread());
   return GetSyncIdFromSessionTag(TabIdToTag(GetCurrentMachineTag(), id));
 }
 
 int64 SessionModelAssociator::GetSyncIdFromSessionTag(const std::string& tag) {
   DCHECK(CalledOnValidThread());
-  sync_api::ReadTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service_->GetUserShare());
   sync_api::ReadNode node(&trans);
   if (!node.InitByClientTagLookup(syncable::SESSIONS, tag))
     return sync_api::kInvalidId;
   return node.GetId();
 }
 void SessionModelAssociator::ReassociateWindows(bool reload_tabs) {
   DCHECK(CalledOnValidThread());
   sync_pb::SessionSpecifics specifics;
   specifics.set_session_tag(GetCurrentMachineTag());
   sync_pb::SessionHeader* header_s = specifics.mutable_header();
@@ skipping 37 matching lines @@
         }
       }
       // Only add a window if it contains valid tabs.
       if (found_tabs) {
         sync_pb::SessionWindow* header_window = header_s->add_window();
         *header_window = window_s;
       }
     }
   }
 
-  sync_api::WriteTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service_->GetUserShare());
   sync_api::WriteNode header_node(&trans);
   if (!header_node.InitByIdLookup(local_session_syncid_)) {
     LOG(ERROR) << "Failed to load local session header node.";
     return;
   }
   header_node.SetSessionSpecifics(specifics);
 }
 
 // Static.
 bool SessionModelAssociator::ShouldSyncWindowType(const Browser::Type& type) {
@@ skipping 54 matching lines @@
   Associate(&tab, sync_id);
 }
 
 void SessionModelAssociator::Associate(const TabContents* tab, int64 sync_id) {
   DCHECK(CalledOnValidThread());
   SessionID::id_type session_id = tab->controller().session_id().id();
 
   TabLinks t(sync_id, tab);
   tab_map_[session_id] = t;
 
-  sync_api::WriteTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service_->GetUserShare());
   WriteTabContentsToSyncModel(*tab, sync_id, &trans);
 }
 
 bool SessionModelAssociator::WriteTabContentsToSyncModel(
     const TabContents& tab,
     int64 sync_id,
     sync_api::WriteTransaction* trans) {
   DCHECK(CalledOnValidThread());
   sync_api::WriteNode tab_node(trans);
   if (!tab_node.InitByIdLookup(sync_id)) {
@@ skipping 131 matching lines @@
 
   // Ensure that we disassociated properly, otherwise memory might leak.
   DCHECK(foreign_session_tracker_.empty());
   DCHECK_EQ(0U, tab_pool_.capacity());
 
   local_session_syncid_ = sync_api::kInvalidId;
 
   // Read any available foreign sessions and load any session data we may have.
   // If we don't have any local session data in the db, create a header node.
   {
-    sync_api::WriteTransaction trans(
-        sync_service_->backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(sync_service_->GetUserShare());
 
     sync_api::ReadNode root(&trans);
     if (!root.InitByTagLookup(kSessionsTag)) {
       LOG(ERROR) << kNoSessionsFolderError;
       return false;
     }
 
     // Make sure we have a machine tag.
     if (current_machine_tag_.empty())
       InitializeCurrentMachineTag(&trans);
@@ skipping 321 matching lines @@
 
 void SessionModelAssociator::TabNodePool::AddTabNode(int64 sync_id) {
   tab_syncid_pool_.resize(tab_syncid_pool_.size() + 1);
   tab_syncid_pool_[static_cast<size_t>(++tab_pool_fp_)] = sync_id;
 }
 
 int64 SessionModelAssociator::TabNodePool::GetFreeTabNode() {
   DCHECK_GT(machine_tag_.length(), 0U);
   if (tab_pool_fp_ == -1) {
     // Tab pool has no free nodes, allocate new one.
-    sync_api::WriteTransaction trans(
-        sync_service_->backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(sync_service_->GetUserShare());
     sync_api::ReadNode root(&trans);
     if (!root.InitByTagLookup(kSessionsTag)) {
       LOG(ERROR) << kNoSessionsFolderError;
       return 0;
     }
     size_t tab_node_id = tab_syncid_pool_.size();
     std::string tab_node_tag = TabIdToTag(machine_tag_, tab_node_id);
     sync_api::WriteNode tab_node(&trans);
     if (!tab_node.InitUniqueByCreation(syncable::SESSIONS, root,
                                        tab_node_tag)) {
@@ skipping 110 matching lines @@
     int handle,
     std::vector<SessionWindow*>* windows) {
   DCHECK(CalledOnValidThread());
   DCHECK(local_session_syncid_);
 
   sync_pb::SessionSpecifics specifics;
   specifics.set_session_tag(GetCurrentMachineTag());
   sync_pb::SessionHeader* header_s = specifics.mutable_header();
   PopulateSessionSpecificsHeader(*windows, header_s);
 
-  sync_api::WriteTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service_->GetUserShare());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(kSessionsTag)) {
     LOG(ERROR) << kNoSessionsFolderError;
     return;
   }
 
   sync_api::WriteNode header_node(&trans);
   if (!header_node.InitByIdLookup(local_session_syncid_)) {
     LOG(ERROR) << "Failed to load local session header node.";
     return;
@@ skipping 53 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(tab_map_.empty());
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     SessionTab* tab = window.tabs[i];
     int64 id = tab_pool_.GetFreeTabNode();
     if (id == -1) {
       LOG(ERROR) << "Failed to find/generate free sync node for tab.";
       return false;
     }
 
-    sync_api::WriteTransaction trans(
-        sync_service_->backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(sync_service_->GetUserShare());
     if (!WriteSessionTabToSyncModel(*tab, id, &trans)) {
       return false;
     }
 
     TabLinks t(id, tab);
     tab_map_[tab->tab_id.id()] = t;
   }
   return true;
 }
 
@@ skipping 31 matching lines @@
   for (std::vector<TabNavigation>::const_iterator i =
       tab.navigations.begin(); i != tab.navigations.end(); ++i) {
     const TabNavigation navigation = *i;
     sync_pb::TabNavigation* tab_navigation =
         session_tab->add_navigation();
     PopulateSessionSpecificsNavigation(&navigation, tab_navigation);
   }
 }
 
 }  // namespace browser_sync