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

chrome/browser/sync/glue/extension_sync.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/extension_sync.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/extension_data.h"
 #include "chrome/browser/sync/glue/extension_sync_traits.h"
 #include "chrome/browser/sync/glue/extension_util.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 
 namespace browser_sync {
 
 bool RootNodeHasChildren(const char* tag,
                          ProfileSyncService* sync_service,
                          bool* has_children) {
   CHECK(has_children);
   *has_children = false;
-  sync_api::ReadTransaction trans(
-      sync_service->backend()->GetUserShareHandle());
+  sync_api::ReadTransaction trans(sync_service->GetUserShare());
   sync_api::ReadNode node(&trans);
   if (!node.InitByTagLookup(tag)) {
     LOG(ERROR) << "Root node with tag " << tag << " does not exist";
     return false;
   }
   *has_children = node.GetFirstChildId() != sync_api::kInvalidId;
   return true;
 }
 
 ExtensionService* GetExtensionServiceFromProfile(
@@ skipping 103 matching lines @@
 
 // Gets the data from the server for extensions to be synced and
 // updates |extension_data_map|.  Skips all extensions in
 // |unsynced_extensions|.
 bool SlurpServerData(
     const char* root_node_tag,
     const ExtensionSpecificsGetter extension_specifics_getter,
     const std::set<std::string>& unsynced_extensions,
     ProfileSyncService* sync_service,
     ExtensionDataMap* extension_data_map) {
-  sync_api::WriteTransaction trans(
-      sync_service->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service->GetUserShare());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(root_node_tag)) {
     LOG(ERROR) << GetRootNodeDoesNotExistError(root_node_tag);
     return false;
   }
 
   int64 id = root.GetFirstChildId();
   while (id != sync_api::kInvalidId) {
     sync_api::ReadNode sync_node(&trans);
     if (!sync_node.InitByIdLookup(id)) {
@@ skipping 154 matching lines @@
     LOG(DFATAL) << "Extension updater unexpectedly NULL; "
                 << "auto-updates may be turned off";
   }
 }
 
 }  // namespace
 
 bool FlushExtensionData(const ExtensionSyncTraits& traits,
                         const ExtensionDataMap& extension_data_map,
                         ProfileSyncService* sync_service) {
-  sync_api::WriteTransaction trans(
-      sync_service->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service->GetUserShare());
   sync_api::ReadNode root(&trans);
   if (!root.InitByTagLookup(traits.root_node_tag)) {
     LOG(ERROR) << GetRootNodeDoesNotExistError(traits.root_node_tag);
     return false;
   }
 
   ExtensionService* extensions_service =
       GetExtensionServiceFromProfileSyncService(sync_service);
 
   // Update server and client as necessary.
@@ skipping 42 matching lines @@
 
   ExtensionService* extensions_service =
       GetExtensionServiceFromProfileSyncService(sync_service);
   sync_pb::ExtensionSpecifics client_data;
   GetExtensionSpecifics(extension, extensions_service->extension_prefs(),
                         &client_data);
   DcheckIsExtensionSpecificsValid(client_data);
   ExtensionData extension_data =
       ExtensionData::FromData(ExtensionData::CLIENT, client_data);
 
-  sync_api::WriteTransaction trans(
-      sync_service->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service->GetUserShare());
 
   sync_api::ReadNode node(&trans);
   if (node.InitByClientTagLookup(traits.model_type, id)) {
     sync_pb::ExtensionSpecifics server_data =
         (*traits.extension_specifics_getter)(node);
     if (IsExtensionSpecificsValid(server_data)) {
       // If server node exists and is valid, update |extension_data|
       // from it (but with it taking precedence).
       extension_data =
           ExtensionData::FromData(ExtensionData::SERVER, server_data);
@@ skipping 18 matching lines @@
   // again once the auto-update is finished.
   //
   // TODO(akalin): Figure out a way to tell when the above happens,
   // so we know exactly what NeedsUpdate(CLIENT) should return.
   return true;
 }
 
 void RemoveServerData(const ExtensionSyncTraits& traits,
                       const std::string& id,
                       ProfileSyncService* sync_service) {
-  sync_api::WriteTransaction trans(
-      sync_service->backend()->GetUserShareHandle());
+  sync_api::WriteTransaction trans(sync_service->GetUserShare());
   sync_api::WriteNode write_node(&trans);
   if (write_node.InitByClientTagLookup(traits.model_type, id)) {
     write_node.Remove();
   } else {
     LOG(ERROR) << "Server data does not exist for extension " << id;
   }
 }
 
 void UpdateClient(const ExtensionSyncTraits& traits,
                   const sync_pb::ExtensionSpecifics& server_data,
@@ skipping 38 matching lines @@
     } else {
       LOG(WARNING) << "Ignoring server data for invalid or "
                    << "non-syncable extension " << extension->id();
     }
   } else {
     LOG(ERROR) << "Trying to uninstall nonexistent extension " << id;
   }
 }
 
 }  // namespace browser_sync