[Sync] Refactor GetEncryptedTypes usage.

sync/syncable/directory.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/syncable/directory.h"
 
 #include "base/debug/trace_event.h"
 #include "base/perftimer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 118 matching lines @@
   delete dirty_metahandles;
   delete metahandles_to_purge;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   STLDeleteElements(metahandles_index);
   delete metahandles_index;
 }
 
 Directory::Directory(
-    Encryptor* encryptor,
+    DirectoryBackingStore* store,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function,
-    DirectoryBackingStore* store)
-    : cryptographer_(encryptor),
-      kernel_(NULL),
+    NigoriHandler* nigori_handler,
+    Cryptographer* cryptographer)
+    : kernel_(NULL),
       store_(store),
       unrecoverable_error_handler_(unrecoverable_error_handler),
       report_unrecoverable_error_function_(
           report_unrecoverable_error_function),
       unrecoverable_error_set_(false),
+      nigori_handler_(nigori_handler),
+      cryptographer_(cryptographer),
       invariant_check_level_(VERIFY_CHANGES) {
 }
 
 Directory::~Directory() {
   Close();
 }
 
 DirOpenResult Directory::Open(
     const string& name,
     DirectoryChangeDelegate* delegate,
@@ skipping 549 matching lines @@
 void Directory::SetNotificationState(const std::string& notification_state) {
   ScopedKernelLock lock(this);
   SetNotificationStateUnsafe(notification_state);
 }
 
 string Directory::cache_guid() const {
   // No need to lock since nothing ever writes to it after load.
   return kernel_->cache_guid;
 }
 
+NigoriHandler* Directory::GetNigoriHandler() {
+  return nigori_handler_;
+}
+
 Cryptographer* Directory::GetCryptographer(const BaseTransaction* trans) {
   DCHECK_EQ(this, trans->directory());
-  return &cryptographer_;
+  return cryptographer_;
 }
 
 void Directory::GetAllMetaHandles(BaseTransaction* trans,
                                   MetahandleSet* result) {
   result->clear();
   ScopedKernelLock lock(this);
   MetahandlesIndex::iterator i;
   for (i = kernel_->metahandles_index->begin();
        i != kernel_->metahandles_index->end();
        ++i) {
@@ skipping 475 matching lines @@
   // There were no children in the linked list.
   return NULL;
 }
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 }  // namespace syncable
 }  // namespace syncer