[Sync] Refactor GetEncryptedTypes usage.

sync/engine/syncer_util.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/engine/syncer_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
+#include "sync/syncable/nigori_handler.h"
 #include "sync/syncable/nigori_util.h"
 #include "sync/syncable/read_transaction.h"
 #include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 #include "sync/util/time.h"
 
 namespace syncer {
@@ skipping 175 matching lines @@
   // preserve the encryption keys based on the local passphrase, while the
   // nigori node will preserve the server encryption keys.
   //
   // If non-encryption changes are made to the nigori node, they will be
   // lost as part of conflict resolution. This is intended, as we place a higher
   // priority on preserving the server's passphrase change to preserving local
   // non-encryption changes. Next time the non-encryption changes are made to
   // the nigori node (e.g. on restart), they will commit without issue.
   if (specifics.has_nigori()) {
     const sync_pb::NigoriSpecifics& nigori = specifics.nigori();
-    cryptographer->ApplyNigoriUpdate(nigori, trans);
+    trans->directory()->GetNigoriHandler()->ApplyNigoriUpdate(nigori, trans);
 
     // Make sure any unsynced changes are properly encrypted as necessary.
     // We only perform this if the cryptographer is ready. If not, these are
     // re-encrypted at SetDecryptionPassphrase time (via ReEncryptEverything).
     // This logic covers the case where the nigori update marked new datatypes
     // for encryption, but didn't change the passphrase.
     if (cryptographer->is_ready()) {
       // Note that we don't bother to encrypt any data for which IS_UNSYNCED
       // == false here. The machine that turned on encryption should know about
       // and re-encrypt all synced data. It's possible it could get interrupted
       // during this process, but we currently reencrypt everything at startup
       // as well, so as soon as a client is restarted with this datatype marked
       // for encryption, all the data should be updated as necessary.
 
       // If this fails, something is wrong with the cryptographer, but there's
       // nothing we can do about it here.
       DVLOG(1) << "Received new nigori, encrypting unsynced changes.";
-      syncable::ProcessUnsyncedChangesForEncryption(trans, cryptographer);
+      syncable::ProcessUnsyncedChangesForEncryption(trans);
     }
   }
 
   // Only apply updates that we can decrypt. If we can't decrypt the update, it
   // is likely because the passphrase has not arrived yet. Because the
   // passphrase may not arrive within this GetUpdates, we can't just return
   // conflict, else we try to perform normal conflict resolution prematurely or
   // the syncer may get stuck. As such, we return CONFLICT_ENCRYPTION, which is
   // treated as an unresolvable conflict. See the description in syncer_types.h.
   // This prevents any unsynced changes from commiting and postpones conflict
@@ skipping 443 matching lines @@
   if (update.version() < target->Get(SERVER_VERSION)) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace syncer