Update from https://crrev.com/316786

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 181 matching lines @@
 
   SetupCryptoServerConfigForTest(
       server_session.connection()->clock(),
       server_session.connection()->random_generator(),
       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());
+  CHECK_NE(0u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessages(client_conn, client, server_conn, &server);
 
   CompareClientAndServerKeys(client, &server);
 
   return client->num_sent_client_hellos();
 }
 
 // static
 int CryptoTestUtils::HandshakeWithFakeClient(
@@ skipping 24 matching lines @@
     crypto_config.SetChannelIDSource(source);
   }
   QuicServerId server_id(kServerHostname, kServerPort, is_https,
                          PRIVACY_MODE_DISABLED);
   QuicCryptoClientStream client(server_id, &client_session,
                                 ProofVerifyContextForTesting(),
                                 &crypto_config);
   client_session.SetCryptoStream(&client);
 
   client.CryptoConnect();
-  CHECK_EQ(1u, client_conn->packets_.size());
+  CHECK_EQ(1u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessagesAndRunCallbacks(
       client_conn, &client, server_conn, server, async_channel_id_source);
 
   CompareClientAndServerKeys(&client, server);
 
   if (options.channel_id_enabled) {
     scoped_ptr<ChannelIDKey> channel_id_key;
     QuicAsyncStatus status = crypto_config.channel_id_source()->GetChannelIDKey(
         kServerHostname, &channel_id_key, nullptr);
@@ skipping 30 matching lines @@
 
 // static
 void CryptoTestUtils::CommunicateHandshakeMessagesAndRunCallbacks(
     PacketSavingConnection* a_conn,
     QuicCryptoStream* a,
     PacketSavingConnection* b_conn,
     QuicCryptoStream* b,
     CallbackSource* callback_source) {
   size_t a_i = 0, b_i = 0;
   while (!a->handshake_confirmed()) {
-    ASSERT_GT(a_conn->packets_.size(), a_i);
-    LOG(INFO) << "Processing " << a_conn->packets_.size() - a_i
-              << " packets a->b";
+    ASSERT_GT(a_conn->encrypted_packets_.size(), a_i);
+    VLOG(1) << "Processing " << a_conn->encrypted_packets_.size() - a_i
+            << " packets a->b";
     MovePackets(a_conn, &a_i, b, b_conn);
     if (callback_source) {
       callback_source->RunPendingCallbacks();
     }
 
-    ASSERT_GT(b_conn->packets_.size(), b_i);
-    LOG(INFO) << "Processing " << b_conn->packets_.size() - b_i
-              << " packets b->a";
+    ASSERT_GT(b_conn->encrypted_packets_.size(), b_i);
+    VLOG(1) << "Processing " << b_conn->encrypted_packets_.size() - b_i
+            << " packets b->a";
     MovePackets(b_conn, &b_i, a, a_conn);
     if (callback_source) {
       callback_source->RunPendingCallbacks();
     }
   }
 }
 
 // static
 pair<size_t, size_t> CryptoTestUtils::AdvanceHandshake(
     PacketSavingConnection* a_conn,
     QuicCryptoStream* a,
     size_t a_i,
     PacketSavingConnection* b_conn,
     QuicCryptoStream* b,
     size_t b_i) {
-  LOG(INFO) << "Processing " << a_conn->packets_.size() - a_i
-            << " packets a->b";
+  VLOG(1) << "Processing " << a_conn->encrypted_packets_.size() - a_i
+          << " packets a->b";
   MovePackets(a_conn, &a_i, b, b_conn);
 
-  LOG(INFO) << "Processing " << b_conn->packets_.size() - b_i
-            << " packets b->a";
-  if (b_conn->packets_.size() - b_i == 2) {
-    LOG(INFO) << "here";
+  VLOG(1) << "Processing " << b_conn->encrypted_packets_.size() - b_i
+          << " packets b->a";
+  if (b_conn->encrypted_packets_.size() - b_i == 2) {
+    VLOG(1) << "here";
   }
   MovePackets(b_conn, &b_i, a, a_conn);
 
-  return make_pair(a_i, b_i);
+  return std::make_pair(a_i, b_i);
 }
 
 // static
 string CryptoTestUtils::GetValueForTag(const CryptoHandshakeMessage& message,
                                        QuicTag tag) {
   QuicTagValueMap::const_iterator it = message.tag_value_map().find(tag);
   if (it == message.tag_value_map().end()) {
     return string();
   }
   return it->second;
@@ skipping 278 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