Refactor sync notifier out of sync api.

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2011 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 "build/build_config.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 73 matching lines @@
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(registrar_.workers.empty());
 }
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
     const GURL& sync_service_url,
     const syncable::ModelTypeSet& types,
     URLRequestContextGetter* baseline_context_getter,
     const SyncCredentials& credentials,
-    bool delete_sync_data_folder,
-    const notifier::NotifierOptions& notifier_options) {
+    bool delete_sync_data_folder) {
   if (!core_thread_.Start())
     return;
 
   frontend_ = frontend;
   DCHECK(frontend);
 
   // Create a worker for the UI thread and route bookmark changes to it.
   // TODO(tim): Pull this into a method to reuse.  For now we don't even
   // need to lock because we init before the syncapi exists and we tear down
   // after the syncapi is destroyed.  Make sure to NULL-check workers_ indices
@@ skipping 32 matching lines @@
   }
 
   // Nigori is populated by default now.
   registrar_.routing_info[syncable::NIGORI] = GROUP_PASSIVE;
 
   InitCore(Core::DoInitializeOptions(
       sync_service_url,
       MakeHttpBridgeFactory(baseline_context_getter),
       credentials,
       delete_sync_data_folder,
-      notifier_options,
       RestoreEncryptionBootstrapToken(),
       false));
 }
 
 void SyncBackendHost::PersistEncryptionBootstrapToken(
     const std::string& token) {
   PrefService* prefs = profile_->GetPrefs();
 
   prefs->SetString(prefs::kEncryptionBootstrapToken, token);
   prefs->ScheduleSavePersistentPrefs();
@@ skipping 425 matching lines @@
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
   host_->frontend_->OnEncryptionComplete(encrypted_types);
 }
 
 SyncBackendHost::Core::DoInitializeOptions::DoInitializeOptions(
     const GURL& service_url,
     sync_api::HttpPostProviderFactory* http_bridge_factory,
     const sync_api::SyncCredentials& credentials,
     bool delete_sync_data_folder,
-    const notifier::NotifierOptions& notifier_options,
     std::string restored_key_for_bootstrapping,
     bool setup_for_test_mode)
     : service_url(service_url),
       http_bridge_factory(http_bridge_factory),
       credentials(credentials),
       delete_sync_data_folder(delete_sync_data_folder),
-      notifier_options(notifier_options),
       restored_key_for_bootstrapping(restored_key_for_bootstrapping),
       setup_for_test_mode(setup_for_test_mode) {
 }
 
 SyncBackendHost::Core::DoInitializeOptions::~DoInitializeOptions() {}
 
 sync_api::UserShare* SyncBackendHost::GetUserShare() const {
   DCHECK(syncapi_initialized_);
   return core_->syncapi()->GetUserShare();
 }
@@ skipping 97 matching lines @@
   const FilePath& path_str = host_->sync_data_folder_path();
   success = syncapi_->Init(
       path_str,
       (options.service_url.host() + options.service_url.path()).c_str(),
       options.service_url.EffectiveIntPort(),
       options.service_url.SchemeIsSecure(),
       options.http_bridge_factory,
       host_,  // ModelSafeWorkerRegistrar.
       MakeUserAgentForSyncapi().c_str(),
       options.credentials,
-      options.notifier_options,
       options.restored_key_for_bootstrapping,
       options.setup_for_test_mode);
   DCHECK(success) << "Syncapi initialization failed!";
 }
 
 void SyncBackendHost::Core::DoUpdateCredentials(
     const SyncCredentials& credentials) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->UpdateCredentials(credentials);
 }
@@ skipping 402 matching lines @@
 }
 
 void SyncBackendHost::Core::DoProcessMessage(
     const std::string& name, const JsArgList& args,
     const JsEventHandler* sender) {
   DCHECK_EQ(MessageLoop::current(), host_->core_thread_.message_loop());
   syncapi_->GetJsBackend()->ProcessMessage(name, args, sender);
 }
 
 }  // namespace browser_sync