Take 2: sync changes to support encryption

chrome/browser/sync/glue/sync_backend_host.h

 // Copyright (c) 2006-2008 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_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 98 matching lines @@
                   bool invalidate_sync_xmpp_login,
                   NotificationMethod notification_method);
 
   // Called on |frontend_loop_| to kick off asynchronous authentication.
   void Authenticate(const std::string& username, const std::string& password,
                     const std::string& captcha);
 
   // Called on |frontend_loop_| to start syncing.
   void StartSyncing();
 
+  // Called on |frontend_loop_| to asynchronously set the passphrase.
+  void SetPassphrase(const std::string& passphrase);
+
   // 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,
@@ skipping 55 matching lines @@
                              bool delete_sync_data_folder,
                              NotificationMethod notification_method) {
     if (!core_thread_.Start())
       return;
     registrar_.workers[GROUP_UI] = new UIModelWorker(frontend_loop_);
     registrar_.routing_info[syncable::BOOKMARKS] = GROUP_PASSIVE;
     registrar_.routing_info[syncable::PREFERENCES] = GROUP_PASSIVE;
     registrar_.routing_info[syncable::AUTOFILL] = GROUP_PASSIVE;
     registrar_.routing_info[syncable::THEMES] = GROUP_PASSIVE;
     registrar_.routing_info[syncable::TYPED_URLS] = GROUP_PASSIVE;
+    registrar_.routing_info[syncable::NIGORI] = GROUP_PASSIVE;
     registrar_.routing_info[syncable::PASSWORDS] = GROUP_PASSIVE;
 
     core_thread_.message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(core_.get(),
         &SyncBackendHost::Core::DoInitializeForTest,
         test_user,
         network_change_notifier_thread,
         factory,
         auth_factory,
         delete_sync_data_folder,
@@ skipping 13 matching lines @@
     // landing threads.
     virtual void OnChangesApplied(
         syncable::ModelType model_type,
         const sync_api::BaseTransaction* trans,
         const sync_api::SyncManager::ChangeRecord* changes,
         int change_count);
     virtual void OnSyncCycleCompleted(
         const sessions::SyncSessionSnapshot* snapshot);
     virtual void OnInitializationComplete();
     virtual void OnAuthError(const GoogleServiceAuthError& auth_error);
+    virtual void OnPassphraseRequired();
+    virtual void OnPassphraseAccepted();
     virtual void OnPaused();
     virtual void OnResumed();
 
     struct DoInitializeOptions {
       DoInitializeOptions(
           const GURL& service_url,
           bool attempt_last_user_authentication,
           chrome_common_net::NetworkChangeNotifierThread*
               network_change_notifier_thread,
           sync_api::HttpPostProviderFactory* http_bridge_factory,
@@ skipping 40 matching lines @@
     // Called on our SyncBackendHost's core_thread_ to perform authentication
     // on behalf of SyncBackendHost::Authenticate.
     void DoAuthenticate(const std::string& username,
                         const std::string& password,
                         const std::string& captcha);
 
     // Called on the SyncBackendHost core_thread_ to tell the syncapi to start
     // syncing (generally after initialization and authentication).
     void DoStartSyncing();
 
+    // Called on our SyncBackendHost's |core_thread_| to set the passphrase
+    // on behalf of SyncBackendHost::SupplyPassphrase.
+    void DoSetPassphrase(const std::string& passphrase);
+
     // The shutdown order is a bit complicated:
     // 1) From |core_thread_|, invoke the syncapi Shutdown call to do a final
     //    SaveChanges, close sqlite handles, and halt the syncer thread (which
     //    could potentially block for 1 minute).
     // 2) Then, from |frontend_loop_|, halt the core_thread_. 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);
@@ skipping 56 matching lines @@
     // SyncBackendHost |core_thread_|), using a repeating timer that is kicked
     // off as soon as the SyncManager tells us it completed
     // initialization.
     void SaveChanges();
 
     // Dispatched to from HandleAuthErrorEventOnCoreLoop to handle updating
     // frontend UI components.
     void HandleAuthErrorEventOnFrontendLoop(
         const GoogleServiceAuthError& new_auth_error);
 
+    // Invoked when a passphrase is required to decrypt a set of Nigori keys.
+    void NotifyPassphraseRequired();
+
+    // Invoked when the passphrase provided by the user has been accepted.
+    void NotifyPassphraseAccepted();
+
     // Called from Core::OnSyncCycleCompleted to handle updating frontend
     // thread components.
     void HandleSyncCycleCompletedOnFrontendLoop(
         sessions::SyncSessionSnapshot* snapshot);
 
     // Called from Core::OnInitializationComplete to handle updating
     // frontend thread components.
     void HandleInitalizationCompletedOnFrontendLoop();
 
     // Return true if a model lives on the current thread.
@@ skipping 78 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_