Merge internal change: 63891842 - QuicServerId changes

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"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_crypto_client_stream.h"
 #include "net/quic/quic_crypto_server_stream.h"
 #include "net/quic/quic_crypto_stream.h"
-#include "net/quic/quic_session_key.h"
+#include "net/quic/quic_server_id.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::pair;
 using std::string;
 using std::vector;
 
 namespace net {
 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) {
   }
 
-  virtual void OnError(CryptoFramer* framer) OVERRIDE {
-    error_ = true;
-  }
+  virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
 
   virtual void OnHandshakeMessage(
       const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
   bool error() const {
     return error_;
   }
 
@@ skipping 115 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());
   }
-  QuicSessionKey server_key(kServerHostname, kServerPort, false,
-                            kPrivacyModeDisabled);
-  QuicCryptoClientStream client(server_key, &client_session, NULL,
+  QuicServerId server_id(kServerHostname, kServerPort, false,
+                         kPrivacyModeDisabled);
+  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) {
-    EXPECT_EQ(crypto_config.channel_id_signer()->GetKeyForHostname(
-                  kServerHostname),
-              server->crypto_negotiated_params().channel_id);
+    EXPECT_EQ(
+        crypto_config.channel_id_signer()->GetKeyForHostname(kServerHostname),
+        server->crypto_negotiated_params().channel_id);
   }
 
   return client.num_sent_client_hellos();
 }
 
 // static
 void CryptoTestUtils::SetupCryptoServerConfigForTest(
     const QuicClock* clock,
     QuicRandom* rand,
     QuicConfig* config,
@@ skipping 278 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(len % 2 == 0);
+      CHECK_EQ(0u, len % 2);
       scoped_ptr<uint8[]> buf(new uint8[len/2]);
 
       for (size_t i = 0; i < len/2; i++) {
         uint8 v = 0;
         CHECK(HexChar(valuestr[i*2], &v));
         buf[i] = v << 4;
         CHECK(HexChar(valuestr[i*2 + 1], &v));
         buf[i] |= v;
       }
 
@@ skipping 10 matching lines @@
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net