[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 99 matching lines @@
 // dispatch of potentially blocking calls to appropriate threads and ensures
 // that the SyncFrontend is only accessed on the UI loop.
 class SyncBackendHost {
  public:
   typedef sync_api::SyncManager::Status::Summary StatusSummary;
   typedef sync_api::SyncManager::Status Status;
 
   // Create a SyncBackendHost with a reference to the |frontend| that it serves
   // and communicates to via the SyncFrontend interface (on the same thread
   // it used to call the constructor).
-  explicit SyncBackendHost(Profile* profile);
+  SyncBackendHost(const std::string& name, Profile* profile);
   // For testing.
   // TODO(skrul): Extract an interface so this is not needed.
   SyncBackendHost();
   virtual ~SyncBackendHost();
 
   // Called on |frontend_loop_| to kick off asynchronous initialization.
   // As a fallback when no cached auth information is available, try to
   // bootstrap authentication using |lsid|, if it isn't empty.
   // Optionally delete the Sync Data folder (if it's corrupt).
   void Initialize(SyncFrontend* frontend,
@@ skipping 41 matching lines @@
 
   // 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 GetUnsyncedDataTypes() 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 49 matching lines @@
     DOWNLOADING_NIGORI,  // The SyncManager is initialized, but we're fetching
                          // encryption information before alerting the
                          // frontend.
     INITIALIZED,         // Initialization is complete.
   };
 
   // The real guts of SyncBackendHost, to keep the public client API clean.
   class Core : public base::RefCountedThreadSafe<SyncBackendHost::Core>,
                public sync_api::SyncManager::Observer {
    public:
-    Core(Profile* profile, SyncBackendHost* backend);
+    Core(const std::string& name, SyncBackendHost* backend);
 
     // SyncManager::Observer implementation.  The Core just acts like an air
     // traffic controller here, forwarding incoming messages to appropriate
     // landing threads.
     virtual void OnChangesApplied(
         syncable::ModelType model_type,
         const sync_api::BaseTransaction* trans,
         const sync_api::SyncManager::ChangeRecord* changes,
         int change_count) OVERRIDE;
     virtual void OnChangesComplete(
@@ skipping 168 matching lines @@
         sessions::SyncSessionSnapshot* snapshot);
 
     void HandleStopSyncingPermanentlyOnFrontendLoop();
 
     // Called to handle success/failure of clearing server data
     void HandleClearServerDataSucceededOnFrontendLoop();
     void HandleClearServerDataFailedOnFrontendLoop();
 
     void FinishConfigureDataTypesOnFrontendLoop();
 
-    Profile* profile_;
+    // Name used for debugging.
+    const std::string name_;
 
     // Our parent SyncBackendHost
     SyncBackendHost* host_;
 
     // Our parent's registrar (not owned).  Non-NULL only between
     // calls to DoInitialize() and DoShutdown().
     SyncBackendRegistrar* registrar_;
 
     // The timer used to periodically call SaveChanges.
     base::RepeatingTimer<Core> save_changes_timer_;
@@ skipping 65 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_