Clang format slam.

net/quic/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 "base/basictypes.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
@@ skipping 32 matching lines @@
         client_address_(Loopback4(), 1234),
         config_(QuicCryptoServerConfig::TESTING, rand_) {
     config_.SetProofSource(CryptoTestUtils::ProofSourceForTesting());
     supported_versions_ = QuicSupportedVersions();
     client_version_ = QuicUtils::TagToString(
         QuicVersionToQuicTag(supported_versions_.front()));
   }
 
   virtual void SetUp() {
     scoped_ptr<CryptoHandshakeMessage> msg(
-        config_.AddDefaultConfig(rand_, &clock_,
-        config_options_));
+        config_.AddDefaultConfig(rand_, &clock_, config_options_));
 
     StringPiece orbit;
     CHECK(msg->GetStringPiece(kORBT, &orbit));
     CHECK_EQ(sizeof(orbit_), orbit.size());
     memcpy(orbit_, orbit.data(), orbit.size());
 
     char public_value[32];
     memset(public_value, 42, sizeof(public_value));
 
     const string nonce_str = GenerateNonce();
     nonce_hex_ = "#" + base::HexEncode(nonce_str.data(), nonce_str.size());
     pub_hex_ = "#" + base::HexEncode(public_value, sizeof(public_value));
 
-    CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
-        "CHLO",
-        "AEAD", "AESG",
-        "KEXS", "C255",
-        "PUBS", pub_hex_.c_str(),
-        "NONC", nonce_hex_.c_str(),
-        "VER\0", client_version_.data(),
-        "$padding", static_cast<int>(kClientHelloMinimumSize),
-        NULL);
+    CryptoHandshakeMessage client_hello =
+        CryptoTestUtils::Message("CHLO",
+                                 "AEAD",
+                                 "AESG",
+                                 "KEXS",
+                                 "C255",
+                                 "PUBS",
+                                 pub_hex_.c_str(),
+                                 "NONC",
+                                 nonce_hex_.c_str(),
+                                 "VER\0",
+                                 client_version_.data(),
+                                 "$padding",
+                                 static_cast<int>(kClientHelloMinimumSize),
+                                 NULL);
     ShouldSucceed(client_hello);
     // The message should be rejected because the source-address token is
     // missing.
     ASSERT_EQ(kREJ, out_.tag());
 
     StringPiece srct;
     ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct));
     srct_hex_ = "#" + base::HexEncode(srct.data(), srct.size());
 
     StringPiece scfg;
@@ skipping 60 matching lines @@
     EXPECT_EQ(client_address_.address(), decoder.ip());
     EXPECT_EQ(client_address_.port(), decoder.port());
   }
 
   void ShouldSucceed(const CryptoHandshakeMessage& message) {
     bool called = false;
     RunValidate(message, new ValidateCallback(this, true, "", &called));
     EXPECT_TRUE(called);
   }
 
