Landing Recent QUIC changes until Sat Sep 10 00:32:41

net/quic/core/crypto/crypto_server_test.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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <vector>
 
@@ skipping 183 matching lines @@
                      bool should_succeed,
                      const char* error_substr,
                      bool* called)
         : test_(test),
           should_succeed_(should_succeed),
           error_substr_(error_substr),
           called_(called) {
       *called_ = false;
     }
 
-    void RunImpl(const CryptoHandshakeMessage& client_hello,
-                 const Result& result,
-                 std::unique_ptr<ProofSource::Details> /* details */) override {
+    void Run(std::unique_ptr<Result> result,
+             std::unique_ptr<ProofSource::Details> /* details */) override {
       {
         // Ensure that the strike register client lock is not held.
         QuicCryptoServerConfigPeer peer(&test_->config_);
         base::Lock* m = peer.GetStrikeRegisterClientLock();
         // In Chromium, we will dead lock if the lock is held by the current
         // thread. Chromium doesn't have AssertNotHeld API call.
         // m->AssertNotHeld();
         base::AutoLock lock(*m);
       }
       ASSERT_FALSE(*called_);
-      test_->ProcessValidationResult(client_hello, result, should_succeed_,
-                                     error_substr_);
+      test_->ProcessValidationResult(*result, should_succeed_, error_substr_);
       *called_ = true;
     }
 
    private:
     CryptoServerTest* test_;
     bool should_succeed_;
     const char* error_substr_;
     bool* called_;
   };
 
@@ skipping 10 matching lines @@
     ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address));
     QuicSocketAddressCoder decoder;
     ASSERT_TRUE(decoder.Decode(address.data(), address.size()));
     EXPECT_EQ(client_address_.address(), decoder.ip());
     EXPECT_EQ(client_address_.port(), decoder.port());
   }
 
   void ShouldSucceed(const CryptoHandshakeMessage& message) {
     bool called = false;
     IPAddress server_ip;
-    config_.ValidateClientHello(message, client_address_.address(), server_ip,
-                                supported_versions_.front(), &clock_,
-                                &crypto_proof_,
-                                new ValidateCallback(this, true, "", &called));
+    config_.ValidateClientHello(
+        message, client_address_.address(), server_ip,
+        supported_versions_.front(), &clock_, &crypto_proof_,
+        std::unique_ptr<ValidateCallback>(
+            new ValidateCallback(this, true, "", &called)));
     EXPECT_TRUE(called);
   }
 
   void ShouldFailMentioning(const char* error_substr,
                             const CryptoHandshakeMessage& message) {
     bool called = false;
     ShouldFailMentioning(error_substr, message, &called);
     EXPECT_TRUE(called);
   }
 
   void ShouldFailMentioning(const char* error_substr,
                             const CryptoHandshakeMessage& message,
                             bool* called) {
     IPAddress server_ip;
     config_.ValidateClientHello(
         message, client_address_.address(), server_ip,
         supported_versions_.front(), &clock_, &crypto_proof_,
-        new ValidateCallback(this, false, error_substr, called));
+        std::unique_ptr<ValidateCallback>(
+            new ValidateCallback(this, false, error_substr, called)));
   }
 
-  void ProcessValidationResult(const CryptoHandshakeMessage& message,
-                               const ValidateCallback::Result& result,
+  void ProcessValidationResult(const ValidateCallback::Result& result,
                                bool should_succeed,
                                const char* error_substr) {
     IPAddress server_ip;
     DiversificationNonce diversification_nonce;
     string error_details;
     QuicConnectionId server_designated_connection_id =
         rand_for_id_generation_.RandUint64();
     QuicErrorCode error = config_.ProcessClientHello(
         result, /*reject_only=*/false, /*connection_id=*/1, server_ip,
         client_address_, supported_versions_.front(), supported_versions_,
         use_stateless_rejects_, server_designated_connection_id, &clock_, rand_,
         &compressed_certs_cache_, &params_, &crypto_proof_,
         /*total_framing_overhead=*/50, chlo_packet_size_, &out_,
         &diversification_nonce, &error_details);
 
     if (should_succeed) {
       ASSERT_EQ(error, QUIC_NO_ERROR) << "Message failed with error "
                                       << error_details << ": "
-                                      << message.DebugString();
+                                      << result.client_hello.DebugString();
     } else {
       ASSERT_NE(error, QUIC_NO_ERROR) << "Message didn't fail: "
-                                      << message.DebugString();
+                                      << result.client_hello.DebugString();
 
       EXPECT_TRUE(error_details.find(error_substr) != string::npos)
           << error_substr << " not in " << error_details;
     }
   }
 
   string GenerateNonce() {
     string nonce;
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), rand_,
@@ skipping 868 matching lines @@
       "VER\0", client_version_string_.c_str(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
       nullptr);
   // clang-format on
 
   // Clear the message tag.
   out_.set_tag(0);
 
   bool called = false;
   IPAddress server_ip;
-  config_.ValidateClientHello(msg, client_address_.address(), server_ip,
-                              client_version_, &clock_, &crypto_proof_,
-                              new ValidateCallback(this, true, "", &called));
+  config_.ValidateClientHello(
+      msg, client_address_.address(), server_ip, client_version_, &clock_,
+      &crypto_proof_, std::unique_ptr<ValidateCallback>(
+                          new ValidateCallback(this, true, "", &called)));
   // The verification request was queued.
   ASSERT_FALSE(called);
   EXPECT_EQ(0u, out_.tag());
   EXPECT_EQ(1, strike_register_client_->PendingVerifications());
 
   // Continue processing the verification request.
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be accepted now.
   EXPECT_EQ(kSHLO, out_.tag());
 
   // Rejected if replayed.
-  config_.ValidateClientHello(msg, client_address_.address(), server_ip,
-                              client_version_, &clock_, &crypto_proof_,
-                              new ValidateCallback(this, true, "", &called));
+  config_.ValidateClientHello(
+      msg, client_address_.address(), server_ip, client_version_, &clock_,
+      &crypto_proof_, std::unique_ptr<ValidateCallback>(
+                          new ValidateCallback(this, true, "", &called)));
   // The verification request was queued.
   ASSERT_FALSE(called);
   EXPECT_EQ(1, strike_register_client_->PendingVerifications());
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   CheckRejectTag();
 }
@@ skipping 30 matching lines @@
     EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   } else {
     // version 33.
     ASSERT_EQ(kSHLO, out_.tag());
     CheckServerHello(out_);
   }
 }
 
 }  // namespace test
 }  // namespace net