Cleanup changes: Rename QuicSession::MarkWriteBlocked to

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 85 matching lines @@
   //   // status.
   //   CheckConfigs(
   //     "id1", false,
   //     "id2", true,
   //     "id3", false,
   //     nullptr);
   void CheckConfigs(const char* server_config_id1, ...) {
     va_list ap;
     va_start(ap, server_config_id1);
 
-    vector<pair<ServerConfigID, bool> > expected;
+    vector<pair<ServerConfigID, bool>> expected;
     bool first = true;
     for (;;) {
       const char* server_config_id;
       if (first) {
         server_config_id = server_config_id1;
         first = false;
       } else {
         server_config_id = va_arg(ap, const char*);
       }
 
       if (!server_config_id) {
         break;
       }
 
       // varargs will promote the value to an int so we have to read that from
       // the stack and cast down.
       const bool is_primary = static_cast<bool>(va_arg(ap, int));
       expected.push_back(std::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 (const pair<const ServerConfigID,
+                    scoped_refptr<QuicCryptoServerConfig::Config>>& i :
+         server_config_->configs_) {
       bool found = false;
-      for (vector<pair<ServerConfigID, bool> >::iterator j = expected.begin();
-           j != expected.end(); ++j) {
-        if (i->first == j->first && i->second->is_primary == j->second) {
+      for (pair<ServerConfigID, bool>& j : expected) {
+        if (i.first == j.first && i.second->is_primary == j.second) {
           found = true;
-          j->first.clear();
+          j.first.clear();
           break;
         }
       }
 
-      ASSERT_TRUE(found) << "Failed to find match for " << i->first
+      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) {
-      const scoped_refptr<QuicCryptoServerConfig::Config> config = i->second;
+    for (const auto& i : server_config_->configs_) {
+      const scoped_refptr<QuicCryptoServerConfig::Config> config = i.second;
       if (config->is_primary) {
         s += "(primary) ";
       } else {
         s += "          ";
       }
       s += config->id;
       s += "\n";
     }
 
     return s;
@@ skipping 55 matching lines @@
 TEST(QuicCryptoServerConfigTest, GetOrbitIsCalledWithoutTheStrikeRegisterLock) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   MockClock clock;
 
   TestStrikeRegisterClient* strike_register =
       new TestStrikeRegisterClient(&server);
   server.SetStrikeRegisterClient(strike_register);
 
   QuicCryptoServerConfig::ConfigOptions options;
-  scoped_ptr<CryptoHandshakeMessage>(
+  scoped_ptr<CryptoHandshakeMessage> message(
       server.AddDefaultConfig(rand, &clock, options));
   EXPECT_TRUE(strike_register->is_known_orbit_called());
 }
 
 class SourceAddressTokenTest : public ::testing::Test {
  public:
   SourceAddressTokenTest()
       : ip4_(Loopback4()),
         ip4_dual_(ConvertIPv4NumberToIPv6Number(ip4_)),
         ip6_(Loopback6()),
@@ skipping 499 matching lines @@
              nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
       nullptr);
 }
 
 }  // namespace test
 }  // namespace net