Use unique_ptrs to manage callback lifetimes in some QUIC code

net/tools/quic/stateless_rejector.cc

 // Copyright 2016 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/tools/quic/stateless_rejector.h"
 
 #include "net/quic/core/quic_crypto_server_stream.h"
 #include "net/quic/core/quic_flags.h"
 
 namespace net {
 
 class StatelessRejector::ValidateCallback
     : public ValidateClientHelloResultCallback {
  public:
   explicit ValidateCallback(
       std::unique_ptr<StatelessRejector> rejector,
       std::unique_ptr<StatelessRejector::ProcessDoneCallback> cb)
       : rejector_(std::move(rejector)), cb_(std::move(cb)) {}
 
   ~ValidateCallback() override {}
 
-  void RunImpl(std::unique_ptr<Result> result,
-               std::unique_ptr<ProofSource::Details> /* proof_source_details */)
+  void Run(std::unique_ptr<Result> result,
+           std::unique_ptr<ProofSource::Details> /* proof_source_details */)
       override {
     StatelessRejector* rejector_ptr = rejector_.get();
     rejector_ptr->ProcessClientHello(*result, std::move(rejector_),
                                      std::move(cb_));
   }
 
  private:
   std::unique_ptr<StatelessRejector> rejector_;
   std::unique_ptr<StatelessRejector::ProcessDoneCallback> cb_;
 };
@@ skipping 51 matching lines @@
   if (rejector->state() != UNKNOWN) {
     cb->Run(std::move(rejector));
     return;
   }
 
   StatelessRejector* rejector_ptr = rejector.get();
   rejector_ptr->crypto_config_->ValidateClientHello(
       rejector_ptr->chlo_, rejector_ptr->client_address_.address(),
       rejector_ptr->server_address_.address(), rejector_ptr->version_,
       rejector_ptr->clock_, &rejector_ptr->proof_,
-      new ValidateCallback(std::move(rejector), std::move(cb)));
+      std::unique_ptr<ValidateCallback>(
+          new ValidateCallback(std::move(rejector), std::move(cb))));
 }
 
 void StatelessRejector::ProcessClientHello(
     const ValidateClientHelloResultCallback::Result& result,
     std::unique_ptr<StatelessRejector> rejector,
     std::unique_ptr<StatelessRejector::ProcessDoneCallback> cb) {
   QuicCryptoNegotiatedParameters params;
   DiversificationNonce diversification_nonce;
   QuicErrorCode error = crypto_config_->ProcessClientHello(
       result,
       /*reject_only=*/true, connection_id_, server_address_.address(),
       client_address_, version_, versions_,
       /*use_stateless_rejects=*/true, server_designated_connection_id_, clock_,
       random_, compressed_certs_cache_, &params, &proof_,
       QuicCryptoStream::CryptoMessageFramingOverhead(version_),
       chlo_packet_size_, &reply_, &diversification_nonce, &error_details_);
   if (error != QUIC_NO_ERROR) {
     error_ = error;
     state_ = FAILED;
   } else if (reply_.tag() == kSREJ) {
     state_ = REJECTED;
   } else {
     state_ = ACCEPTED;
   }
   cb->Run(std::move(rejector));
 }
 
 }  // namespace net