Passing correct passhprase type in the generic change processor.

components/sync/driver/generic_change_processor.cc

 // Copyright 2014 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 "components/sync/driver/generic_change_processor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 19 matching lines @@
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/syncable/entry.h"  // TODO(tim): Bug 123674.
 
 namespace sync_driver {
 
 namespace {
 
 const int kContextSizeLimit = 1024;  // Datatype context size limit.
 
 void SetNodeSpecifics(const sync_pb::EntitySpecifics& entity_specifics,
-                      syncer::WriteNode* write_node) {
+                      syncer::WriteNode* write_node,
+                      syncer::PassphraseType passphrase_type) {
   if (syncer::GetModelTypeFromSpecifics(entity_specifics) ==
       syncer::PASSWORDS) {
     write_node->SetPasswordSpecifics(
         entity_specifics.password().client_only_encrypted_data(),
-        // TODO(melandory): Since PasswordsSpecifics care about passphrase type.
-        // the real value should be passed here.
-        syncer::PassphraseType::UNDEFINED);
+        passphrase_type);
+
   } else {
     write_node->SetEntitySpecifics(entity_specifics);
   }
 }
 
 // Helper function to convert AttachmentId to AttachmentMetadataRecord.
 sync_pb::AttachmentMetadataRecord AttachmentIdToRecord(
     const syncer::AttachmentId& attachment_id) {
   sync_pb::AttachmentMetadataRecord record;
   *record.mutable_id() = attachment_id.GetProto();
@@ skipping 492 matching lines @@
       }
       default: {
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "unknown error", type_);
         error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Create: Unknown error.";
         return error;
       }
     }
   }
+  syncer::PassphraseType passphrase_type = syncer::PassphraseType::UNDEFINED;
+  {
+      syncer::ReadTransaction trans(FROM_HERE, share_handle());
+      passphrase_type = trans.GetPassphraseType();
+  }
   sync_node->SetTitle(change.sync_data().GetTitle());
-  SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node);
+  SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node,passphrase_type) ;
 
   syncer::AttachmentIdList attachment_ids = sync_data_local.GetAttachmentIds();
   SetAttachmentMetadata(attachment_ids, sync_node);
 
   // Return any newly added attachments.
   new_attachments->insert(attachment_ids.begin(), attachment_ids.end());
   if (merge_result_.get()) {
     merge_result_->set_num_items_added(merge_result_->num_items_added() + 1);
   }
   return syncer::SyncError();
@@ skipping 41 matching lines @@
       return error;
     } else {
       NOTREACHED();
       syncer::SyncError error;
       error.Reset(FROM_HERE, error_prefix + "unknown error", type_);
       error_handler()->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Update: Unknown error.";
       return error;
     }
   }
-
+  syncer::PassphraseType passphrase_type = syncer::PassphraseType::UNDEFINED;
+  {
+      syncer::ReadTransaction trans(FROM_HERE, share_handle());
+      passphrase_type = trans.GetPassphraseType();
+  }
   sync_node->SetTitle(change.sync_data().GetTitle());
-  SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node);
+  SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node, passphrase_type);
   syncer::AttachmentIdList attachment_ids = sync_data_local.GetAttachmentIds();
   SetAttachmentMetadata(attachment_ids, sync_node);
 
   // Return any newly added attachments.
   new_attachments->insert(attachment_ids.begin(), attachment_ids.end());
 
   if (merge_result_.get()) {
     merge_result_->set_num_items_modified(merge_result_->num_items_modified() +
                                           1);
   }
@@ skipping 51 matching lines @@
   }
 }
 
 std::unique_ptr<syncer::AttachmentService>
 GenericChangeProcessor::GetAttachmentService() const {
   return std::unique_ptr<syncer::AttachmentService>(
       new syncer::AttachmentServiceProxy(attachment_service_proxy_));
 }
 
 }  // namespace sync_driver