Revert of [sync] Fix decryption failure caused by missing user_key

components/sync/base/cryptographer.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/base/cryptographer.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 16 matching lines @@
 
 Cryptographer::Cryptographer(Encryptor* encryptor) : encryptor_(encryptor) {
   DCHECK(encryptor);
 }
 
 Cryptographer::Cryptographer(const Cryptographer& other)
     : encryptor_(other.encryptor_),
       default_nigori_name_(other.default_nigori_name_) {
   for (NigoriMap::const_iterator it = other.nigoris_.begin();
        it != other.nigoris_.end(); ++it) {
-    std::string user_key, encryption_key, mac_key;
-    it->second->ExportKeys(&user_key, &encryption_key, &mac_key);
+    std::string encryption_key, mac_key;
+    it->second->ExportKeys(&encryption_key, &mac_key);
     linked_ptr<Nigori> nigori_copy(new Nigori());
-    nigori_copy->InitByImport(user_key, encryption_key, mac_key);
+    nigori_copy->InitByImport(encryption_key, mac_key);
     nigoris_.insert(std::make_pair(it->first, nigori_copy));
   }
 
   if (other.pending_keys_) {
     pending_keys_ =
         base::MakeUnique<sync_pb::EncryptedData>(*(other.pending_keys_));
   }
 }
 
 Cryptographer::~Cryptographer() {}
@@ skipping 92 matching lines @@
   DCHECK(encrypted);
   DCHECK(!nigoris_.empty());
 
   // Create a bag of all the Nigori parameters we know about.
   sync_pb::NigoriKeyBag bag;
   for (NigoriMap::const_iterator it = nigoris_.begin(); it != nigoris_.end();
        ++it) {
     const Nigori& nigori = *it->second;
     sync_pb::NigoriKey* key = bag.add_key();
     key->set_name(it->first);
-    nigori.ExportKeys(key->mutable_user_key(), key->mutable_encryption_key(),
-                      key->mutable_mac_key());
+    nigori.ExportKeys(key->mutable_encryption_key(), key->mutable_mac_key());
   }
 
   // Encrypt the bag with the default Nigori.
   return Encrypt(bag, encrypted);
 }
 
 bool Cryptographer::AddKey(const KeyParams& params) {
   // Create the new Nigori and make it the default encryptor.
   std::unique_ptr<Nigori> nigori(new Nigori);
   if (!nigori->InitByDerivation(params.hostname, params.username,
@@ skipping 134 matching lines @@
   return unencrypted_token;
 }
 
 void Cryptographer::InstallKeyBag(const sync_pb::NigoriKeyBag& bag) {
   int key_size = bag.key_size();
   for (int i = 0; i < key_size; ++i) {
     const sync_pb::NigoriKey key = bag.key(i);
     // Only use this key if we don't already know about it.
     if (nigoris_.end() == nigoris_.find(key.name())) {
       std::unique_ptr<Nigori> new_nigori(new Nigori);
-      if (!new_nigori->InitByImport(key.user_key(), key.encryption_key(),
-                                    key.mac_key())) {
+      if (!new_nigori->InitByImport(key.encryption_key(), key.mac_key())) {
         NOTREACHED();
         continue;
       }
       nigoris_[key.name()] = make_linked_ptr(new_nigori.release());
     }
   }
 }
 
 bool Cryptographer::KeybagIsStale(
     const sync_pb::EncryptedData& encrypted_bag) const {
@@ skipping 20 matching lines @@
   return default_nigori_name_;
 }
 
 std::string Cryptographer::GetDefaultNigoriKeyData() const {
   if (!is_initialized())
     return std::string();
   NigoriMap::const_iterator iter = nigoris_.find(default_nigori_name_);
   if (iter == nigoris_.end())
     return std::string();
   sync_pb::NigoriKey key;
-  if (!iter->second->ExportKeys(key.mutable_user_key(),
-                                key.mutable_encryption_key(),
+  if (!iter->second->ExportKeys(key.mutable_encryption_key(),
                                 key.mutable_mac_key()))
     return std::string();
   return key.SerializeAsString();
 }
 
 bool Cryptographer::ImportNigoriKey(const std::string& serialized_nigori_key) {
   if (serialized_nigori_key.empty())
     return false;
 
   sync_pb::NigoriKey key;
   if (!key.ParseFromString(serialized_nigori_key))
     return false;
 
   std::unique_ptr<Nigori> nigori(new Nigori);
-  if (!nigori->InitByImport(key.user_key(), key.encryption_key(),
-                            key.mac_key())) {
+  if (!nigori->InitByImport(key.encryption_key(), key.mac_key())) {
     NOTREACHED();
     return false;
   }
 
   if (!AddKeyImpl(std::move(nigori), true))
     return false;
   return true;
 }
 
 }  // namespace syncer