Supplimentary identifier for passwords specific

components/sync/syncable/nigori_util.cc

 // Copyright 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/syncable/nigori_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "components/sync/base/cryptographer.h"
+#include "components/sync/base/passphrase_type.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/entry.h"
 #include "components/sync/syncable/mutable_entry.h"
 #include "components/sync/syncable/nigori_handler.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
 
 namespace syncer {
 namespace syncable {
 
@@ skipping 114 matching lines @@
     }
     // Push the successor.
     to_visit.push(child.GetSuccessorId());
   }
   return true;
 }
 
 bool UpdateEntryWithEncryption(BaseTransaction* const trans,
                                const sync_pb::EntitySpecifics& new_specifics,
                                syncable::MutableEntry* entry) {
+  return UpdateEntryWithEncryption(trans, new_specifics, entry,
+                                   syncer::PassphraseType::UNDEFINED);
+}
+
+bool UpdateEntryWithEncryption(BaseTransaction* const trans,
+                               const sync_pb::EntitySpecifics& new_specifics,
+                               syncable::MutableEntry* entry,
+                               PassphraseType passphrase_type) {
   NigoriHandler* nigori_handler = trans->directory()->GetNigoriHandler();
   Cryptographer* cryptographer = trans->directory()->GetCryptographer(trans);
   ModelType type = GetModelTypeFromSpecifics(new_specifics);
   DCHECK_GE(type, FIRST_REAL_MODEL_TYPE);
   const sync_pb::EntitySpecifics& old_specifics = entry->GetSpecifics();
   const ModelTypeSet encrypted_types =
       nigori_handler ? nigori_handler->GetEncryptedTypes(trans)
                      : ModelTypeSet();
   // 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.
@@ skipping 58 matching lines @@
     // For bookmarks we actually put bogus data into the unencrypted specifics,
     // else the server will try to do it for us.
     if (type == BOOKMARKS) {
       sync_pb::BookmarkSpecifics* bookmark_specifics =
           generated_specifics.mutable_bookmark();
       if (!entry->GetIsDir())
         bookmark_specifics->set_url(kEncryptedString);
       bookmark_specifics->set_title(kEncryptedString);
     }
   }
+
+  if (type == PASSWORDS && IsExplicitPassphrase(passphrase_type)) {
+    sync_pb::PasswordSpecifics* password_specifics =
+        generated_specifics.mutable_password();
+    password_specifics->clear_unencrypted_metadata();
+  }
+
   entry->PutSpecifics(generated_specifics);
   DVLOG(1) << "Overwriting specifics of type " << ModelTypeToString(type)
            << " and marking for syncing.";
   syncable::MarkForSyncing(entry);
   return true;
 }
 
 void UpdateNigoriFromEncryptedTypes(ModelTypeSet encrypted_types,
                                     bool encrypt_everything,
                                     sync_pb::NigoriSpecifics* nigori) {
@@ skipping 68 matching lines @@
     encrypted_types.Put(ARTICLES);
   if (nigori.encrypt_app_list())
     encrypted_types.Put(APP_LIST);
   if (nigori.encrypt_arc_package())
     encrypted_types.Put(ARC_PACKAGE);
   return encrypted_types;
 }
 
 }  // namespace syncable
 }  // namespace syncer