[Sync] Make BackendMigrator not wait for full sync cycles

chrome/browser/sync/glue/sync_backend_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 148 matching lines @@
   // The ready_task will be run when all of the requested data types
   // are up-to-date and ready for activation.  The task will be
   // cancelled upon shutdown.
   virtual void ConfigureDataTypes(
       const syncable::ModelTypeSet& types_to_add,
       const syncable::ModelTypeSet& types_to_remove,
       sync_api::ConfigureReason reason,
       base::Callback<void(bool)> ready_task,
       bool enable_nigori);
 
-  // Makes an asynchronous call to syncer to switch to config mode. When done
-  // syncer will call us back on FinishConfigureDataTypes.
-  virtual void StartConfiguration(Callback0::Type* callback);
+  // Tells the syncer to switch to config mode. Calls back on
+  // FinishConfigureDataTypesOnFrontendLoop when done.  Overrideable
+  // for testing.
+  virtual void StartConfiguration(bool cleanup_disabled_types);
 
   // Encrypts the specified datatypes and marks them as needing encryption on
   // other machines. This affects all machines synced to this account and all
   // data belonging to the specified types.
   // Note: actual work is done on sync_thread_'s message loop.
   virtual void EncryptDataTypes(
       const syncable::ModelTypeSet& encrypted_types);
 
   syncable::ModelTypeSet GetEncryptedDataTypes() const;
 
+  // Returns the set of types for which there is no sync data.
+  // Overrideable for testing.
+  virtual syncable::ModelTypeSet GetPurgedDataTypes() const;
+
   // Activates change processing for the given data type.  This must
   // be called synchronously with the data type's model association so
   // no changes are dropped between model association and change
   // processor activation.
   void ActivateDataType(
       syncable::ModelType type, ModelSafeGroup group,
       ChangeProcessor* change_processor);
 
   // Deactivates change processing for the given data type.
   void DeactivateDataType(syncable::ModelType type);
@@ skipping 129 matching lines @@
     // Called on the SyncBackendHost sync_thread_ to tell the syncapi to start
     // syncing (generally after initialization and authentication).
     void DoStartSyncing();
 
     // Called on the SyncBackendHost sync_thread_ to clear server
     // data.
     void DoRequestClearServerData();
 
     // Called on the SyncBackendHost sync_thread_ to cleanup disabled
     // types.
-    void DoRequestCleanupDisabledTypes();
+    void DoRequestCleanupDisabledTypes(const base::Closure& callback);
 
     // Called on our SyncBackendHost's |sync_thread_| to set the passphrase
     // on behalf of SyncBackendHost::SupplyPassphrase.
     void DoSetPassphrase(const std::string& passphrase, bool is_explicit);
 
     // Getter/setter for whether we are waiting on SetPassphrase to process a
     // passphrase. Set by SetPassphrase, cleared by OnPassphraseRequired or
     // OnPassphraseAccepted.
     bool processing_passphrase() const;
     void set_processing_passphrase();
 
     // Called on SyncBackendHost's |sync_thread_| to set the datatypes we need
     // to encrypt as well as encrypt all local data of that type.
     void DoEncryptDataTypes(const syncable::ModelTypeSet& encrypted_types);
 
     // The shutdown order is a bit complicated:
     // 1) From |sync_thread_|, invoke the syncapi Shutdown call to do
     //    a final SaveChanges, and close sqlite handles.
     // 2) Then, from |frontend_loop_|, halt the sync_thread_ (which is
     //    a blocking call). This causes syncapi thread-exit handlers
     //    to run and make use of cached pointers to various components
     //    owned implicitly by us.
     // 3) Destroy this Core. That will delete syncapi components in a
     //    safe order because the thread that was using them has exited
     //    (in step 2).
     void DoShutdown(bool stopping_sync);
 
     // Posts a config request on the sync thread.
-    virtual void DoRequestConfig(
+    void DoRequestConfig(
         const syncable::ModelTypeBitSet& types_to_config,
         sync_api::ConfigureReason reason);
 
-    // Start the configuration mode.
-    virtual void DoStartConfiguration(Callback0::Type* callback);
+    // Starts configuration mode, cleaning up disabled types if
+    // necessary.  Calls back on FinishConfigureDataTypes when done.
+    void DoStartConfiguration(bool cleanup_disabled_types);
 
     // 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.
 
     sync_api::SyncManager* sync_manager() { return sync_manager_.get(); }
 
     // Delete the sync data folder to cleanup backend data.  Happens the first
     // time sync is enabled for a user (to prevent accidentally reusing old
     // sync databases), as well as shutdown when you're no longer syncing.
@@ skipping 140 matching lines @@
   // For convenience, checks if initialization state is INITIALIZED.
   bool initialized() const { return initialization_state_ == INITIALIZED; }
 
   // A thread where all the sync operations happen.
   base::Thread sync_thread_;
 
   // A reference to the MessageLoop used to construct |this|, so we know how
   // to safely talk back to the SyncFrontend.
   MessageLoop* const frontend_loop_;
 
-  Profile* profile_;
+  Profile* const profile_;
+
+  // Name used for debugging (set from profile_->GetDebugName()).
+  const std::string name_;
 
   sync_notifier::SyncNotifierFactory sync_notifier_factory_;
 
   scoped_ptr<SyncBackendRegistrar> registrar_;
 
   // The frontend which we serve (and are owned by).
   SyncFrontend* frontend_;
 
   // Path of the folder that stores the sync data files.
   FilePath sync_data_folder_path_;
 
   scoped_ptr<PendingConfigureDataTypesState> pending_download_state_;
   scoped_ptr<PendingConfigureDataTypesState> pending_config_mode_state_;
 
   // UI-thread cache of the last AuthErrorState received from syncapi.
   GoogleServiceAuthError last_auth_error_;
 
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   scoped_ptr<sessions::SyncSessionSnapshot> last_snapshot_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_