[Sync] Refactor GetEncryptedTypes usage.

sync/syncable/directory.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_SYNCABLE_DIRECTORY_H_
 #define SYNC_SYNCABLE_DIRECTORY_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/gtest_prod_util.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/syncable/dir_open_result.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/scoped_kernel_lock.h"
-#include "sync/util/cryptographer.h"
 
 namespace syncer {
 
-class Encryptor;
+class Cryptographer;
 class UnrecoverableErrorHandler;
 
 namespace syncable {
 
+class BaseTransaction;
 class DirectoryChangeDelegate;
+class DirectoryBackingStore;
+class NigoriHandler;
+class ScopedKernelLock;
 class TransactionObserver;
-class BaseTransaction;
 class WriteTransaction;
-class ScopedKernelLock;
-class DirectoryBackingStore;
 
 // How syncable indices & Indexers work.
 //
 // The syncable Directory maintains several indices on the Entries it tracks.
 // The indices follow a common pattern:
 //   (a) The index allows efficient lookup of an Entry* with particular
 //       field values.  This is done by use of a std::set<> and a custom
 //       comparator.
 //   (b) There may be conditions for inclusion in the index -- for example,
 //       deleted items might not be indexed.
@@ skipping 155 matching lines @@
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     EntryKernelSet dirty_metas;
     MetahandleSet metahandles_to_purge;
   };
 
   // Does not take ownership of |encryptor|.
   // |report_unrecoverable_error_function| may be NULL.
   // Takes ownership of |store|.
   Directory(
-      Encryptor* encryptor,
+      DirectoryBackingStore* store,
       UnrecoverableErrorHandler* unrecoverable_error_handler,
       ReportUnrecoverableErrorFunction
           report_unrecoverable_error_function,
-      DirectoryBackingStore* store);
+      NigoriHandler* nigori_handler,
+      Cryptographer* cryptographer);
   virtual ~Directory();
 
   // Does not take ownership of |delegate|, which must not be NULL.
   // Starts sending events to |delegate| if the returned result is
   // OPENED.  Note that events to |delegate| may be sent from *any*
   // thread.  |transaction_observer| must be initialized.
   DirOpenResult Open(const std::string& name,
                      DirectoryChangeDelegate* delegate,
                      const WeakHandle<TransactionObserver>&
                          transaction_observer);
@@ skipping 33 matching lines @@
   // later.
   std::string store_birthday() const;
   void set_store_birthday(const std::string& store_birthday);
 
   std::string GetNotificationState() const;
   void SetNotificationState(const std::string& notification_state);
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
-  // Returns a pointer to our cryptographer.  Does not transfer ownership.  The
-  // cryptographer is not thread safe; it should not be accessed after the
-  // transaction has been released.
+  // Returns a pointer to our Nigori node handler.
+  NigoriHandler* GetNigoriHandler();
+
+  // Returns a pointer to our cryptographer. Does not transfer ownership.
+  // Not thread safe, so should only be accessed while holding a transaction.
   Cryptographer* GetCryptographer(const BaseTransaction* trans);
 
   // Returns true if the directory had encountered an unrecoverable error.
   // Note: Any function in |Directory| that can be called without holding a
   // transaction need to check if the Directory already has an unrecoverable
   // error on it.
   bool unrecoverable_error_set(const BaseTransaction* trans) const;
 
   // Called to immediately report an unrecoverable error (but don't
   // propagate it up).
@@ skipping 304 matching lines @@
   void AppendChildHandles(
       const ScopedKernelLock& lock,
       const Id& parent_id, Directory::ChildHandles* result);
 
   // Return a pointer to what is probably (but not certainly) the
   // first child of |parent_id|, or NULL if |parent_id| definitely has
   // no children.
   EntryKernel* GetPossibleFirstChild(
       const ScopedKernelLock& lock, const Id& parent_id);
 
-  Cryptographer cryptographer_;
-
   Kernel* kernel_;
 
   scoped_ptr<DirectoryBackingStore> store_;
 
   UnrecoverableErrorHandler* const unrecoverable_error_handler_;
   const ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 
+  // Not owned.
+  NigoriHandler* const nigori_handler_;
+  Cryptographer* const cryptographer_;
+
   InvariantCheckLevel invariant_check_level_;
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_