Clang format slam.

net/quic/crypto/quic_crypto_server_config_test.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/quic_crypto_server_config.h"
 
 #include <stdarg.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
@@ skipping 27 matching lines @@
       return scoped_refptr<QuicCryptoServerConfig::Config>(
           server_config_->primary_config_);
     } else {
       return server_config_->GetConfigWithScid(config_id);
     }
   }
 
   bool ConfigHasDefaultSourceAddressTokenBoxer(string config_id) {
     scoped_refptr<QuicCryptoServerConfig::Config> config = GetConfig(config_id);
     return config->source_address_token_boxer ==
-        &(server_config_->default_source_address_token_boxer_);
+           &(server_config_->default_source_address_token_boxer_);
   }
 
-  string NewSourceAddressToken(
-      string config_id,
-      IPEndPoint ip,
-      QuicRandom* rand,
-      QuicWallTime now) {
+  string NewSourceAddressToken(string config_id,
+                               IPEndPoint ip,
+                               QuicRandom* rand,
+                               QuicWallTime now) {
     return server_config_->NewSourceAddressToken(
         *GetConfig(config_id), ip, rand, now);
   }
 
   bool ValidateSourceAddressToken(string config_id,
                                   StringPiece srct,
                                   IPEndPoint ip,
                                   QuicWallTime now) {
     return server_config_->ValidateSourceAddressToken(
         *GetConfig(config_id), srct, ip, now);
@@ skipping 42 matching lines @@
       expected.push_back(make_pair(server_config_id, is_primary));
     }
 
     va_end(ap);
 
     base::AutoLock locked(server_config_->configs_lock_);
 
     ASSERT_EQ(expected.size(), server_config_->configs_.size())
         << ConfigsDebug();
 
-    for (QuicCryptoServerConfig::ConfigMap::const_iterator
-             i = server_config_->configs_.begin();
-         i != server_config_->configs_.end(); ++i) {
+    for (QuicCryptoServerConfig::ConfigMap::const_iterator i =
+             server_config_->configs_.begin();
+         i != server_config_->configs_.end();
+         ++i) {
       bool found = false;
       for (vector<pair<ServerConfigID, bool> >::iterator j = expected.begin();
-           j != expected.end(); ++j) {
+           j != expected.end();
+           ++j) {
         if (i->first == j->first && i->second->is_primary == j->second) {
           found = true;
           j->first.clear();
           break;
         }
       }
 
       ASSERT_TRUE(found) << "Failed to find match for " << i->first
                          << " in configs:\n" << ConfigsDebug();
     }
   }
 
   // ConfigsDebug returns a string that contains debugging information about
   // the set of Configs loaded in |server_config_| and their status.
   // ConfigsDebug() should be called after acquiring
   // server_config_->configs_lock_.
   string ConfigsDebug() {
     if (server_config_->configs_.empty()) {
       return "No Configs in QuicCryptoServerConfig";
     }
 
     string s;
 
-    for (QuicCryptoServerConfig::ConfigMap::const_iterator
-             i = server_config_->configs_.begin();
-         i != server_config_->configs_.end(); ++i) {
+    for (QuicCryptoServerConfig::ConfigMap::const_iterator i =
+             server_config_->configs_.begin();
+         i != server_config_->configs_.end();
+         ++i) {
       const scoped_refptr<QuicCryptoServerConfig::Config> config = i->second;
       if (config->is_primary) {
         s += "(primary) ";
       } else {
         s += "          ";
       }
       s += config->id;
       s += "\n";
     }
 
     return s;
   }
 
   void SelectNewPrimaryConfig(int seconds) {
     base::AutoLock locked(server_config_->configs_lock_);
     server_config_->SelectNewPrimaryConfig(
         QuicWallTime::FromUNIXSeconds(seconds));
   }
 
  private:
   const QuicCryptoServerConfig* server_config_;
 };
 
 class TestStrikeRegisterClient : public StrikeRegisterClient {
  public:
   explicit TestStrikeRegisterClient(QuicCryptoServerConfig* config)
-      : config_(config),
-        is_known_orbit_called_(false) {
-  }
+      : config_(config), is_known_orbit_called_(false) {}
 
   virtual bool IsKnownOrbit(StringPiece orbit) const OVERRIDE {
     // Ensure that the strike register client lock is not held.
     QuicCryptoServerConfigPeer peer(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);
 
     is_known_orbit_called_ = true;
     return true;
   }
 
-  virtual void VerifyNonceIsValidAndUnique(
-      StringPiece nonce,
-      QuicWallTime now,
-      ResultCallback* cb) OVERRIDE {
+  virtual void VerifyNonceIsValidAndUnique(StringPiece nonce,
+                                           QuicWallTime now,
+                                           ResultCallback* cb) OVERRIDE {
     LOG(FATAL) << "Not implemented";
   }
 
   bool is_known_orbit_called() { return is_known_orbit_called_; }
 
  private:
   QuicCryptoServerConfig* config_;
   mutable bool is_known_orbit_called_;
 };
 
 TEST(QuicCryptoServerConfigTest, ServerConfig) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   MockClock clock;
 
-  scoped_ptr<CryptoHandshakeMessage>(
-      server.AddDefaultConfig(rand, &clock,
-                              QuicCryptoServerConfig::ConfigOptions()));
+  scoped_ptr<CryptoHandshakeMessage>(server.AddDefaultConfig(
+      rand, &clock, QuicCryptoServerConfig::ConfigOptions()));
 }
 
 TEST(QuicCryptoServerConfigTest, GetOrbitIsCalledWithoutTheStrikeRegisterLock) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   MockClock clock;
 
   TestStrikeRegisterClient* strike_register =
       new TestStrikeRegisterClient(&server);
   server.SetStrikeRegisterClient(strike_register);
@@ skipping 11 matching lines @@
   MockClock clock;
   clock.AdvanceTime(QuicTime::Delta::FromSeconds(1000000));
 
   QuicWallTime now = clock.WallNow();
   const QuicWallTime original_time = now;
 
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   QuicCryptoServerConfigPeer peer(&server);
 
-  scoped_ptr<CryptoHandshakeMessage>(
-      server.AddDefaultConfig(rand, &clock,
-                              QuicCryptoServerConfig::ConfigOptions()));
+  scoped_ptr<CryptoHandshakeMessage>(server.AddDefaultConfig(
+      rand, &clock, QuicCryptoServerConfig::ConfigOptions()));
 
   // Add a config that overrides the default boxer.
   QuicCryptoServerConfig::ConfigOptions options;
   options.id = kOverride;
   scoped_ptr<QuicServerConfigProtobuf> protobuf(
       QuicCryptoServerConfig::GenerateConfig(rand, &clock, options));
   protobuf->set_source_address_token_secret_override("a secret key");
   // Lower priority than the default config.
   protobuf->set_priority(1);
-  scoped_ptr<CryptoHandshakeMessage>(
-      server.AddConfig(protobuf.get(), now));
+  scoped_ptr<CryptoHandshakeMessage>(server.AddConfig(protobuf.get(), now));
 
   EXPECT_TRUE(peer.ConfigHasDefaultSourceAddressTokenBoxer(kPrimary));
   EXPECT_FALSE(peer.ConfigHasDefaultSourceAddressTokenBoxer(kOverride));
 
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   IPEndPoint ip4 = IPEndPoint(ip, 1);
   CHECK(ParseIPLiteralToNumber("2001:db8:0::42", &ip));
   IPEndPoint ip6 = IPEndPoint(ip, 2);
 
   // Primary config generates configs that validate successfully.
   const string token4 = peer.NewSourceAddressToken(kPrimary, ip4, rand, now);
   const string token6 = peer.NewSourceAddressToken(kPrimary, ip6, rand, now);
   EXPECT_TRUE(peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
   EXPECT_FALSE(peer.ValidateSourceAddressToken(kPrimary, token4, ip6, now));
   EXPECT_TRUE(peer.ValidateSourceAddressToken(kPrimary, token6, ip6, now));
 
   // Override config generates configs that validate successfully.
-  const string override_token4 = peer.NewSourceAddressToken(
-      kOverride, ip4, rand, now);
-  const string override_token6 = peer.NewSourceAddressToken(
-      kOverride, ip6, rand, now);
-  EXPECT_TRUE(peer.ValidateSourceAddressToken(
-      kOverride, override_token4, ip4, now));
-  EXPECT_FALSE(peer.ValidateSourceAddressToken(
-      kOverride, override_token4, ip6, now));
-  EXPECT_TRUE(peer.ValidateSourceAddressToken(
-      kOverride, override_token6, ip6, now));
+  const string override_token4 =
+      peer.NewSourceAddressToken(kOverride, ip4, rand, now);
+  const string override_token6 =
+      peer.NewSourceAddressToken(kOverride, ip6, rand, now);
+  EXPECT_TRUE(
+      peer.ValidateSourceAddressToken(kOverride, override_token4, ip4, now));
+  EXPECT_FALSE(
+      peer.ValidateSourceAddressToken(kOverride, override_token4, ip6, now));
+  EXPECT_TRUE(
+      peer.ValidateSourceAddressToken(kOverride, override_token6, ip6, now));
 
   // Tokens generated by the primary config do not validate
   // successfully against the override config, and vice versa.
   EXPECT_FALSE(peer.ValidateSourceAddressToken(kOverride, token4, ip4, now));
   EXPECT_FALSE(peer.ValidateSourceAddressToken(kOverride, token6, ip6, now));
-  EXPECT_FALSE(peer.ValidateSourceAddressToken(
-      kPrimary, override_token4, ip4, now));
-  EXPECT_FALSE(peer.ValidateSourceAddressToken(
-      kPrimary, override_token6, ip6, now));
+  EXPECT_FALSE(
+      peer.ValidateSourceAddressToken(kPrimary, override_token4, ip4, now));
+  EXPECT_FALSE(
+      peer.ValidateSourceAddressToken(kPrimary, override_token6, ip6, now));
 
   // Validation fails after tokens expire.
   now = original_time.Add(QuicTime::Delta::FromSeconds(86400 * 7));
   EXPECT_FALSE(peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
 
   now = original_time.Subtract(QuicTime::Delta::FromSeconds(3600 * 2));
   EXPECT_FALSE(peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
 }
 
 class CryptoServerConfigsTest : public ::testing::Test {
@@ skipping 78 matching lines @@
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfigPeer test_peer_;
 };
 
 TEST_F(CryptoServerConfigsTest, NoConfigs) {
   test_peer_.CheckConfigs(NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimaryFirst) {
   // Make sure that "b" is primary even though "a" comes first.
-  SetConfigs("a", 1100, 1,
-             "b", 900, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      NULL);
+  SetConfigs("a", 1100, 1, "b", 900, 1, NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimarySecond) {
   // Make sure that a remains primary after b is added.
-  SetConfigs("a", 900, 1,
-             "b", 1100, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      NULL);
+  SetConfigs("a", 900, 1, "b", 1100, 1, NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, Delete) {
   // Ensure that configs get deleted when removed.
-  SetConfigs("a", 800, 1,
-             "b", 900, 1,
-             "c", 1100, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      "c", false,
-      NULL);
-  SetConfigs("b", 900, 1,
-             "c", 1100, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "b", true,
-      "c", false,
-      NULL);
+  SetConfigs("a", 800, 1, "b", 900, 1, "c", 1100, 1, NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, "c", false, NULL);
+  SetConfigs("b", 900, 1, "c", 1100, 1, NULL);
+  test_peer_.CheckConfigs("b", true, "c", false, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, DeletePrimary) {
   // Ensure that deleting the primary config works.
-  SetConfigs("a", 800, 1,
-             "b", 900, 1,
-             "c", 1100, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      "c", false,
-      NULL);
-  SetConfigs("a", 800, 1,
-             "c", 1100, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "c", false,
-      NULL);
+  SetConfigs("a", 800, 1, "b", 900, 1, "c", 1100, 1, NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, "c", false, NULL);
+  SetConfigs("a", 800, 1, "c", 1100, 1, NULL);
+  test_peer_.CheckConfigs("a", true, "c", false, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, FailIfDeletingAllConfigs) {
   // Ensure that configs get deleted when removed.
-  SetConfigs("a", 800, 1,
-             "b", 900, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      NULL);
+  SetConfigs("a", 800, 1, "b", 900, 1, NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, NULL);
   SetConfigs(NULL);
   // Config change is rejected, still using old configs.
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, ChangePrimaryTime) {
   // Check that updates to primary time get picked up.
-  SetConfigs("a", 400, 1,
-             "b", 800, 1,
-             "c", 1200, 1,
-             NULL);
+  SetConfigs("a", 400, 1, "b", 800, 1, "c", 1200, 1, NULL);
   test_peer_.SelectNewPrimaryConfig(500);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      "c", false,
-      NULL);
-  SetConfigs("a", 1200, 1,
-             "b", 800, 1,
-             "c", 400, 1,
-             NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, "c", false, NULL);
+  SetConfigs("a", 1200, 1, "b", 800, 1, "c", 400, 1, NULL);
   test_peer_.SelectNewPrimaryConfig(500);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", false,
-      "c", true,
-      NULL);
+  test_peer_.CheckConfigs("a", false, "b", false, "c", true, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, AllConfigsInThePast) {
   // Check that the most recent config is selected.
-  SetConfigs("a", 400, 1,
-             "b", 800, 1,
-             "c", 1200, 1,
-             NULL);
+  SetConfigs("a", 400, 1, "b", 800, 1, "c", 1200, 1, NULL);
   test_peer_.SelectNewPrimaryConfig(1500);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", false,
-      "c", true,
-      NULL);
+  test_peer_.CheckConfigs("a", false, "b", false, "c", true, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, AllConfigsInTheFuture) {
   // Check that the first config is selected.
-  SetConfigs("a", 400, 1,
-             "b", 800, 1,
-             "c", 1200, 1,
-             NULL);
+  SetConfigs("a", 400, 1, "b", 800, 1, "c", 1200, 1, NULL);
   test_peer_.SelectNewPrimaryConfig(100);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      "c", false,
-      NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, "c", false, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, SortByPriority) {
   // Check that priority is used to decide on a primary config when
   // configs have the same primary time.
-  SetConfigs("a", 900, 1,
-             "b", 900, 2,
-             "c", 900, 3,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      "c", false,
-      NULL);
+  SetConfigs("a", 900, 1, "b", 900, 2, "c", 900, 3, NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, "c", false, NULL);
   test_peer_.SelectNewPrimaryConfig(800);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      "c", false,
-      NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, "c", false, NULL);
   test_peer_.SelectNewPrimaryConfig(1000);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      "c", false,
-      NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, "c", false, NULL);
 
   // Change priorities and expect sort order to change.
-  SetConfigs("a", 900, 2,
-             "b", 900, 1,
-             "c", 900, 0,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", false,
-      "c", true,
-      NULL);
+  SetConfigs("a", 900, 2, "b", 900, 1, "c", 900, 0, NULL);
+  test_peer_.CheckConfigs("a", false, "b", false, "c", true, NULL);
   test_peer_.SelectNewPrimaryConfig(800);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", false,
-      "c", true,
-      NULL);
+  test_peer_.CheckConfigs("a", false, "b", false, "c", true, NULL);
   test_peer_.SelectNewPrimaryConfig(1000);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", false,
-      "c", true,
-      NULL);
+  test_peer_.CheckConfigs("a", false, "b", false, "c", true, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, AdvancePrimary) {
   // Check that a new primary config is enabled at the right time.
-  SetConfigs("a", 900, 1,
-             "b", 1100, 1,
-             NULL);
+  SetConfigs("a", 900, 1, "b", 1100, 1, NULL);
   test_peer_.SelectNewPrimaryConfig(1000);
-  test_peer_.CheckConfigs(
-      "a", true,
-      "b", false,
-      NULL);
+  test_peer_.CheckConfigs("a", true, "b", false, NULL);
   test_peer_.SelectNewPrimaryConfig(1101);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, NULL);
 }
 
 TEST_F(CryptoServerConfigsTest, InvalidConfigs) {
   // Ensure that invalid configs don't change anything.
-  SetConfigs("a", 800, 1,
-             "b", 900, 1,
-             "c", 1100, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      "c", false,
-      NULL);
-  SetConfigs("a", 800, 1,
-             "c", 1100, 1,
-             "INVALID1", 1000, 1,
-             NULL);
-  test_peer_.CheckConfigs(
-      "a", false,
-      "b", true,
-      "c", false,
-      NULL);
+  SetConfigs("a", 800, 1, "b", 900, 1, "c", 1100, 1, NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, "c", false, NULL);
+  SetConfigs("a", 800, 1, "c", 1100, 1, "INVALID1", 1000, 1, NULL);
+  test_peer_.CheckConfigs("a", false, "b", true, "c", false, NULL);
 }
 
 }  // namespace test
 }  // namespace net