[Sync] Tidy up SyncBackendHost interface.

chrome/browser/sync/glue/sync_backend_host.h

 // Copyright (c) 2010 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 53 matching lines @@
   virtual void OnAuthError() = 0;
 
   // We are no longer permitted to communicate with the server. Sync should
   // be disabled and state cleaned up at once.
   virtual void OnStopSyncingPermanently() = 0;
 
   // Called to handle success/failure of clearing server data
   virtual void OnClearServerDataSucceeded() = 0;
   virtual void OnClearServerDataFailed() = 0;
 
+  // The syncer requires a passphrase to decrypt sensitive
+  // updates. This is called when the first sensitive data type is
+  // setup by the user as well as anytime any the passphrase is
+  // changed in another synced client.  if
+  // |passphrase_required_for_decryption| is false, the passphrase is
+  // required only for encryption.
+  virtual void OnPassphraseRequired(bool for_decryption) = 0;
+
+  // Called when the passphrase provided by the user is
+  // accepted. After this is called, updates to sensitive nodes are
+  // encrypted using the accepted passphrase.
+  virtual void OnPassphraseAccepted() = 0;

[tim (not reviewing), 2011/01/19 20:42:53]

sweet, so you gonna write a sync_backend_host_unittest now? :)

+
  protected:
   // Don't delete through SyncFrontend interface.
   virtual ~SyncFrontend() {
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncFrontend);
 };
 
 // A UI-thread safe API into the sync backend that "hosts" the top-level
 // syncapi element, the SyncManager, on its own thread. This class handles
 // dispatch of potentially blocking calls to appropriate threads and ensures
 // that the SyncFrontend is only accessed on the UI loop.
 class SyncBackendHost : public browser_sync::ModelSafeWorkerRegistrar {
  public:
   typedef sync_api::UserShare* UserShareHandle;
   typedef sync_api::SyncManager::Status::Summary StatusSummary;
   typedef sync_api::SyncManager::Status Status;
   typedef std::map<ModelSafeGroup,
                    scoped_refptr<browser_sync::ModelSafeWorker> > WorkerMap;
 
   // 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).
-  SyncBackendHost(SyncFrontend* frontend,
-                  Profile* profile,
-                  const FilePath& profile_path,
-                  const DataTypeController::TypeMap& data_type_controllers);
+  SyncBackendHost(SyncFrontend* frontend, Profile* profile);
   // For testing.
   // TODO(skrul): Extract an interface so this is not needed.
   SyncBackendHost();
   ~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(const GURL& service_url,
@@ skipping 21 matching lines @@
 
   // 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.
-  virtual void ConfigureDataTypes(const syncable::ModelTypeSet& types,
-                                  CancelableTask* ready_task);
+  virtual void ConfigureDataTypes(
+      const DataTypeController::TypeMap& data_type_controllers,
+      const syncable::ModelTypeSet& types,
+      CancelableTask* ready_task);
 
   syncable::AutofillMigrationState
       GetAutofillMigrationState();
 
   void SetAutofillMigrationState(
       syncable::AutofillMigrationState state);
 
   syncable::AutofillMigrationDebugInfo
       GetAutofillMigrationDebugInfo();
 
@@ skipping 345 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_;
 
-  // List of registered data type controllers.
-  DataTypeController::TypeMap data_type_controllers_;
-
   // A task that should be called once data type configuration is
   // complete.
   scoped_ptr<CancelableTask> configure_ready_task_;
 
   // The set of types that we are waiting to be initially synced in a
   // configuration cycle.
   syncable::ModelTypeSet configure_initial_sync_types_;
 
   // 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_;
 
   // 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_