Remove SyncFileSystemservice::GetRemoteService

chrome/browser/sync_file_system/sync_file_system_service.cc

 // Copyright (c) 2012 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_file_system/sync_file_system_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 305 matching lines @@
 
 void SyncFileSystemService::DumpDatabase(const DumpFilesCallback& callback) {
   remote_service_->DumpDatabase(
       base::Bind(&SyncFileSystemService::DidDumpDatabase,
                  AsWeakPtr(), callback));
 }
 
 void SyncFileSystemService::GetFileSyncStatus(
     const FileSystemURL& url, const SyncFileStatusCallback& callback) {
   DCHECK(local_service_);
-  DCHECK(GetRemoteService(url.origin()));
+  DCHECK(remote_service_);
 
   // It's possible to get an invalid FileEntry.
   if (!url.is_valid()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    SYNC_FILE_ERROR_INVALID_URL,
                    SYNC_FILE_STATUS_UNKNOWN));
     return;
   }
 
   local_service_->HasPendingLocalChanges(
       url,
       base::Bind(&SyncFileSystemService::DidGetLocalChangeStatus,
                  AsWeakPtr(), callback));
 }
 
 void SyncFileSystemService::AddSyncEventObserver(SyncEventObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void SyncFileSystemService::RemoveSyncEventObserver(
     SyncEventObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 LocalChangeProcessor* SyncFileSystemService::GetLocalChangeProcessor(
     const GURL& origin) {
-  return GetRemoteService(origin)->GetLocalChangeProcessor();
+  return remote_service_->GetLocalChangeProcessor();
 }
 
 void SyncFileSystemService::OnSyncIdle() {
   if (promoting_demoted_changes_)
     return;
   promoting_demoted_changes_ = true;
 
   int* job_count = new int(1);
   base::Closure promote_completion_callback =
       base::Bind(&SyncFileSystemService::OnPromotionCompleted,
@@ skipping 152 matching lines @@
     callback.Run(SYNC_STATUS_ABORT);
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("SyncFileSystem.RegisterOriginResult",
                             remote_service_->GetCurrentState(),
                             REMOTE_SERVICE_STATE_MAX);
 
   if (status == SYNC_STATUS_FAILED) {
     // If we got generic error return the service status information.
-    switch (GetRemoteService(app_origin)->GetCurrentState()) {
+    switch (remote_service_->GetCurrentState()) {
       case REMOTE_SERVICE_AUTHENTICATION_REQUIRED:
         callback.Run(SYNC_STATUS_AUTHENTICATION_FAILED);
         return;
       case REMOTE_SERVICE_TEMPORARY_UNAVAILABLE:
         callback.Run(SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE);
         return;
       default:
         break;
     }
   }
@@ skipping 10 matching lines @@
   if (status != SYNC_STATUS_OK) {
     callback.Run(base::ListValue());
     return;
   }
 
   if (!remote_service_) {
     callback.Run(base::ListValue());
     return;
   }
 
-  GetRemoteService(origin)->DumpFiles(
+  remote_service_->DumpFiles(
       origin,
       base::Bind(
           &SyncFileSystemService::DidDumpFiles,
           AsWeakPtr(),
           origin,
           callback));
 }
 
 void SyncFileSystemService::DidDumpFiles(
     const GURL& origin,
@@ skipping 105 matching lines @@
     // handled as enabled origin in the SyncFS. This should be safe and will be
     // recovered when the user re-enables the app manually or the sync service
     // restarts.
     DVLOG(1) << "Handle extension notification for UNLOAD(DISABLE_RELOAD): "
              << app_origin;
     return;
   }
 
   DVLOG(1) << "Handle extension notification for UNLOAD(DISABLE): "
            << app_origin;
-  GetRemoteService(app_origin)->DisableOrigin(
+  remote_service_->DisableOrigin(
       app_origin,
       base::Bind(&DidHandleUnloadedEvent, app_origin));
   local_service_->SetOriginEnabled(app_origin, false);
 }
 
 void SyncFileSystemService::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
   RemoteFileSyncService::UninstallFlag flag =
       RemoteFileSyncService::UNINSTALL_AND_PURGE_REMOTE;
   // If it's loaded from an unpacked package and with key: field,
   // the uninstall will not be sync'ed and the user might be using the
   // same app key in other installs, so avoid purging the remote folder.
   if (extensions::Manifest::IsUnpackedLocation(extension->location()) &&
       extension->manifest()->HasKey(extensions::manifest_keys::kKey)) {
     flag = RemoteFileSyncService::UNINSTALL_AND_KEEP_REMOTE;
   }
 
   GURL app_origin = Extension::GetBaseURLFromExtensionId(extension->id());
   DVLOG(1) << "Handle extension notification for UNINSTALLED: "
            << app_origin;
-  GetRemoteService(app_origin)->UninstallOrigin(
+  remote_service_->UninstallOrigin(
       app_origin, flag,
       base::Bind(&DidHandleUninstalledEvent, app_origin));
   local_service_->SetOriginEnabled(app_origin, false);
 }
 
 void SyncFileSystemService::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   GURL app_origin = Extension::GetBaseURLFromExtensionId(extension->id());
   DVLOG(1) << "Handle extension notification for LOADED: " << app_origin;
-  GetRemoteService(app_origin)->EnableOrigin(
+  remote_service_->EnableOrigin(
       app_origin,
       base::Bind(&DidHandleLoadEvent, app_origin));
   local_service_->SetOriginEnabled(app_origin, true);
 }
 
 void SyncFileSystemService::OnStateChanged() {
   ProfileSyncServiceBase* profile_sync_service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (profile_sync_service)
     UpdateSyncEnabledStatus(profile_sync_service);
@@ skipping 27 matching lines @@
   for (ScopedVector<SyncProcessRunner>::iterator iter =
            local_sync_runners_.begin();
        iter != local_sync_runners_.end(); ++iter)
     ((*iter)->*method)();
   for (ScopedVector<SyncProcessRunner>::iterator iter =
            remote_sync_runners_.begin();
        iter != remote_sync_runners_.end(); ++iter)
     ((*iter)->*method)();
 }
 
-RemoteFileSyncService* SyncFileSystemService::GetRemoteService(
-    const GURL& origin) {
-  return remote_service_.get();
-}
-
 }  // namespace sync_file_system