chromeos: Add out-of-line copy ctors for complex classes.

chromeos/cryptohome/cryptohome_parameters.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 "chromeos/cryptohome/cryptohome_parameters.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "chromeos/dbus/cryptohome/key.pb.h"
@@ skipping 94 matching lines @@
     bool encrypt,
     bool sign,
     const std::string& symmetric_key) : type(TYPE_HMACSHA256) {
     secrets.push_back(Secret(encrypt,
                              sign,
                              symmetric_key,
                              std::string() /* public_key */,
                              false /* wrapped */));
 }
 
+KeyDefinition::AuthorizationData::AuthorizationData(
+    const AuthorizationData& other) = default;
 
 KeyDefinition::AuthorizationData::~AuthorizationData() {
 }
 
 bool KeyDefinition::AuthorizationData::operator==(
     const AuthorizationData& other) const {
   if (type != other.type || secrets.size() != other.secrets.size())
     return false;
   for (size_t i = 0; i < secrets.size(); ++i) {
     if (!(secrets[i] == other.secrets[i]))
@@ skipping 56 matching lines @@
 KeyDefinition::KeyDefinition(const std::string& secret,
                              const std::string& label,
                              int /*AuthKeyPrivileges*/ privileges)
     : type(TYPE_PASSWORD),
       label(label),
       privileges(privileges),
       revision(0),
       secret(secret) {
 }
 
+KeyDefinition::KeyDefinition(const KeyDefinition& other) = default;
+
 KeyDefinition::~KeyDefinition() {
 }
 
 bool KeyDefinition::operator==(const KeyDefinition& other) const {
   if (type != other.type ||
       label != other.label ||
       privileges != other.privileges ||
       revision != other.revision ||
       authorization_data.size() != other.authorization_data.size() ||
       provider_data.size() != other.provider_data.size()) {
@@ skipping 21 matching lines @@
       label(key_def.label) {
 }
 
 bool Authorization::operator==(const Authorization& other) const {
   return key == other.key && label == other.label;
 }
 
 MountParameters::MountParameters(bool ephemeral) : ephemeral(ephemeral) {
 }
 
+MountParameters::MountParameters(const MountParameters& other) = default;
+
 bool MountParameters::operator==(const MountParameters& other) const {
   return ephemeral == other.ephemeral && create_keys == other.create_keys;
 }
 
 MountParameters::~MountParameters() {
 }
 
 bool GetGaiaIdMigrationStatus(const AccountId& account_id) {
   return user_manager::known_user::GetGaiaIdMigrationStatus(account_id,
                                                             kCryptohome);
 }
 
 void SetGaiaIdMigrationStatusDone(const AccountId& account_id) {
   user_manager::known_user::SetGaiaIdMigrationStatusDone(account_id,
                                                          kCryptohome);
 }
 
 }  // namespace cryptohome
 
 namespace BASE_HASH_NAMESPACE {
 
 std::size_t hash<cryptohome::Identification>::operator()(
     const cryptohome::Identification& cryptohome_id) const {
   return hash<std::string>()(cryptohome_id.id());
 }
 
 }  // namespace BASE_HASH_NAMESPACE