sync: hook up ServerConnectionManager <> SyncerThread2 and tie up more loose ends

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 370 matching lines @@
     void DeleteSyncDataFolder();
 
     void ConnectChildJsEventRouter();
 
     void DisconnectChildJsEventRouter();
 
     void DoProcessMessage(
         const std::string& name, const JsArgList& args,
         const JsEventHandler* sender);
 
+    // A callback from the SyncerThread when it is safe to continue config.
+    void FinishConfigureDataTypes();
+
 #if defined(UNIT_TEST)
     // Special form of initialization that does not try and authenticate the
     // last known user (since it will fail in test mode) and does some extra
     // setup to nudge the syncapi into a usable state.
     void DoInitializeForTest(const std::wstring& test_user,
                              sync_api::HttpPostProviderFactory* factory,
                              bool delete_sync_data_folder) {
       // Construct dummy credentials for test.
       sync_api::SyncCredentials credentials;
       credentials.email = WideToUTF8(test_user);
@@ skipping 74 matching lines @@
     void HandleClearServerDataFailedOnFrontendLoop();
 
     // Called from Core::OnInitializationComplete to handle updating
     // frontend thread components.
     void HandleInitalizationCompletedOnFrontendLoop();
 
     void RouteJsEventOnFrontendLoop(
         const std::string& name, const JsArgList& args,
         const JsEventHandler* dst);
 
+    void FinishConfigureDataTypesOnFrontendLoop();
+
     // Return true if a model lives on the current thread.
     bool IsCurrentThreadSafeForModel(syncable::ModelType model_type);
 
     // Our parent SyncBackendHost
     SyncBackendHost* host_;
 
     // The timer used to periodically call SaveChanges.
     base::RepeatingTimer<Core> save_changes_timer_;
 
     // The top-level syncapi entry point.
@@ skipping 20 matching lines @@
   // on to |frontend_|, and so that tests can intercept here if they need to
   // set up initial conditions.
   virtual void HandleInitializationCompletedOnFrontendLoop();
 
   // Posts a nudge request on the core thread.
   virtual void RequestNudge();
 
   // Posts a config request on the core thread.
   virtual void RequestConfig(const syncable::ModelTypeBitSet& added_types);
 
+  // Called to finish the job of ConfigureDataTypes once the syncer is in
+  // configuration mode.
+  void FinishConfigureDataTypes();
+  void FinishConfigureDataTypesOnFrontendLoop();
+
   // Allows tests to perform alternate core initialization work.
   virtual void InitCore(const Core::DoInitializeOptions& options);
 
   // Factory method for HttpPostProviderFactories.
   virtual sync_api::HttpPostProviderFactory* MakeHttpBridgeFactory(
       URLRequestContextGetter* getter);
 
   MessageLoop* core_loop() { return core_thread_.message_loop(); }
 
   void set_syncapi_initialized() { syncapi_initialized_ = true; }
 
   // Helpers to persist a token that can be used to bootstrap sync encryption
   // across browser restart to avoid requiring the user to re-enter their
   // passphrase.  |token| must be valid UTF-8 as we use the PrefService for
   // storage.
   void PersistEncryptionBootstrapToken(const std::string& token);
   std::string RestoreEncryptionBootstrapToken();
 
   // Our core, which communicates directly to the syncapi.
   scoped_refptr<Core> core_;
 
  private:
   UIModelWorker* ui_worker();
 
   void ConfigureAutofillMigration();
 
-  // Depending on switches::kUseNewSyncerThread, kicks the syncapi to respond
-  // to a change in the set of enabled data types.
-  void ScheduleSyncEventForConfigChange(
-      bool deleted_type,
-      const syncable::ModelTypeBitSet& added_types);
-
   // A thread we dedicate for use by our Core to perform initialization,
   // authentication, handle messages from the syncapi, and periodically tell
   // the syncapi to persist itself.
   base::Thread core_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_;
@@ skipping 26 matching lines @@
 
   // The frontend which we serve (and are owned by).
   SyncFrontend* frontend_;
 
   // The change processors that handle the different data types.
   std::map<syncable::ModelType, ChangeProcessor*> processors_;
 
   // Path of the folder that stores the sync data files.
   FilePath sync_data_folder_path_;
 
-  // A task that should be called once data type configuration is
-  // complete.
-  scoped_ptr<CancelableTask> configure_ready_task_;
+  struct PendingConfigureDataTypesState {
+    PendingConfigureDataTypesState();
+    // A task that should be called once data type configuration is
+    // complete.
+    scoped_ptr<CancelableTask> ready_task;
 
-  // The set of types that we are waiting to be initially synced in a
-  // configuration cycle.
-  syncable::ModelTypeSet configure_initial_sync_types_;
+    // The set of types that we are waiting to be initially synced in a
+    // configuration cycle.
+    syncable::ModelTypeSet initial_types;
+
+    // Additional details about which types were added / removed.
+    bool deleted_type;
+    syncable::ModelTypeBitSet added_types;
+  };
+
+  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_;
 
   // While two impls are in flight, using this for sanity checking. Bug 26339.
   const bool using_new_syncer_thread_;
 
   // Whether we've processed the initialization complete callback.
   bool syncapi_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_