[Sync] Refactor GetEncryptedTypes usage.

sync/util/cryptographer.cc

 // 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.
 
 #include "sync/util/cryptographer.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "sync/protocol/nigori_specifics.pb.h"
-#include "sync/syncable/nigori_handler.h"
 #include "sync/util/encryptor.h"
 
 namespace syncer {
 
 const char kNigoriTag[] = "google_chrome_nigori";
 
 // We name a particular Nigori instance (ie. a triplet consisting of a hostname,
 // a username, and a password) by calling Permute on this string. Since the
 // output of Permute is always the same for a given triplet, clients will always
 // assign the same name to a particular triplet.
 const char kNigoriKeyName[] = "nigori-key";
 
 Cryptographer::Cryptographer(Encryptor* encryptor)
     : encryptor_(encryptor),
       default_nigori_(NULL),
-      keystore_nigori_(NULL),
-      nigori_node_handler_(NULL) {
+      keystore_nigori_(NULL) {
   DCHECK(encryptor);
 }
 
 Cryptographer::~Cryptographer() {}
 
-void Cryptographer::SetNigoriHandler(syncable::NigoriHandler* delegate) {
-  nigori_node_handler_ = delegate;
-}
-
-void Cryptographer::ApplyNigoriUpdate(
-    const sync_pb::NigoriSpecifics& nigori,
-    syncable::BaseTransaction* const trans) {
-  nigori_node_handler_->ApplyNigoriUpdate(nigori, trans);
-}
-
-ModelTypeSet Cryptographer::GetEncryptedTypes() const {
-  return nigori_node_handler_->GetEncryptedTypes();
-}
-
-void Cryptographer::UpdateNigoriFromEncryptedTypes(
-    sync_pb::NigoriSpecifics* nigori,
-    syncable::BaseTransaction* const trans) const {
-  nigori_node_handler_->UpdateNigoriFromEncryptedTypes(nigori, trans);
-}
-
 
 void Cryptographer::Bootstrap(const std::string& restored_bootstrap_token) {
   if (is_initialized()) {
     NOTREACHED();
     return;
   }
 
   scoped_ptr<Nigori> nigori(UnpackBootstrapToken(restored_bootstrap_token));
   if (nigori.get())
     AddKeyImpl(nigori.release(), false);
@@ skipping 141 matching lines @@
   InstallKeyBag(bag);
 }
 
 void Cryptographer::SetDefaultKey(const std::string& key_name) {
   DCHECK(nigoris_.end() != nigoris_.find(key_name));
   default_nigori_ = &*nigoris_.find(key_name);
 }
 
 void Cryptographer::SetPendingKeys(const sync_pb::EncryptedData& encrypted) {
   DCHECK(!CanDecrypt(encrypted));
+  DCHECK(!encrypted.blob().empty());
   pending_keys_.reset(new sync_pb::EncryptedData(encrypted));
 }
 
 const sync_pb::EncryptedData& Cryptographer::GetPendingKeys() const {
   DCHECK(has_pending_keys());
   return *(pending_keys_.get());
 }
 
 bool Cryptographer::DecryptPendingKeys(const KeyParams& params) {
   Nigori nigori;
@@ skipping 135 matching lines @@
                                     key.mac_key())) {
         NOTREACHED();
         continue;
       }
       nigoris_[key.name()] = make_linked_ptr(new_nigori.release());
     }
   }
 }
 
 }  // namespace syncer