[Sync] Refactor data type configuration/activation/deactivation

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>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
 #include "chrome/browser/sync/engine/configure_reason.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
-#include "chrome/browser/sync/engine/syncapi.h"
-#include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/ui_model_worker.h"
 #include "chrome/browser/sync/js/js_backend.h"
 #include "chrome/browser/sync/notifier/sync_notifier_factory.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/weak_handle.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_context_getter.h"
 
 class CancelableTask;
 class Profile;
 
 namespace net {
 class URLRequestContextGetter;
 }
 
 namespace browser_sync {
 
 namespace sessions {
 struct SyncSessionSnapshot;
 }
 
 class ChangeProcessor;
-class DataTypeController;
 class JsEventHandler;
 
 // SyncFrontend is the interface used by SyncBackendHost to communicate with
 // the entity that created it and, presumably, is interested in sync-related
 // activity.
 // NOTE: All methods will be invoked by a SyncBackendHost on the same thread
 // used to create that SyncBackendHost.
 class SyncFrontend {
  public:
   SyncFrontend() {}
@@ skipping 66 matching lines @@
   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,
                   const WeakHandle<JsEventHandler>& event_handler,
                   const GURL& service_url,
-                  const syncable::ModelTypeSet& types,
+                  const syncable::ModelTypeSet& initial_types,
                   const sync_api::SyncCredentials& credentials,
                   bool delete_sync_data_folder);
 
   // Called from |frontend_loop| to update SyncCredentials.
   void UpdateCredentials(const sync_api::SyncCredentials& credentials);
 
   // This starts the SyncerThread running a Syncer object to communicate with
   // sync servers.  Until this is called, no changes will leave or enter this
   // browser from the cloud / sync servers.
   // Called on |frontend_loop_|.
   virtual void StartSyncingWithServer();
 
   // Called on |frontend_loop_| to asynchronously set the passphrase.
   // |is_explicit| is true if the call is in response to the user explicitly
   // setting a passphrase as opposed to implicitly (from the users' perspective)
   // using their Google Account password.  An implicit SetPassphrase will *not*
   // *not* override an explicit passphrase set previously.
   void SetPassphrase(const std::string& passphrase, bool is_explicit);
 
   // Called on |frontend_loop_| to kick off shutdown.
   // |sync_disabled| indicates if syncing is being disabled or not.
   // See the implementation and Core::DoShutdown for details.
   void Shutdown(bool sync_disabled);
 
   // Changes the set of data types that are currently being synced.
   // The ready_task will be run when all of the requested data types
-  // are up-to-date and ready for activation.  The task will cancelled
-  // upon shutdown.  The method takes ownership of the task pointer.
+  // are up-to-date and ready for activation.  The task will be
+  // cancelled upon shutdown.
   virtual void ConfigureDataTypes(
-      const DataTypeController::TypeMap& data_type_controllers,
-      const syncable::ModelTypeSet& types,
+      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);
 
   // 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;
 
   // 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(DataTypeController* data_type_controller,
-                        ChangeProcessor* change_processor);
+  void ActivateDataType(
+      syncable::ModelType type, ModelSafeGroup group,
+      ChangeProcessor* change_processor);
 
   // Deactivates change processing for the given data type.
-  void DeactivateDataType(DataTypeController* data_type_controller,
-                          ChangeProcessor* change_processor);
+  void DeactivateDataType(syncable::ModelType type);
 
   // Asks the server to clear all data associated with ChromeSync.
   virtual bool RequestClearServerData();
 
   // Called on |frontend_loop_| to obtain a handle to the UserShare needed
   // for creating transactions.
   sync_api::UserShare* GetUserShare() const;
 
   // Called from any thread to obtain current status information in detailed or
   // summarized form.
@@ skipping 145 matching lines @@
     // 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(const syncable::ModelTypeBitSet& added_types,
