Refactor syncable DEVICE_INFO type from ChangeProcessor to SyncableService - part 3.

chrome/browser/sync/glue/sync_backend_host_core.h

 // Copyright 2013 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_
 
 #include "base/memory/ref_counted.h"
 
 #include "base/timer/timer.h"
@@ skipping 22 matching lines @@
       scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory,
       const syncer::SyncCredentials& credentials,
       const std::string& invalidator_client_id,
       scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
       bool delete_sync_data_folder,
       const std::string& restored_key_for_bootstrapping,
       const std::string& restored_keystore_key_for_bootstrapping,
       scoped_ptr<syncer::InternalComponentsFactory> internal_components_factory,
       scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
       syncer::ReportUnrecoverableErrorFunction
-          report_unrecoverable_error_function,
-      const std::string& signin_scoped_device_id);
+          report_unrecoverable_error_function);
   ~DoInitializeOptions();
 
   base::MessageLoop* sync_loop;
   SyncBackendRegistrar* registrar;
   syncer::ModelSafeRoutingInfo routing_info;
   std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
   scoped_refptr<syncer::ExtensionsActivity> extensions_activity;
   syncer::WeakHandle<syncer::JsEventHandler> event_handler;
   GURL service_url;
   // Overridden by tests.
   scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory;
   syncer::SyncCredentials credentials;
   const std::string invalidator_client_id;
   scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory;
   std::string lsid;
   bool delete_sync_data_folder;
   std::string restored_key_for_bootstrapping;
   std::string restored_keystore_key_for_bootstrapping;
   scoped_ptr<syncer::InternalComponentsFactory> internal_components_factory;
   scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler;
   syncer::ReportUnrecoverableErrorFunction
       report_unrecoverable_error_function;
-  std::string signin_scoped_device_id;
 };
 
 // Helper struct to handle currying params to
 // SyncBackendHost::Core::DoConfigureSyncer.
 struct DoConfigureSyncerTypes {
   DoConfigureSyncerTypes();
   ~DoConfigureSyncerTypes();
   syncer::ModelTypeSet to_download;
   syncer::ModelTypeSet to_purge;
   syncer::ModelTypeSet to_journal;
@@ skipping 95 matching lines @@
   void DoEnableEncryptEverything();
 
   // Ask the syncer to check for updates for the specified types.
   void DoRefreshTypes(syncer::ModelTypeSet types);
 
   // Invoked if we failed to download the necessary control types at startup.
   // Invokes SyncBackendHost::HandleControlTypesDownloadRetry.
   void OnControlTypesDownloadRetry();
 
   // Called to perform tasks which require the control data to be downloaded.
-  // This includes refreshing encryption, setting up the device info change
-  // processor, etc.
+  // This includes refreshing encryption, etc.
   void DoInitialProcessControlTypes();
 
-  // Some parts of DoInitialProcessControlTypes() may be executed on a different
-  // thread.  This function asynchronously continues the work started in
-  // DoInitialProcessControlTypes() once that other thread gets back to us.
-  void DoFinishInitialProcessControlTypes();
-
   // The shutdown order is a bit complicated:
   // 1) Call ShutdownOnUIThread() from |frontend_loop_| to request sync manager
   //    to stop as soon as possible.
   // 2) Post DoShutdown() to sync loop to clean up backend state, save
   //    directory and destroy sync manager.
   void ShutdownOnUIThread();
   void DoShutdown(syncer::ShutdownReason reason);
   void DoDestroySyncManager(syncer::ShutdownReason reason);
 
   // Configuration methods that must execute on sync loop.
@@ skipping 10 matching lines @@
                                 syncer::ModelTypeSet)>& ready_task);
   void DoRetryConfiguration(
       const base::Closure& retry_callback);
 
   // Set the base request context to use when making HTTP calls.
   // This method will add a reference to the context to persist it
   // on the IO thread. Must be removed from IO thread.
 
   syncer::SyncManager* sync_manager() { return sync_manager_.get(); }
 
-  SyncedDeviceTracker* synced_device_tracker() {
-    return synced_device_tracker_.get();
-  }
-
   void SendBufferedProtocolEventsAndEnableForwarding();
   void DisableProtocolEventForwarding();
 
   // Enables the forwarding of directory type debug counters to the
   // SyncBackendHost.  Also requests that updates to all counters be
   // emitted right away to initialize any new listeners' states.
   void EnableDirectoryTypeDebugInfoForwarding();
 
   // Disables forwarding of directory type debug counters.
   void DisableDirectoryTypeDebugInfoForwarding();
@@ skipping 50 matching lines @@
   // Our parent's registrar (not owned).  Non-NULL only between
   // calls to DoInitialize() and DoShutdown().
   SyncBackendRegistrar* registrar_;
 
   // The timer used to periodically call SaveChanges.
   scoped_ptr<base::RepeatingTimer<SyncBackendHostCore> > save_changes_timer_;
 
   // Our encryptor, which uses Chrome's encryption functions.
   sync_driver::SystemEncryptor encryptor_;
 
-  // A special ChangeProcessor that tracks the DEVICE_INFO type for us.
-  scoped_ptr<SyncedDeviceTracker> synced_device_tracker_;
-
   // The top-level syncapi entry point.  Lives on the sync thread.
   scoped_ptr<syncer::SyncManager> sync_manager_;
 
   // Temporary holder of sync manager's initialization results. Set by
   // OnInitializeComplete, and consumed when we pass it via OnBackendInitialized
   // in the final state of HandleInitializationSuccessOnFrontendLoop.
   syncer::WeakHandle<syncer::JsBackend> js_backend_;
   syncer::WeakHandle<syncer::DataTypeDebugInfoListener> debug_info_listener_;
 
   // These signals allow us to send requests to shut down the HttpBridgeFactory
   // and ServerConnectionManager without having to wait for those classes to
   // finish initializing first.
   //
   // See comments in SyncBackendHostCore::ShutdownOnUIThread() for more details.
   syncer::CancelationSignal release_request_context_signal_;
   syncer::CancelationSignal stop_syncing_signal_;
 
   // Matches the value of SyncPref's HasSyncSetupCompleted() flag at init time.
   // Should not be used for anything except for UMAs and logging.
   const bool has_sync_setup_completed_;
 
   // Set when we've been asked to forward sync protocol events to the frontend.
   bool forward_protocol_events_;
 
   // Set when the forwarding of per-type debug counters is enabled.
   bool forward_type_info_;
 
-  // Obtained from SigninClient::GetSigninScopedDeviceId(). Stored here just to
-  // pass from SyncBackendHostImpl to SyncedDeviceTracker.
-  std::string signin_scoped_device_id_;
-
   base::WeakPtrFactory<SyncBackendHostCore> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostCore);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_CORE_H_