[Sync] Cache encrypted types info in ProfileSyncService

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 72 matching lines @@
   // the passphrase is changed by another synced client. |reason| denotes why
   // the passphrase was required.
   virtual void OnPassphraseRequired(
       sync_api::PassphraseRequiredReason reason) = 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;
 
-  virtual void OnEncryptionComplete(
-      const syncable::ModelTypeSet& encrypted_types) = 0;
+  // Called when the set of encrypted types or the encrypt everything
+  // flag has been changed.  Note that encryption isn't complete until
+  // the OnEncryptionComplete() notification has been sent (see
+  // below).
+  //
+  // |encrypted_types| will always be a superset of
+  // Cryptographer::SensitiveTypes().  If |encrypt_everything| is
+  // true, |encrypted_types| will be the set of all known types.
+  //
+  // Until this function is called, observers can assume that the set
+  // of encrypted types is Cryptographer::SensitiveTypes() and that
+  // the encrypt everything flag is false.
+  virtual void OnEncryptedTypesChanged(
+      const syncable::ModelTypeSet& encrypted_types,
+      bool encrypt_everything) = 0;
+
+  // Called after we finish encrypting the current set of encrypted
+  // types.
+  virtual void OnEncryptionComplete() = 0;
 
   // Called to perform migration of |types|.
   virtual void OnMigrationNeededForTypes(
       const syncable::ModelTypeSet& types) = 0;
 
   // Inform the Frontend that new datatypes are available for registration.
   virtual void OnDataTypesChanged(const syncable::ModelTypeSet& to_add) = 0;
 
   // Called when the sync cycle returns there is an user actionable error.
   virtual void OnActionableError(
@@ skipping 77 matching lines @@
       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(const base::Closure& callback);
 
   // Turns on encryption of all present and future sync data.
   virtual void EnableEncryptEverything();
 
-  // Returns true if we have enabled encrypt everything, false if we only
-  // encrypt the sensitive types.
-  virtual bool EncryptEverythingEnabled() const;
-
-  // Returns the set of encrypted data types.
-  virtual 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(
       syncable::ModelType type, ModelSafeGroup group,
       ChangeProcessor* change_processor);
 
   // Deactivates change processing for the given data type.
   void DeactivateDataType(syncable::ModelType type);
@@ skipping 73 matching lines @@
     virtual void OnAuthError(
         const GoogleServiceAuthError& auth_error) OVERRIDE;
     virtual void OnPassphraseRequired(
         sync_api::PassphraseRequiredReason reason) OVERRIDE;
     virtual void OnPassphraseAccepted(
         const std::string& bootstrap_token) OVERRIDE;
     virtual void OnStopSyncingPermanently() OVERRIDE;
     virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
     virtual void OnClearServerDataFailed() OVERRIDE;
     virtual void OnClearServerDataSucceeded() OVERRIDE;
-    virtual void OnEncryptionComplete(
-        const syncable::ModelTypeSet& encrypted_types);
+    virtual void OnEncryptedTypesChanged(
+        const syncable::ModelTypeSet& encrypted_types,
+        bool encrypt_everything) OVERRIDE;
+    virtual void OnEncryptionComplete() OVERRIDE;
     virtual void OnActionableError(
-        const browser_sync::SyncProtocolError& sync_error);
+        const browser_sync::SyncProtocolError& sync_error) OVERRIDE;
 
     struct DoInitializeOptions {
       DoInitializeOptions(
           MessageLoop* sync_loop,
           SyncBackendRegistrar* registrar,
           const WeakHandle<JsEventHandler>& event_handler,
           const GURL& service_url,
           const scoped_refptr<net::URLRequestContextGetter>&
               request_context_getter,
           const sync_api::SyncCredentials& credentials,
@@ skipping 132 matching lines @@
     // Invoked when a passphrase is required to decrypt a set of Nigori keys,
     // or for encrypting. |reason| denotes why the passhrase was required.
     void NotifyPassphraseRequired(sync_api::PassphraseRequiredReason reason);
 
     // Invoked when the passphrase provided by the user has been accepted.
     void NotifyPassphraseAccepted(const std::string& bootstrap_token);
 
     // Invoked when an updated token is available from the sync server.
     void NotifyUpdatedToken(const std::string& token);
 
-    // Invoked when sync finishes encrypting new datatypes or has become aware
-    // of new datatypes requiring encryption.
-    void NotifyEncryptionComplete(const syncable::ModelTypeSet&
-                                      encrypted_types);
+    // Invoked when the set of encrypted types or the encrypt
+    // everything flag changes.
+    void NotifyEncryptedTypesChanged(
+        const syncable::ModelTypeSet& encrypted_types,
+        bool encrypt_everything);
+
+    // Invoked when sync finishes encrypting new datatypes.
+    void NotifyEncryptionComplete();
 
     // Called from Core::OnSyncCycleCompleted to handle updating frontend
     // thread components.
     void HandleSyncCycleCompletedOnFrontendLoop(
         sessions::SyncSessionSnapshot* snapshot);
 
     void HandleStopSyncingPermanentlyOnFrontendLoop();
 
     // Called to handle success/failure of clearing server data
     void HandleClearServerDataSucceededOnFrontendLoop();
@@ skipping 120 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_