Pass args to SyncManager::Init via a struct.

sync/internal_api/sync_rollback_manager.cc

 // Copyright 2014 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 "sync/internal_api/sync_rollback_manager.h"
 
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/util/syncer_error.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.h"
 #include "url/gurl.h"
 
 namespace syncer {
 
 SyncRollbackManager::SyncRollbackManager()
     : change_delegate_(NULL) {
 }
 
 SyncRollbackManager::~SyncRollbackManager() {
 }
 
-void SyncRollbackManager::Init(
-    const base::FilePath& database_location,
-    const WeakHandle<JsEventHandler>& event_handler,
-    const GURL& service_url,
-    scoped_ptr<HttpPostProviderFactory> post_factory,
-    const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
-    ExtensionsActivity* extensions_activity,
-    SyncManager::ChangeDelegate* change_delegate,
-    const SyncCredentials& credentials,
-    const std::string& invalidator_client_id,
-    const std::string& restored_key_for_bootstrapping,
-    const std::string& restored_keystore_key_for_bootstrapping,
-    InternalComponentsFactory* internal_components_factory,
-    Encryptor* encryptor,
-    scoped_ptr<UnrecoverableErrorHandler> unrecoverable_error_handler,
-    ReportUnrecoverableErrorFunction report_unrecoverable_error_function,
-    CancelationSignal* cancelation_signal) {
+void SyncRollbackManager::Init(InitArgs* args) {
   if (SyncRollbackManagerBase::InitInternal(
-          database_location,
-          internal_components_factory,
-          unrecoverable_error_handler.Pass(),
-          report_unrecoverable_error_function)) {
-    change_delegate_ = change_delegate;
+          args->database_location,
+          args->internal_components_factory.get(),
+          args->unrecoverable_error_handler.Pass(),
+          args->report_unrecoverable_error_function)) {
+    change_delegate_ = args->change_delegate;
 
-    for (size_t i = 0; i < workers.size(); ++i) {
-      ModelSafeGroup group = workers[i]->GetModelSafeGroup();
+    for (size_t i = 0; i < args->workers.size(); ++i) {
+      ModelSafeGroup group = args->workers[i]->GetModelSafeGroup();
       CHECK(workers_.find(group) == workers_.end());
-      workers_[group] = workers[i];
+      workers_[group] = args->workers[i];
     }
 
     rollback_ready_types_ = GetUserShare()->directory->InitialSyncEndedTypes();
     rollback_ready_types_.RetainAll(BackupTypes());
   }
 }
 
 void SyncRollbackManager::StartSyncingNormally(
     const ModelSafeRoutingInfo& routing_info){
   if (rollback_ready_types_.Empty()) {
@@ skipping 66 matching lines @@
 }
 
 void SyncRollbackManager::NotifyRollbackDone() {
   SyncProtocolError error;
   error.action = ROLLBACK_DONE;
   FOR_EACH_OBSERVER(SyncManager::Observer, *GetObservers(),
                     OnActionableError(error));
 }
 
 }  // namespace syncer