Allow custom deleters to opt out of self reset checks for scoped_ptr.

net/ssl/openssl_client_key_store.cc

 // Copyright (c) 2013 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 "net/ssl/openssl_client_key_store.h"
 
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 32 matching lines @@
 }
 
 OpenSSLClientKeyStore::KeyPair::~KeyPair() {
 }
 
 OpenSSLClientKeyStore::KeyPair::KeyPair(const KeyPair& other)
     : public_key(EVP_PKEY_dup(other.public_key.get())),
       private_key(EVP_PKEY_dup(other.private_key.get())) {
 }
 
 void OpenSSLClientKeyStore::KeyPair::operator=(const KeyPair& other) {

[Jeffrey Yasskin, 2014/09/29 17:23:19]

operator= should generally be implemented with a by-value signature and a swap,
so:

void OpenSSLClientKeyStore::KeyPair::operator=(KeyPair other) {
  this->swap(other);
}

That avoids the need to duplicate the code to copy the input value.

[Ryan Sleevi, 2014/09/29 18:57:08]

Except this isn't a swap. It's a copy.

[Jeffrey Yasskin, 2014/09/29 19:20:52]

Yeah, the copy happens because the argument is passed by value, invoking the
copy constructor. Then the new value gets swapped into *this.

This saves a set of EVP_PKEY_dup() calls when the argument to operator= is a
temporary, because in that case the copy constructor doesn't need to be called
to create a by-value argument.

Search for the "copy-and-swap idiom".

-  // Use a temporary ScopedEVP_PKEY because scoped_ptr does not allow resetting
-  // to the current value, even though it's safe here.
-  crypto::ScopedEVP_PKEY public_key_tmp(EVP_PKEY_dup(other.public_key.get()));
-  crypto::ScopedEVP_PKEY private_key_tmp(EVP_PKEY_dup(other.private_key.get()));
-  public_key.reset();
-  public_key = public_key_tmp.Pass();
-  private_key.reset();
-  private_key = private_key_tmp.Pass();
+  public_key.reset(EVP_PKEY_dup(other.public_key.get()));
+  private_key.reset(EVP_PKEY_dup(other.private_key.get()));
 }
 
 int OpenSSLClientKeyStore::FindKeyPairIndex(EVP_PKEY* public_key) {
   if (!public_key)
     return -1;
   for (size_t n = 0; n < pairs_.size(); ++n) {
     if (EVP_PKEY_cmp(pairs_[n].public_key.get(), public_key) == 1)
       return static_cast<int>(n);
   }
   return -1;
@@ skipping 44 matching lines @@
   pairs_.clear();
 }
 
 OpenSSLClientKeyStore* OpenSSLClientKeyStore::GetInstance() {
   return Singleton<OpenSSLClientKeyStore>::get();
 }
 
 }  // namespace net