[Sync] Split encryption state and logic out of PSS and SBHI.

components/sync/engine/sync_engine.h

 // Copyright 2012 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 COMPONENTS_SYNC_ENGINE_SYNC_ENGINE_H_
 #define COMPONENTS_SYNC_ENGINE_SYNC_ENGINE_H_
 
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 38 matching lines @@
 
   // Utility struct for holding initialization options.
   struct InitParams {
     InitParams();
     InitParams(InitParams&& other);
     ~InitParams();
 
     scoped_refptr<base::SingleThreadTaskRunner> sync_task_runner;
     SyncEngineHost* host = nullptr;
     std::unique_ptr<SyncBackendRegistrar> registrar;
+    std::unique_ptr<SyncEncryptionHandler::Observer> encryption_observer_proxy;
     scoped_refptr<ExtensionsActivity> extensions_activity;
     WeakHandle<JsEventHandler> event_handler;
     GURL service_url;
     std::string sync_user_agent;
     SyncEngine::HttpPostProviderFactoryGetter http_factory_getter;
     SyncCredentials credentials;
     std::string invalidator_client_id;
     std::unique_ptr<SyncManagerFactory> sync_manager_factory;
     bool delete_sync_data_folder = false;
     bool enable_local_sync_backend = false;
@@ skipping 42 matching lines @@
   // - |is_explicit| is true and we have pending keys.
   // When |is_explicit| is false, a couple of things could happen:
   // - If there are pending keys, we try to decrypt them. If decryption works,
   //   this acts like a call to SetDecryptionPassphrase. If not, the GAIA
   //   passphrase passed in is cached so we can re-encrypt with it in future.
   // - If there are no pending keys, data is encrypted with |passphrase| (this
   //   is a no-op if data was already encrypted with |passphrase|.)
   virtual void SetEncryptionPassphrase(const std::string& passphrase,
                                        bool is_explicit) = 0;
 
-  // Use the provided passphrase to asynchronously attempt decryption. Returns
-  // false immediately if the passphrase could not be used to decrypt a locally
-  // cached copy of encrypted keys; returns true otherwise. If new encrypted
-  // keys arrive during the asynchronous call, OnPassphraseRequired may be
-  // triggered at a later time. It is an error to call this when there are no
-  // pending keys.
-  virtual bool SetDecryptionPassphrase(const std::string& passphrase)
-      WARN_UNUSED_RESULT = 0;
+  // Use the provided passphrase to asynchronously attempt decryption. If new
+  // encrypted keys arrive during the asynchronous call, OnPassphraseRequired
+  // may be triggered at a later time. It is an error to call this when there
+  // are no pending keys.
+  virtual void SetDecryptionPassphrase(const std::string& passphrase) = 0;
 
   // Kick off shutdown procedure. Attempts to cut short any long-lived or
   // blocking sync thread tasks so that the shutdown on sync thread task that
   // we're about to post won't have to wait very long.
   virtual void StopSyncingForShutdown() = 0;
 
   // See the implementation and Core::DoShutdown for details.
   // Must be called *after* StopSyncingForShutdown.
   virtual void Shutdown(ShutdownReason reason) = 0;
 
   // Turns on encryption of all present and future sync data.
   virtual void EnableEncryptEverything() = 0;
 
   // Obtain a handle to the UserShare needed for creating transactions. Should
   // not be called before we signal initialization is complete with
   // OnBackendInitialized().
   virtual UserShare* GetUserShare() const = 0;
 
   // Called from any thread to obtain current detailed status information.
   virtual Status GetDetailedStatus() = 0;
 
   // Determines if the underlying sync engine has made any local changes to
   // items that have not yet been synced with the server.
   // ONLY CALL THIS IF OnInitializationComplete was called!
   virtual bool HasUnsyncedItems() const = 0;
 
-  // Whether or not we are syncing encryption keys.
-  virtual bool IsNigoriEnabled() const = 0;
-
-  // Returns the type of passphrase being used to encrypt data. See
-  // sync_encryption_handler.h.
-  virtual PassphraseType GetPassphraseType() const = 0;
-
-  // If an explicit passphrase is in use, returns the time at which that
-  // passphrase was set (if available).
-  virtual base::Time GetExplicitPassphraseTime() const = 0;
-
   // True if the cryptographer has any keys available to attempt decryption.
   // Could mean we've downloaded and loaded Nigori objects, or we bootstrapped
   // using a token previously received.
   virtual bool IsCryptographerReady(const BaseTransaction* trans) const = 0;
 
   virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) const = 0;
 
   // Send a message to the sync thread to persist the Directory to disk.
   virtual void FlushDirectory() const = 0;
 
@@ skipping 25 matching lines @@
   // See SyncManager::OnCookieJarChanged.
   virtual void OnCookieJarChanged(bool account_mismatch, bool empty_jar) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncEngine);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_ENGINE_SYNC_ENGINE_H_