-  void RunValidate(
-      const CryptoHandshakeMessage& message,
-      ValidateClientHelloResultCallback* cb) {
+  void RunValidate(const CryptoHandshakeMessage& message,
+                   ValidateClientHelloResultCallback* cb) {
     config_.ValidateClientHello(message, client_address_, &clock_, cb);
   }
 
   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) {
     config_.ValidateClientHello(
-        message, client_address_, &clock_,
+        message,
+        client_address_,
+        &clock_,
         new ValidateCallback(this, false, error_substr, called));
   }
 
   void ProcessValidationResult(const CryptoHandshakeMessage& message,
                                const ValidateCallback::Result& result,
                                bool should_succeed,
                                const char* error_substr) {
     string error_details;
-    QuicErrorCode error = config_.ProcessClientHello(
-        result, 1 /* ConnectionId */, client_address_,
-        supported_versions_.front(), supported_versions_,
-        kInitialFlowControlWindowForTest, &clock_, rand_, &params_, &out_,
-        &error_details);
+    QuicErrorCode error =
+        config_.ProcessClientHello(result,
+                                   1 /* ConnectionId */,
+                                   client_address_,
+                                   supported_versions_.front(),
+                                   supported_versions_,
+                                   kInitialFlowControlWindowForTest,
+                                   &clock_,
+                                   rand_,
+                                   &params_,
+                                   &out_,
+                                   &error_details);
 
     if (should_succeed) {
-      ASSERT_EQ(error, QUIC_NO_ERROR)
-          << "Message failed with error " << error_details << ": "
-          << message.DebugString();
+      ASSERT_EQ(error, QUIC_NO_ERROR) << "Message failed with error "
+                                      << error_details << ": "
+                                      << message.DebugString();
     } else {
       ASSERT_NE(error, QUIC_NO_ERROR)
           << "Message didn't fail: " << message.DebugString();
 
       EXPECT_TRUE(error_details.find(error_substr) != string::npos)
           << error_substr << " not in " << error_details;
     }
   }
 
   CryptoHandshakeMessage InchoateClientHello(const char* message_tag, ...) {
     va_list ap;
     va_start(ap, message_tag);
 
     CryptoHandshakeMessage message =
         CryptoTestUtils::BuildMessage(message_tag, ap);
     va_end(ap);
 
     message.SetStringPiece(kPAD, string(kClientHelloMinimumSize, '-'));
     return message;
   }
 
   string GenerateNonce() {
     string nonce;
     CryptoUtils::GenerateNonce(
-        clock_.WallNow(), rand_,
+        clock_.WallNow(),
+        rand_,
         StringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
         &nonce);
     return nonce;
   }
 
  protected:
   QuicRandom* const rand_;
   MockClock clock_;
   const IPEndPoint client_address_;
   QuicVersionVector supported_versions_;
   string client_version_;
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfig::ConfigOptions config_options_;
   QuicCryptoNegotiatedParameters params_;
   CryptoHandshakeMessage out_;
   uint8 orbit_[kOrbitSize];
 
   // These strings contain hex escaped values from the server suitable for
   // passing to |InchoateClientHello| when constructing client hello messages.
   string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
   scoped_ptr<CryptoHandshakeMessage> server_config_;
 };
 
 TEST_F(CryptoServerTest, BadSNI) {
   static const char* kBadSNIs[] = {
-    "",
-    "foo",
-    "#00",
-    "#ff00",
-    "127.0.0.1",
-    "ffee::1",
+      "", "foo", "#00", "#ff00", "127.0.0.1", "ffee::1",
   };
 
-  string client_version = QuicUtils::TagToString(
-      QuicVersionToQuicTag(supported_versions_.front()));
+  string client_version =
+      QuicUtils::TagToString(QuicVersionToQuicTag(supported_versions_.front()));
 
   for (size_t i = 0; i < arraysize(kBadSNIs); i++) {
-    ShouldFailMentioning("SNI", InchoateClientHello(
-        "CHLO",
-        "SNI", kBadSNIs[i],
-        "VER\0", client_version.data(),
-        NULL));
+    ShouldFailMentioning(
+        "SNI",
+        InchoateClientHello(
+            "CHLO", "SNI", kBadSNIs[i], "VER\0", client_version.data(), NULL));
   }
 }
 
 // TODO(rtenneti): Enable the DefaultCert test after implementing ProofSource.
 TEST_F(CryptoServerTest, DISABLED_DefaultCert) {
   // Check that the server replies with a default certificate when no SNI is
   // specified.
-  ShouldSucceed(InchoateClientHello(
-      "CHLO",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "SCID", scid_hex_.c_str(),
-      "#004b5453", srct_hex_.c_str(),
-      "PUBS", pub_hex_.c_str(),
-      "NONC", nonce_hex_.c_str(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      "PDMD", "X509",
-      "VER\0", client_version_.data(),
-      NULL));
+  ShouldSucceed(InchoateClientHello("CHLO",
+                                    "AEAD",
+                                    "AESG",
+                                    "KEXS",
+                                    "C255",
+                                    "SCID",
+                                    scid_hex_.c_str(),
+                                    "#004b5453",
+                                    srct_hex_.c_str(),
+                                    "PUBS",
+                                    pub_hex_.c_str(),
+                                    "NONC",
+                                    nonce_hex_.c_str(),
+                                    "$padding",
+                                    static_cast<int>(kClientHelloMinimumSize),
+                                    "PDMD",
+                                    "X509",
+                                    "VER\0",
+                                    client_version_.data(),
+                                    NULL));
 
   StringPiece cert, proof;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_NE(0u, cert.size());
   EXPECT_NE(0u, proof.size());
 }
 
 TEST_F(CryptoServerTest, TooSmall) {
-  ShouldFailMentioning("too small", CryptoTestUtils::Message(
-        "CHLO",
-        "VER\0", client_version_.data(),
-        NULL));
+  ShouldFailMentioning(
+      "too small",
+      CryptoTestUtils::Message("CHLO", "VER\0", client_version_.data(), NULL));
 }
 
 TEST_F(CryptoServerTest, BadSourceAddressToken) {
   // Invalid source-address tokens should be ignored.
   static const char* kBadSourceAddressTokens[] = {
-    "",
-    "foo",
-    "#0000",
-    "#0000000000000000000000000000000000000000",
+      "", "foo", "#0000", "#0000000000000000000000000000000000000000",
   };
 
   for (size_t i = 0; i < arraysize(kBadSourceAddressTokens); i++) {
-    ShouldSucceed(InchoateClientHello(
-        "CHLO",
-        "STK", kBadSourceAddressTokens[i],
-        "VER\0", client_version_.data(),
-        NULL));
+    ShouldSucceed(InchoateClientHello("CHLO",
+                                      "STK",
+                                      kBadSourceAddressTokens[i],
+                                      "VER\0",
+                                      client_version_.data(),
+                                      NULL));
   }
 }
 
 TEST_F(CryptoServerTest, BadClientNonce) {
   // Invalid nonces should be ignored.
   static const char* kBadNonces[] = {
-    "",
-    "#0000",
-    "#0000000000000000000000000000000000000000",
+      "", "#0000", "#0000000000000000000000000000000000000000",
   };
 
   for (size_t i = 0; i < arraysize(kBadNonces); i++) {
     ShouldSucceed(InchoateClientHello(
-        "CHLO",
-        "NONC", kBadNonces[i],
-        "VER\0", client_version_.data(),
-        NULL));
+        "CHLO", "NONC", kBadNonces[i], "VER\0", client_version_.data(), NULL));
   }
 }
 
 TEST_F(CryptoServerTest, DowngradeAttack) {
   if (supported_versions_.size() == 1) {
     // No downgrade attack is possible if the server only supports one version.
     return;
   }
   // Set the client's preferred version to a supported version that
   // is not the "current" version (supported_versions_.front()).
-  string bad_version = QuicUtils::TagToString(
-      QuicVersionToQuicTag(supported_versions_.back()));
+  string bad_version =
+      QuicUtils::TagToString(QuicVersionToQuicTag(supported_versions_.back()));
 
-  ShouldFailMentioning("Downgrade", InchoateClientHello(
-      "CHLO",
-      "VER\0", bad_version.data(),
-      NULL));
+  ShouldFailMentioning(
+      "Downgrade",
+      InchoateClientHello("CHLO", "VER\0", bad_version.data(), NULL));
 }
 
 TEST_F(CryptoServerTest, ReplayProtection) {
   // This tests that disabling replay protection works.
-  CryptoHandshakeMessage msg = CryptoTestUtils::Message(
-      "CHLO",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "SCID", scid_hex_.c_str(),
-      "#004b5453", srct_hex_.c_str(),
-      "PUBS", pub_hex_.c_str(),
-      "NONC", nonce_hex_.c_str(),
-      "VER\0", client_version_.data(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+  CryptoHandshakeMessage msg =
+      CryptoTestUtils::Message("CHLO",
+                               "AEAD",
+                               "AESG",
+                               "KEXS",
+                               "C255",
+                               "SCID",
+                               scid_hex_.c_str(),
+                               "#004b5453",
+                               srct_hex_.c_str(),
+                               "PUBS",
+                               pub_hex_.c_str(),
+                               "NONC",
+                               nonce_hex_.c_str(),
+                               "VER\0",
+                               client_version_.data(),
+                               "$padding",
+                               static_cast<int>(kClientHelloMinimumSize),
+                               NULL);
   ShouldSucceed(msg);
   // The message should be rejected because the strike-register is still
   // quiescent.
   ASSERT_EQ(kREJ, out_.tag());
 
   config_.set_replay_protection(false);
 
   ShouldSucceed(msg);
   // The message should be accepted now.
   ASSERT_EQ(kSHLO, out_.tag());
@@ skipping 39 matching lines @@
   scoped_ptr<CryptoHandshakeMessage> scfg_b(
       b.AddDefaultConfig(&rand_b, &clock, options));
 
   StringPiece scid_a, scid_b;
   EXPECT_TRUE(scfg_a->GetStringPiece(kSCID, &scid_a));
   EXPECT_TRUE(scfg_b->GetStringPiece(kSCID, &scid_b));
 
   EXPECT_NE(scid_a, scid_b);
 }
 
-
 TEST(CryptoServerConfigGenerationTest, SCIDIsHashOfServerConfig) {
   MockRandom rand_a;
   const QuicCryptoServerConfig::ConfigOptions options;
   MockClock clock;
 
   QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a);
   scoped_ptr<CryptoHandshakeMessage> scfg(
       a.AddDefaultConfig(&rand_a, &clock, options));
 
   StringPiece scid;
@@ skipping 16 matching lines @@
 }
 
 class CryptoServerTestNoConfig : public CryptoServerTest {
  public:
   virtual void SetUp() {
     // Deliberately don't add a config so that we can test this situation.
   }
 };
 
 TEST_F(CryptoServerTestNoConfig, DontCrash) {
-    ShouldFailMentioning("No config", InchoateClientHello(
-        "CHLO",
-        "VER\0", client_version_.data(),
-        NULL));
+  ShouldFailMentioning(
+      "No config",
+      InchoateClientHello("CHLO", "VER\0", client_version_.data(), NULL));
 }
 
 class AsyncStrikeServerVerificationTest : public CryptoServerTest {
  protected:
-  AsyncStrikeServerVerificationTest() {
-  }
+  AsyncStrikeServerVerificationTest() {}
 
   virtual void SetUp() {
     const string kOrbit = "12345678";
     config_options_.orbit = kOrbit;
     strike_register_client_ = new DelayedVerifyStrikeRegisterClient(
         10000,  // strike_register_max_entries
         static_cast<uint32>(clock_.WallNow().ToUNIXSeconds()),
         60,  // strike_register_window_secs
-        reinterpret_cast<const uint8 *>(kOrbit.data()),
+        reinterpret_cast<const uint8*>(kOrbit.data()),
         StrikeRegister::NO_STARTUP_PERIOD_NEEDED);
     config_.SetStrikeRegisterClient(strike_register_client_);
     CryptoServerTest::SetUp();
     strike_register_client_->StartDelayingVerification();
   }
 
   DelayedVerifyStrikeRegisterClient* strike_register_client_;
 };
 
 TEST_F(AsyncStrikeServerVerificationTest, AsyncReplayProtection) {
   // This tests async validation with a strike register works.
-  CryptoHandshakeMessage msg = CryptoTestUtils::Message(
-      "CHLO",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "SCID", scid_hex_.c_str(),
-      "#004b5453", srct_hex_.c_str(),
-      "PUBS", pub_hex_.c_str(),
-      "NONC", nonce_hex_.c_str(),
-      "VER\0", client_version_.data(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+  CryptoHandshakeMessage msg =
+      CryptoTestUtils::Message("CHLO",
+                               "AEAD",
+                               "AESG",
+                               "KEXS",
+                               "C255",
+                               "SCID",
+                               scid_hex_.c_str(),
+                               "#004b5453",
+                               srct_hex_.c_str(),
+                               "PUBS",
+                               pub_hex_.c_str(),
+                               "NONC",
+                               nonce_hex_.c_str(),
+                               "VER\0",
+                               client_version_.data(),
+                               "$padding",
+                               static_cast<int>(kClientHelloMinimumSize),
+                               NULL);
 
   // Clear the message tag.
   out_.set_tag(0);
 
   bool called = false;
   RunValidate(msg, 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());
@@ skipping 13 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   EXPECT_EQ(kREJ, out_.tag());
 }
 
 TEST_F(CryptoServerTest, InitialFlowControlWindow) {
   // Test that the SHLO contains a value for initial flow control window.
-  CryptoHandshakeMessage msg = CryptoTestUtils::Message(
-      "CHLO",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "SCID", scid_hex_.c_str(),
-      "#004b5453", srct_hex_.c_str(),
-      "PUBS", pub_hex_.c_str(),
-      "NONC", nonce_hex_.c_str(),
-      "VER\0", client_version_.data(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+  CryptoHandshakeMessage msg =
+      CryptoTestUtils::Message("CHLO",
+                               "AEAD",
+                               "AESG",
+                               "KEXS",
+                               "C255",
+                               "SCID",
+                               scid_hex_.c_str(),
+                               "#004b5453",
+                               srct_hex_.c_str(),
+                               "PUBS",
+                               pub_hex_.c_str(),
+                               "NONC",
+                               nonce_hex_.c_str(),
+                               "VER\0",
+                               client_version_.data(),
+                               "$padding",
+                               static_cast<int>(kClientHelloMinimumSize),
+                               NULL);
   ShouldSucceed(msg);
   // The message should be rejected because the strike-register is still
   // quiescent.
   ASSERT_EQ(kREJ, out_.tag());
   config_.set_replay_protection(false);
 
   // The message should be accepted now.
   ShouldSucceed(msg);
   ASSERT_EQ(kSHLO, out_.tag());
   CheckServerHello(out_);
 
   // Ensure that the kIFCW tag is populated correctly.
   QuicTag ifcw;
   EXPECT_EQ(QUIC_NO_ERROR, out_.GetUint32(kIFCW, &ifcw));
   EXPECT_EQ(kInitialFlowControlWindowForTest, ifcw);
 }
 
 }  // namespace test
 }  // namespace net