Clang format slam.

net/quic/test_tools/crypto_test_utils.cc

 // Copyright (c) 2012 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/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 19 matching lines @@
 namespace test {
 
 namespace {
 
 const char kServerHostname[] = "test.example.com";
 const uint16 kServerPort = 80;
 
 // CryptoFramerVisitor is a framer visitor that records handshake messages.
 class CryptoFramerVisitor : public CryptoFramerVisitorInterface {
  public:
-  CryptoFramerVisitor()
-      : error_(false) {
-  }
+  CryptoFramerVisitor() : error_(false) {}
 
   virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
 
   virtual void OnHandshakeMessage(
       const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
-  bool error() const {
-    return error_;
-  }
+  bool error() const { return error_; }
 
-  const vector<CryptoHandshakeMessage>& messages() const {
-    return messages_;
-  }
+  const vector<CryptoHandshakeMessage>& messages() const { return messages_; }
 
  private:
   bool error_;
   vector<CryptoHandshakeMessage> messages_;
 };
 
 // MovePackets parses crypto handshake messages from packet number
 // |*inout_packet_index| through to the last packet and has |dest_stream|
 // process them. |*inout_packet_index| is updated with an index one greater
 // than the last packet processed.
 void MovePackets(PacketSavingConnection* source_conn,
-                 size_t *inout_packet_index,
+                 size_t* inout_packet_index,
                  QuicCryptoStream* dest_stream,
                  PacketSavingConnection* dest_conn) {
   SimpleQuicFramer framer(source_conn->supported_versions());
   CryptoFramer crypto_framer;
   CryptoFramerVisitor crypto_visitor;
 
   // In order to properly test the code we need to perform encryption and
   // decryption so that the crypters latch when expected. The crypters are in
   // |dest_conn|, but we don't want to try and use them there. Instead we swap
   // them into |framer|, perform the decryption with them, and then swap them
   // back.
   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
 
   crypto_framer.set_visitor(&crypto_visitor);
 
   size_t index = *inout_packet_index;
   for (; index < source_conn->encrypted_packets_.size(); index++) {
     ASSERT_TRUE(framer.ProcessPacket(*source_conn->encrypted_packets_[index]));
-    for (vector<QuicStreamFrame>::const_iterator
-         i =  framer.stream_frames().begin();
-         i != framer.stream_frames().end(); ++i) {
+    for (vector<QuicStreamFrame>::const_iterator i =
+             framer.stream_frames().begin();
+         i != framer.stream_frames().end();
+         ++i) {
       scoped_ptr<string> frame_data(i->GetDataAsString());
       ASSERT_TRUE(crypto_framer.ProcessInput(*frame_data));
       ASSERT_FALSE(crypto_visitor.error());
     }
   }
   *inout_packet_index = index;
 
   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
 
   ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
 
-  for (vector<CryptoHandshakeMessage>::const_iterator
-       i = crypto_visitor.messages().begin();
-       i != crypto_visitor.messages().end(); ++i) {
+  for (vector<CryptoHandshakeMessage>::const_iterator i =
+           crypto_visitor.messages().begin();
+       i != crypto_visitor.messages().end();
+       ++i) {
     dest_stream->OnHandshakeMessage(*i);
   }
 }
 
 // HexChar parses |c| as a hex character. If valid, it sets |*value| to the
 // value of the hex character and returns true. Otherwise it returns false.
 bool HexChar(char c, uint8* value) {
   if (c >= '0' && c <= '9') {
     *value = c - '0';
     return true;
   }
   if (c >= 'a' && c <= 'f') {
     *value = c - 'a' + 10;
     return true;
   }
   if (c >= 'A' && c <= 'F') {
     *value = c - 'A' + 10;
     return true;
   }
   return false;
 }
 
 }  // anonymous namespace
 
 CryptoTestUtils::FakeClientOptions::FakeClientOptions()
-    : dont_verify_certs(false),
-      channel_id_enabled(false) {
+    : dont_verify_certs(false), channel_id_enabled(false) {
 }
 
 // static
 int CryptoTestUtils::HandshakeWithFakeServer(
     PacketSavingConnection* client_conn,
     QuicCryptoClientStream* client) {
   PacketSavingConnection* server_conn =
       new PacketSavingConnection(true, client_conn->supported_versions());
   TestSession server_session(server_conn, DefaultQuicConfig());
 
   QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING,
                                        QuicRandom::GetInstance());
   SetupCryptoServerConfigForTest(
       server_session.connection()->clock(),
       server_session.connection()->random_generator(),
-      server_session.config(), &crypto_config);
+      server_session.config(),
+      &crypto_config);
 
   QuicCryptoServerStream server(crypto_config, &server_session);
   server_session.SetCryptoStream(&server);
 
   // The client's handshake must have been started already.
   CHECK_NE(0u, client_conn->packets_.size());
 
   CommunicateHandshakeMessages(client_conn, client, server_conn, &server);
 
   CompareClientAndServerKeys(client, &server);
@@ skipping 12 matching lines @@
 
   client_session.config()->SetDefaults();
   crypto_config.SetDefaults();
   // TODO(rtenneti): Enable testing of ProofVerifier.
   // if (!options.dont_verify_certs) {
   //   crypto_config.SetProofVerifier(ProofVerifierForTesting());
   // }
   if (options.channel_id_enabled) {
     crypto_config.SetChannelIDSigner(ChannelIDSignerForTesting());
   }
-  QuicServerId server_id(kServerHostname, kServerPort, false,
-                         PRIVACY_MODE_DISABLED);
-  QuicCryptoClientStream client(server_id, &client_session, NULL,
-                                &crypto_config);
+  QuicServerId server_id(
+      kServerHostname, kServerPort, false, PRIVACY_MODE_DISABLED);
+  QuicCryptoClientStream client(
+      server_id, &client_session, NULL, &crypto_config);
   client_session.SetCryptoStream(&client);
 
   CHECK(client.CryptoConnect());
   CHECK_EQ(1u, client_conn->packets_.size());
 
   CommunicateHandshakeMessages(client_conn, &client, server_conn, server);
 
   CompareClientAndServerKeys(&client, server);
 
   if (options.channel_id_enabled) {
@@ skipping 69 matching lines @@
   QuicTagValueMap::const_iterator it = message.tag_value_map().find(tag);
   if (it == message.tag_value_map().end()) {
     return string();
   }
   return it->second;
 }
 
 class MockCommonCertSets : public CommonCertSets {
  public:
   MockCommonCertSets(StringPiece cert, uint64 hash, uint32 index)
-      : cert_(cert.as_string()),
-        hash_(hash),
-        index_(index) {
-  }
+      : cert_(cert.as_string()), hash_(hash), index_(index) {}
 
   virtual StringPiece GetCommonHashes() const OVERRIDE {
     CHECK(false) << "not implemented";
     return StringPiece();
   }
 
   virtual StringPiece GetCert(uint64 hash, uint32 index) const OVERRIDE {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
@@ skipping 130 matching lines @@
 }
 
 // static
 QuicTag CryptoTestUtils::ParseTag(const char* tagstr) {
   const size_t len = strlen(tagstr);
   CHECK_NE(0u, len);
 
   QuicTag tag = 0;
 
   if (tagstr[0] == '#') {
-    CHECK_EQ(static_cast<size_t>(1 + 2*4), len);
+    CHECK_EQ(static_cast<size_t>(1 + 2 * 4), len);
     tagstr++;
 
     for (size_t i = 0; i < 8; i++) {
       tag <<= 4;
 
       uint8 v = 0;
       CHECK(HexChar(tagstr[i], &v));
       tag |= v;
     }
 
@@ skipping 48 matching lines @@
 
     const QuicTag tag = ParseTag(tagstr);
     const char* valuestr = va_arg(ap, const char*);
 
     size_t len = strlen(valuestr);
     if (len > 0 && valuestr[0] == '#') {
       valuestr++;
       len--;
 
       CHECK_EQ(0u, len % 2);
-      scoped_ptr<uint8[]> buf(new uint8[len/2]);
+      scoped_ptr<uint8[]> buf(new uint8[len / 2]);
 
-      for (size_t i = 0; i < len/2; i++) {
+      for (size_t i = 0; i < len / 2; i++) {
         uint8 v = 0;
-        CHECK(HexChar(valuestr[i*2], &v));
+        CHECK(HexChar(valuestr[i * 2], &v));
         buf[i] = v << 4;
-        CHECK(HexChar(valuestr[i*2 + 1], &v));
+        CHECK(HexChar(valuestr[i * 2 + 1], &v));
         buf[i] |= v;
       }
 
       msg.SetStringPiece(
-          tag, StringPiece(reinterpret_cast<char*>(buf.get()), len/2));
+          tag, StringPiece(reinterpret_cast<char*>(buf.get()), len / 2));
       continue;
     }
 
     msg.SetStringPiece(tag, valuestr);
   }
 
   // The CryptoHandshakeMessage needs to be serialized and parsed to ensure
   // that any padding is included.
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net