use std::unique_ptr for the callback argument of QUIC's ProofVerifier::Verify proof to make ownersh…

net/quic/crypto/proof_verifier_chromium.cc

 // Copyright 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/quic/crypto/proof_verifier_chromium.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 58 matching lines @@
       const std::string& hostname,
       const uint16_t port,
       const std::string& server_config,
       QuicVersion quic_version,
       base::StringPiece chlo_hash,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
       std::string* error_details,
       std::unique_ptr<ProofVerifyDetails>* verify_details,
-      ProofVerifierCallback* callback);
+      std::unique_ptr<ProofVerifierCallback> callback);
 
  private:
   enum State {
     STATE_NONE,
     STATE_VERIFY_CERT,
     STATE_VERIFY_CERT_COMPLETE,
   };
 
   int DoLoop(int last_io_result);
   void OnIOComplete(int result);
@@ skipping 83 matching lines @@
     const string& hostname,
     const uint16_t port,
     const string& server_config,
     QuicVersion quic_version,
     StringPiece chlo_hash,
     const vector<string>& certs,
     const std::string& cert_sct,
     const string& signature,
     std::string* error_details,
     std::unique_ptr<ProofVerifyDetails>* verify_details,
-    ProofVerifierCallback* callback) {
+    std::unique_ptr<ProofVerifierCallback> callback) {
   DCHECK(error_details);
   DCHECK(verify_details);
-  DCHECK(callback);

[rjshade, 2016/07/06 20:09:34]

Not sure about this removal, but the following test fails:

VerifyECDSAKnownAnswerTest
https://cs.chromium.org/chromium/src/net/quic/crypto/proof_test.cc?l=329

with it. Any suggestions?

[Ryan Hamilton, 2016/07/07 00:10:35]

Hm. That sounds dodgy. DO you have a failure log?

 
   error_details->clear();
 
   if (STATE_NONE != next_state_) {
     *error_details = "Certificate is already set and VerifyProof has begun";
     DLOG(DFATAL) << *error_details;
     return QUIC_FAILURE;
   }
 
   verify_details_.reset(new ProofVerifyDetailsChromium);
@@ skipping 42 matching lines @@
 
   hostname_ = hostname;
   port_ = port;
 
   next_state_ = STATE_VERIFY_CERT;
   switch (DoLoop(OK)) {
     case OK:
       *verify_details = std::move(verify_details_);
       return QUIC_SUCCESS;
     case ERR_IO_PENDING:
-      callback_.reset(callback);
+      callback_ = std::move(callback);
       return QUIC_PENDING;
     default:
       *error_details = error_details_;
       *verify_details = std::move(verify_details_);
       return QUIC_FAILURE;
   }
 }
 
 int ProofVerifierChromium::Job::DoLoop(int last_result) {
   int rv = last_result;
@@ skipping 224 matching lines @@
     const uint16_t port,
     const std::string& server_config,
     QuicVersion quic_version,
     base::StringPiece chlo_hash,
     const std::vector<std::string>& certs,
     const std::string& cert_sct,
     const std::string& signature,
     const ProofVerifyContext* verify_context,
     std::string* error_details,
     std::unique_ptr<ProofVerifyDetails>* verify_details,
-    ProofVerifierCallback* callback) {
+    std::unique_ptr<ProofVerifierCallback> callback) {
   if (!verify_context) {
     *error_details = "Missing context";
     return QUIC_FAILURE;
   }
   const ProofVerifyContextChromium* chromium_context =
       reinterpret_cast<const ProofVerifyContextChromium*>(verify_context);
   std::unique_ptr<Job> job(
       new Job(this, cert_verifier_, ct_policy_enforcer_,
               transport_security_state_, cert_transparency_verifier_,
               chromium_context->cert_verify_flags, chromium_context->net_log));
   QuicAsyncStatus status = job->VerifyProof(
       hostname, port, server_config, quic_version, chlo_hash, certs, cert_sct,
-      signature, error_details, verify_details, callback);
+      signature, error_details, verify_details, std::move(callback));
   if (status == QUIC_PENDING) {
     active_jobs_.insert(job.release());
   }
   return status;
 }
 
 void ProofVerifierChromium::OnJobComplete(Job* job) {
   active_jobs_.erase(job);
   delete job;
 }
 
 }  // namespace net