Supplimentary identifier for passwords specific

components/sync/core/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 "components/sync/core/write_node.h"
 
 #include <stdint.h>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 99 matching lines @@
   entity_specifics.mutable_bookmark()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetNigoriSpecifics(const sync_pb::NigoriSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_nigori()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
-void WriteNode::SetPasswordSpecifics(
-    const sync_pb::PasswordSpecificsData& data) {
+void WriteNode::SetPasswordSpecifics(const sync_pb::PasswordSpecificsData& data,
+                                     PassphraseType passphrase_type) {
   DCHECK_EQ(GetModelType(), PASSWORDS);
 
   Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
 
   // We have to do the idempotency check here (vs in UpdateEntryWithEncryption)
   // because Passwords have their encrypted data within the PasswordSpecifics,
   // vs within the EntitySpecifics like all the other types.
   const sync_pb::EntitySpecifics& old_specifics = GetEntitySpecifics();
   sync_pb::EntitySpecifics entity_specifics;
   // Copy over the old specifics if they exist.
   if (GetModelTypeFromSpecifics(old_specifics) == PASSWORDS) {
     entity_specifics.CopyFrom(old_specifics);
   } else {
     AddDefaultFieldValue(PASSWORDS, &entity_specifics);
   }
   sync_pb::PasswordSpecifics* password_specifics =
       entity_specifics.mutable_password();
   // This will only update password_specifics if the underlying unencrypted blob
   // was different from |data| or was not encrypted with the proper passphrase.
   if (!cryptographer->Encrypt(data, password_specifics->mutable_encrypted())) {
     LOG(ERROR) << "Failed to encrypt password, possibly due to sync node "
                << "corruption";
     return;
   }
-  SetEntitySpecifics(entity_specifics);
+  SetEntitySpecifics(entity_specifics, passphrase_type);
 }
 
 void WriteNode::SetEntitySpecifics(const sync_pb::EntitySpecifics& new_value) {
+  SetEntitySpecifics(new_value, PassphraseType::UNDEFINED);
+}
+
+void WriteNode::SetEntitySpecifics(const sync_pb::EntitySpecifics& new_value,
+                                   PassphraseType passphrase_type) {
   ModelType new_specifics_type = GetModelTypeFromSpecifics(new_value);
   CHECK(!new_value.password().has_client_only_encrypted_data());
   DCHECK_NE(new_specifics_type, UNSPECIFIED);
   DVLOG(1) << "Writing entity specifics of type "
            << ModelTypeToString(new_specifics_type);
   DCHECK_EQ(new_specifics_type, GetModelType());
 
   // Preserve unknown fields.
   const sync_pb::EntitySpecifics& old_specifics = entry_->GetSpecifics();
   sync_pb::EntitySpecifics new_specifics;
   new_specifics.CopyFrom(new_value);
   new_specifics.mutable_unknown_fields()->append(
       old_specifics.unknown_fields());
 
   // Will update the entry if encryption was necessary.
   if (!UpdateEntryWithEncryption(GetTransaction()->GetWrappedTrans(),

[Nicolas Zea, 2016/08/26 18:28:30]

Given you have access to the transaction now, I don't think you need to plumb
the passphrase in anymore?

I think that might imply you don't need UNDEFINED as a value either

[melandory, 2016/08/26 23:16:59]

Oh, definitelly!

Fixed and updated CL https://codereview.chromium.org/2279753003/

-                                 new_specifics, entry_)) {
+                                 new_specifics, entry_, passphrase_type)) {
     return;
   }
   if (entry_->GetSpecifics().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 292 matching lines @@
   syncable::Id predecessor_id =
       predecessor ? predecessor->GetSyncId() : syncable::Id();
   return entry_->PutPredecessor(predecessor_id);
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 }  // namespace syncer