+    virtual void DoRequestConfig(
+        const syncable::ModelTypeBitSet& types_to_config,
         sync_api::ConfigureReason reason);
 
     // Start the configuration mode.
     virtual void DoStartConfiguration(Callback0::Type* 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.
 
     sync_api::SyncManager* sync_manager() { return sync_manager_.get(); }
@@ skipping 30 matching lines @@
                                        "", true));
     }
 #endif
 
    private:
     friend class base::RefCountedThreadSafe<SyncBackendHost::Core>;
     friend class SyncBackendHostForProfileSyncTest;
 
     virtual ~Core();
 
-    // Return change processor for a particular model (return NULL on failure).
-    ChangeProcessor* GetProcessor(syncable::ModelType modeltype);
-
     // Invoked when initialization of syncapi is complete and we can start
     // our timer.
     // This must be called from the thread on which SaveChanges is intended to
     // be run on; the host's |sync_thread_|.
     void StartSavingChanges();
 
     // Invoked periodically to tell the syncapi to persist its state
     // by writing to disk.
     // This is called from the thread we were created on (which is the
     // SyncBackendHost |sync_thread_|), using a repeating timer that is kicked
@@ skipping 27 matching lines @@
         sessions::SyncSessionSnapshot* snapshot);
 
     void HandleStopSyncingPermanentlyOnFrontendLoop();
 
     // Called to handle success/failure of clearing server data
     void HandleClearServerDataSucceededOnFrontendLoop();
     void HandleClearServerDataFailedOnFrontendLoop();
 
     void FinishConfigureDataTypesOnFrontendLoop();
 
-    // Return true if a model lives on the current thread.
-    bool IsCurrentThreadSafeForModel(syncable::ModelType model_type);
-
     Profile* profile_;
 
     // Our parent SyncBackendHost
     SyncBackendHost* host_;
 
     // The timer used to periodically call SaveChanges.
     base::RepeatingTimer<Core> save_changes_timer_;
 
     // The top-level syncapi entry point.  Lives on the sync thread.
     scoped_ptr<sync_api::SyncManager> sync_manager_;
@@ skipping 47 matching lines @@
   struct PendingConfigureDataTypesState {
     PendingConfigureDataTypesState();
     ~PendingConfigureDataTypesState();
 
     // A task that should be called once data type configuration is
     // complete.
     base::Callback<void(bool)> ready_task;
 
     // The set of types that we are waiting to be initially synced in a
     // configuration cycle.
-    syncable::ModelTypeSet initial_types;
+    syncable::ModelTypeSet types_to_add;
 
     // Additional details about which types were added.
-    syncable::ModelTypeBitSet added_types;
+    syncable::ModelTypeSet added_types;
     sync_api::ConfigureReason reason;
   };
 
   UIModelWorker* ui_worker();
 
-  // Helper function for ConfigureDataTypes() that fills in |state|
-  // and |deleted_type|.  Does not take ownership of routing_info|.
+  // Return change processor for a particular model (return NULL on failure).
+  ChangeProcessor* GetProcessor(syncable::ModelType modeltype);
+
+  // Like GetProcessor(), but |registrar_lock_| must already be
+  // held.
+  ChangeProcessor* GetProcessorUnsafe(syncable::ModelType modeltype);
+
+  // Return true if a model lives on the current thread.
+  bool IsCurrentThreadSafeForModel(syncable::ModelType model_type) const;
+
+  // Helper function for ConfigureDataTypes() that fills in |state|.
+  // Does not take ownership of |routing_info|.
   static void GetPendingConfigModeState(
-      const DataTypeController::TypeMap& data_type_controllers,
-      const syncable::ModelTypeSet& types,
+      const syncable::ModelTypeSet& types_to_add,
+      const syncable::ModelTypeSet& types_to_remove,
       base::Callback<void(bool)> ready_task,
       ModelSafeRoutingInfo* routing_info,
       sync_api::ConfigureReason reason,
-      bool nigori_enabled,
-      PendingConfigureDataTypesState* state,
-      bool* deleted_type);
+      PendingConfigureDataTypesState* state);
 
   // 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_;
@@ skipping 45 matching lines @@
 
   // 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_