[Sync] Refactor GetEncryptedTypes usage.

sync/internal_api/write_node.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/internal_api/public/write_node.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/public/write_transaction.h"
@@ skipping 24 matching lines @@
   if (entry_->Get(syncable::IS_DIR) == folder)
     return;  // Skip redundant changes.
 
   entry_->Put(syncable::IS_DIR, folder);
   MarkForSyncing();
 }
 
 void WriteNode::SetTitle(const std::wstring& title) {
   DCHECK_NE(GetModelType(), UNSPECIFIED);
   ModelType type = GetModelType();
-  Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
   // It's possible the nigori lost the set of encrypted types. If the current
   // specifics are already encrypted, we want to ensure we continue encrypting.
-  bool needs_encryption = cryptographer->GetEncryptedTypes().Has(type) ||
+  bool needs_encryption = GetTransaction()->GetEncryptedTypes().Has(type) ||
                           entry_->Get(SPECIFICS).has_encrypted();
 
   // If this datatype is encrypted and is not a bookmark, we disregard the
   // specified title in favor of kEncryptedString. For encrypted bookmarks the
   // NON_UNIQUE_NAME will still be kEncryptedString, but we store the real title
   // into the specifics. All strings compared are server legal strings.
   std::string new_legal_title;
   if (type != BOOKMARKS && needs_encryption) {
     new_legal_title = kEncryptedString;
   } else {
@@ skipping 137 matching lines @@
       GetModelTypeFromSpecifics(new_value);
   DCHECK_NE(new_specifics_type, UNSPECIFIED);
   DVLOG(1) << "Writing entity specifics of type "
            << ModelTypeToString(new_specifics_type);
   // GetModelType() can be unspecified if this is the first time this
   // node is being initialized (see PutModelType()).  Otherwise, it
   // should match |new_specifics_type|.
   if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(new_specifics_type, GetModelType());
   }
-  Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
 
   // Preserve unknown fields.
   const sync_pb::EntitySpecifics& old_specifics = entry_->Get(SPECIFICS);
   sync_pb::EntitySpecifics new_specifics;
   new_specifics.CopyFrom(new_value);
   new_specifics.mutable_unknown_fields()->MergeFrom(
       old_specifics.unknown_fields());
 
   // Will update the entry if encryption was necessary.
-  if (!UpdateEntryWithEncryption(cryptographer, new_specifics, entry_)) {
+  if (!UpdateEntryWithEncryption(GetTransaction()->GetWrappedTrans(),
+                                 new_specifics,
+                                 entry_)) {
     return;
   }
   if (entry_->Get(SPECIFICS).has_encrypted()) {
     // EncryptIfNecessary already updated the entry for us and marked for
     // syncing if it was needed. Now we just make a copy of the unencrypted
     // specifics so that if this node is updated, we do not have to decrypt the
     // old data. Note that this only modifies the node's local data, not the
     // entry itself.
     SetUnencryptedSpecifics(new_value);
   }
@@ skipping 276 matching lines @@
   sync_pb::BookmarkSpecifics new_value = GetBookmarkSpecifics();
   new_value.set_favicon(bytes.empty() ? NULL : &bytes[0], bytes.size());
   SetBookmarkSpecifics(new_value);
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 }  // namespace syncer