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

chrome/browser/sync/glue/bookmark_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/bookmark_model_associator.h"
 
 #include <stack>
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
@@ skipping 219 matching lines @@
   *has_nodes = false;
   int64 bookmark_bar_sync_id;
   if (!GetSyncIdForTaggedNode(kBookmarkBarTag, &bookmark_bar_sync_id)) {
     return false;
   }
   int64 other_bookmarks_sync_id;
   if (!GetSyncIdForTaggedNode(kOtherBookmarksTag, &other_bookmarks_sync_id)) {
     return false;
   }
 
-  sync_api::ReadTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service_->GetUserShare());
 
   sync_api::ReadNode bookmark_bar_node(&trans);
   if (!bookmark_bar_node.InitByIdLookup(bookmark_bar_sync_id)) {
     return false;
   }
 
   sync_api::ReadNode other_bookmarks_node(&trans);
   if (!other_bookmarks_node.InitByIdLookup(other_bookmarks_sync_id)) {
     return false;
   }
@@ skipping 29 matching lines @@
     return true;
   if (!GetSyncIdForTaggedNode(tag, &sync_id))
     return false;
 
   Associate(permanent_node, sync_id);
   return true;
 }
 
 bool BookmarkModelAssociator::GetSyncIdForTaggedNode(const std::string& tag,
                                                      int64* sync_id) {
-  sync_api::ReadTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service_->GetUserShare());
   sync_api::ReadNode sync_node(&trans);
   if (!sync_node.InitByTagLookup(tag.c_str()))
     return false;
   *sync_id = sync_node.GetId();
   return true;
 }
 
 bool BookmarkModelAssociator::AssociateModels() {
   // Try to load model associations from persisted associations first. If that
   // succeeds, we don't need to run the complex model matching algorithm.
@@ skipping 45 matching lines @@
       model->GetBookmarkBarNode()->id());
   DCHECK(bookmark_bar_sync_id != sync_api::kInvalidId);
   int64 other_bookmarks_sync_id = GetSyncIdFromChromeId(
       model->other_node()->id());
   DCHECK(other_bookmarks_sync_id != sync_api::kInvalidId);
 
   std::stack<int64> dfs_stack;
   dfs_stack.push(other_bookmarks_sync_id);
   dfs_stack.push(bookmark_bar_sync_id);
 
-  sync_api::WriteTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service_->GetUserShare());
 
   while (!dfs_stack.empty()) {
     int64 sync_parent_id = dfs_stack.top();
     dfs_stack.pop();
 
     sync_api::ReadNode sync_parent(&trans);
     if (!sync_parent.InitByIdLookup(sync_parent_id)) {
       return false;
     }
     // Only folder nodes are pushed on to the stack.
@@ skipping 42 matching lines @@
     // ones that are not present in the parent sync node. So create them.
     for (int i = index; i < parent_node->GetChildCount(); ++i) {
       sync_child_id = BookmarkChangeProcessor::CreateSyncNode(
           parent_node, model, i, &trans, this, sync_service_);
       if (parent_node->GetChild(i)->is_folder())
         dfs_stack.push(sync_child_id);
       number_of_new_sync_nodes_created_at_association_++;
     }
   }
 
-  if (sync_service_->backend()->GetAutofillMigrationState() !=
+  if (sync_service_->GetAutofillMigrationState() !=
       syncable::MIGRATED) {
     syncable::AutofillMigrationDebugInfo debug_info;
     debug_info.bookmarks_added_during_migration =
         number_of_new_sync_nodes_created_at_association_;
-    sync_service_->backend()->SetAutofillMigrationDebugInfo(
+    sync_service_->SetAutofillMigrationDebugInfo(
         syncable::AutofillMigrationDebugInfo::BOOKMARK_ADDED,
         debug_info);
   }
   return true;
 }
 
 void BookmarkModelAssociator::PostPersistAssociationsTask() {
   // No need to post a task if a task is already pending.
   if (!persist_associations_.empty())
     return;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       persist_associations_.NewRunnableMethod(
           &BookmarkModelAssociator::PersistAssociations));
 }
 
 void BookmarkModelAssociator::PersistAssociations() {
   // If there are no dirty associations we have nothing to do. We handle this
   // explicity instead of letting the for loop do it to avoid creating a write
   // transaction in this case.
   if (dirty_associations_sync_ids_.empty()) {
     DCHECK(id_map_.empty());
     DCHECK(id_map_inverse_.empty());
     return;
   }
 
-  sync_api::WriteTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service_->GetUserShare());
   DirtyAssociationsSyncIds::iterator iter;
   for (iter = dirty_associations_sync_ids_.begin();
        iter != dirty_associations_sync_ids_.end();
        ++iter) {
     int64 sync_id = *iter;
     sync_api::WriteNode sync_node(&trans);
     if (!sync_node.InitByIdLookup(sync_id)) {
       persist_ids_error_handler_->OnUnrecoverableError(FROM_HERE,
           "Could not lookup bookmark node for ID persistence.");
       return;
@@ skipping 33 matching lines @@
   // Build a bookmark node ID index since we are going to repeatedly search for
   // bookmark nodes by their IDs.
   BookmarkNodeIdIndex id_index;
   id_index.AddAll(model->GetBookmarkBarNode());
   id_index.AddAll(model->other_node());
 
   std::stack<int64> dfs_stack;
   dfs_stack.push(other_bookmarks_id);
   dfs_stack.push(bookmark_bar_id);
 
-  sync_api::ReadTransaction trans(
-      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service_->GetUserShare());
 
   // Count total number of nodes in sync model so that we can compare that
   // with the total number of nodes in the bookmark model.
   size_t sync_node_count = 0;
   while (!dfs_stack.empty()) {
     int64 parent_id = dfs_stack.top();
     dfs_stack.pop();
     ++sync_node_count;
     sync_api::ReadNode sync_parent(&trans);
     if (!sync_parent.InitByIdLookup(parent_id)) {
@@ skipping 32 matching lines @@
 
   // It's possible that the number of nodes in the bookmark model is not the
   // same as number of nodes in the sync model. This can happen when the sync
   // model doesn't get a chance to persist its changes, for example when
   // Chrome does not shut down gracefully. In such cases we can't trust the
   // loaded associations.
   return sync_node_count == id_index.count();
 }
 
 }  // namespace browser_sync