[Sync] Refactor GetEncryptedTypes usage.

sync/util/cryptographer.h

 // Copyright (c) 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 SYNC_UTIL_CRYPTOGRAPHER_H_
 #define SYNC_UTIL_CRYPTOGRAPHER_H_
 
 #include <map>
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
-#include "sync/internal_api/public/base/model_type.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/util/nigori.h"
 
 namespace sync_pb {
 class NigoriKeyBag;
 class NigoriSpecifics;
 }
 
 namespace syncer {
 
 class Encryptor;
 
-namespace syncable {
-class BaseTransaction;
-class NigoriHandler;
-}
-
 extern const char kNigoriTag[];
 
 // The parameters used to initialize a Nigori instance.
 struct KeyParams {
   std::string hostname;
   std::string username;
   std::string password;
 };
 
 // This class manages the Nigori objects used to encrypt and decrypt sensitive
 // sync data (eg. passwords). Each Nigori object knows how to handle data
 // protected with a particular passphrase.
 //
 // Whenever an update to the Nigori sync node is received from the server,
 // SetPendingKeys should be called with the encrypted contents of that node.
 // Most likely, an updated Nigori node means that a new passphrase has been set
 // and that future node updates won't be decryptable. To remedy this, the user
 // should be prompted for the new passphrase and DecryptPendingKeys be called.
 //
 // Whenever a update to an encrypted node is received from the server,
 // CanDecrypt should be used to verify whether the Cryptographer can decrypt
 // that node. If it cannot, then the application of that update should be
 // delayed until after it can be decrypted.
 class Cryptographer {
  public:
   // Does not take ownership of |encryptor|.
   explicit Cryptographer(Encryptor* encryptor);
   ~Cryptographer();
 
-  // Set the sync nigori node handler.
-  // TODO(zea): refactor so that Cryptographer doesn't need any connection
-  // to a NigoriHandler. crbug.com/139848
-  void SetNigoriHandler(syncable::NigoriHandler* delegate);
-
-  // NigoriHandler delegator methods (passes through to delegate).
-  void ApplyNigoriUpdate(const sync_pb::NigoriSpecifics& nigori,
-                         syncable::BaseTransaction* const trans);
-  void UpdateNigoriFromEncryptedTypes(
-      sync_pb::NigoriSpecifics* nigori,
-      syncable::BaseTransaction* const trans) const;
-  ModelTypeSet GetEncryptedTypes() const;
-
   // |restored_bootstrap_token| can be provided via this method to bootstrap
   // Cryptographer instance into the ready state (is_ready will be true).
   // It must be a string that was previously built by the
   // GetSerializedBootstrapToken function.  It is possible that the token is no
   // longer valid (due to server key change), in which case the normal
   // decryption code paths will fail and the user will need to provide a new
   // passphrase.
   // It is an error to call this if is_ready() == true, though it is fair to
   // never call Bootstrap at all.
   void Bootstrap(const std::string& restored_bootstrap_token);
@@ skipping 118 matching lines @@
   Nigori* UnpackBootstrapToken(const std::string& token) const;
 
   Encryptor* const encryptor_;
 
   NigoriMap nigoris_;  // The Nigoris we know about, mapped by key name.
   NigoriMap::value_type* default_nigori_;  // The Nigori used for encryption.
   NigoriMap::value_type* keystore_nigori_; // Nigori generated from keystore.
 
   scoped_ptr<sync_pb::EncryptedData> pending_keys_;
 
-  // The sync nigori node handler. Necessary until we decouple the encrypted
-  // types from the cryptographer.
-  syncable::NigoriHandler* nigori_node_handler_;
-
   DISALLOW_COPY_AND_ASSIGN(Cryptographer);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_UTIL_CRYPTOGRAPHER_H_