Cleanup: Deprecate DriveFileSyncService::kServiceName

chrome/browser/sync_file_system/local_file_sync_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/local_file_sync_service.h"
 
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 97 matching lines @@
 }
 
 void LocalFileSyncService::Shutdown() {
   sync_context_->RemoveOriginChangeObserver(this);
   sync_context_->ShutdownOnUIThread();
   profile_ = NULL;
 }
 
 void LocalFileSyncService::MaybeInitializeFileSystemContext(
     const GURL& app_origin,
-    const std::string& service_name,
     fileapi::FileSystemContext* file_system_context,
     const SyncStatusCallback& callback) {
   sync_context_->MaybeInitializeFileSystemContext(
-      app_origin, service_name, file_system_context,
+      app_origin, file_system_context,
       base::Bind(&LocalFileSyncService::DidInitializeFileSystemContext,
                  AsWeakPtr(), app_origin,
                  make_scoped_refptr(file_system_context), callback));
 }
 
 void LocalFileSyncService::AddChangeObserver(Observer* observer) {
   change_observers_.AddObserver(observer);
 }
 
 void LocalFileSyncService::RegisterURLForWaitingSync(
@@ skipping 49 matching lines @@
 
 void LocalFileSyncService::GetLocalFileMetadata(
     const FileSystemURL& url, const SyncFileMetadataCallback& callback) {
   DCHECK(ContainsKey(origin_to_contexts_, url.origin()));
   sync_context_->GetFileMetadata(origin_to_contexts_[url.origin()],
                                  url, callback);
 }
 
 void LocalFileSyncService::PrepareForProcessRemoteChange(
     const FileSystemURL& url,
-    const std::string& service_name,
     const PrepareChangeCallback& callback) {
   if (!ContainsKey(origin_to_contexts_, url.origin())) {
     // This could happen if a remote sync is triggered for the app that hasn't
     // been initialized in this service.
     DCHECK(profile_);
     // The given url.origin() must be for valid installed app.
     ExtensionService* extension_service =
         extensions::ExtensionSystem::Get(profile_)->extension_service();
     const extensions::Extension* extension = extension_service->GetInstalledApp(
         url.origin());
@@ skipping 10 matching lines @@
                    SyncFileMetadata(), FileChangeList());
       return;
     }
     GURL site_url = extension_service->GetSiteForExtensionId(extension->id());
     DCHECK(!site_url.is_empty());
     scoped_refptr<fileapi::FileSystemContext> file_system_context =
         content::BrowserContext::GetStoragePartitionForSite(
             profile_, site_url)->GetFileSystemContext();
     MaybeInitializeFileSystemContext(
         url.origin(),
-        service_name,
         file_system_context.get(),
         base::Bind(&LocalFileSyncService::DidInitializeForRemoteSync,
                    AsWeakPtr(),
                    url,
-                   service_name,
                    file_system_context,
                    callback));
     return;
   }
 
   DCHECK(ContainsKey(origin_to_contexts_, url.origin()));
   sync_context_->PrepareForSync(
       origin_to_contexts_[url.origin()], url,
       base::Bind(&PrepareForProcessRemoteChangeCallbackAdapter, callback));
 }
@@ skipping 81 matching lines @@
         app_origin, file_system_context->change_tracker()->num_changes());
     int64 num_changes = origin_change_map_.GetTotalChangeCount();
     FOR_EACH_OBSERVER(Observer, change_observers_,
                       OnLocalChangeAvailable(num_changes));
   }
   callback.Run(status);
 }
 
 void LocalFileSyncService::DidInitializeForRemoteSync(
     const FileSystemURL& url,
-    const std::string& service_name,
     fileapi::FileSystemContext* file_system_context,
     const PrepareChangeCallback& callback,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     DVLOG(1) << "FileSystemContext initialization failed for remote sync:"
              << url.DebugString() << " status=" << status
              << " (" << SyncStatusCodeToString(status) << ")";
     callback.Run(status, SyncFileMetadata(), FileChangeList());
     return;
   }
   origin_to_contexts_[url.origin()] = file_system_context;
-  PrepareForProcessRemoteChange(url, service_name, callback);
+  PrepareForProcessRemoteChange(url, callback);
 }
 
 void LocalFileSyncService::RunLocalSyncCallback(
     SyncStatusCode status,
     const FileSystemURL& url) {
   DCHECK(!local_sync_callback_.is_null());
   SyncFileCallback callback = local_sync_callback_;
   local_sync_callback_.Reset();
   callback.Run(status, url);
 }
@@ skipping 69 matching lines @@
       changes.front(),
       sync_file_info.local_file_path,
       sync_file_info.metadata,
       url,
       base::Bind(&LocalFileSyncService::ProcessNextChangeForURL,
                  AsWeakPtr(), sync_file_info,
                  changes.front(), changes.PopAndGetNewList()));
 }
 
 }  // namespace sync_file_system