Remove using namespace in net/quic/quic_stream_sequencer.h

net/http/disk_cache_based_quic_server_info_unittest.cc

 // Copyright 2014 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/http/disk_cache_based_quic_server_info.h"
 
+#include <string>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/net_errors.h"
 #include "net/http/mock_http_cache.h"
 #include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/quic_server_id.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 60 matching lines @@
 
   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
 
   QuicServerInfo::State* state = quic_server_info->mutable_state();
   EXPECT_TRUE(state->certs.empty());
-  const string server_config_a = "server_config_a";
-  const string source_address_token_a = "source_address_token_a";
-  const string server_config_sig_a = "server_config_sig_a";
-  const string cert_a = "cert_a";
-  const string cert_b = "cert_b";
+  const std::string server_config_a = "server_config_a";
+  const std::string source_address_token_a = "source_address_token_a";
+  const std::string server_config_sig_a = "server_config_sig_a";
+  const std::string cert_a = "cert_a";
+  const std::string cert_b = "cert_b";
 
   state->server_config = server_config_a;
   state->source_address_token = source_address_token_a;
   state->server_config_sig = server_config_sig_a;
   state->certs.push_back(cert_a);
   quic_server_info->Persist();
 
   // Wait until Persist() does the work.
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 42 matching lines @@
   // Persist data for port 443.
   QuicServerId server_id1("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info1(
       new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache()));
   quic_server_info1->Start();
   int rv = quic_server_info1->WaitForDataReady(callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
 
   QuicServerInfo::State* state1 = quic_server_info1->mutable_state();
   EXPECT_TRUE(state1->certs.empty());
-  const string server_config_a = "server_config_a";
-  const string source_address_token_a = "source_address_token_a";
-  const string server_config_sig_a = "server_config_sig_a";
-  const string cert_a = "cert_a";
+  const std::string server_config_a = "server_config_a";
+  const std::string source_address_token_a = "source_address_token_a";
+  const std::string server_config_sig_a = "server_config_sig_a";
+  const std::string cert_a = "cert_a";
 
   state1->server_config = server_config_a;
   state1->source_address_token = source_address_token_a;
   state1->server_config_sig = server_config_sig_a;
   state1->certs.push_back(cert_a);
   quic_server_info1->Persist();
 
   // Wait until Persist() does the work.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Persist data for port 80.
   QuicServerId server_id2("www.google.com", 80, false, PRIVACY_MODE_DISABLED);
   scoped_ptr<QuicServerInfo> quic_server_info2(
       new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache()));
   quic_server_info2->Start();
   rv = quic_server_info2->WaitForDataReady(callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
 
   QuicServerInfo::State* state2 = quic_server_info2->mutable_state();
   EXPECT_TRUE(state2->certs.empty());
-  const string server_config_b = "server_config_b";
-  const string source_address_token_b = "source_address_token_b";
-  const string server_config_sig_b = "server_config_sig_b";
-  const string cert_b = "cert_b";
+  const std::string server_config_b = "server_config_b";
+  const std::string source_address_token_b = "source_address_token_b";
+  const std::string server_config_sig_b = "server_config_sig_b";
+  const std::string cert_b = "cert_b";
 
   state2->server_config = server_config_b;
   state2->source_address_token = source_address_token_b;
   state2->server_config_sig = server_config_sig_b;
   state2->certs.push_back(cert_b);
   quic_server_info2->Persist();
 
   // Wait until Persist() does the work.
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 41 matching lines @@
   scoped_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
   EXPECT_TRUE(quic_server_info->IsDataReady());
 
   QuicServerInfo::State* state = quic_server_info->mutable_state();
   EXPECT_TRUE(state->certs.empty());
-  const string server_config_a = "server_config_a";
-  const string source_address_token_a = "source_address_token_a";
-  const string server_config_sig_a = "server_config_sig_a";
-  const string cert_a = "cert_a";
+  const std::string server_config_a = "server_config_a";
+  const std::string source_address_token_a = "source_address_token_a";
+  const std::string server_config_sig_a = "server_config_sig_a";
+  const std::string cert_a = "cert_a";
 
   state->server_config = server_config_a;
   state->source_address_token = source_address_token_a;
   state->server_config_sig = server_config_sig_a;
   state->certs.push_back(cert_a);
   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
 
   // Once we call Persist, IsReadyToPersist should return false until Persist
   // has completed.
@@ skipping 33 matching lines @@
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
   EXPECT_TRUE(quic_server_info->IsDataReady());
 
   // Persist data once.
   QuicServerInfo::State* state = quic_server_info->mutable_state();
   EXPECT_TRUE(state->certs.empty());
-  const string server_config_init = "server_config_init";
-  const string source_address_token_init = "source_address_token_init";
-  const string server_config_sig_init = "server_config_sig_init";
-  const string cert_init = "cert_init";
+  const std::string server_config_init = "server_config_init";
+  const std::string source_address_token_init = "source_address_token_init";
+  const std::string server_config_sig_init = "server_config_sig_init";
+  const std::string cert_init = "cert_init";
 
   state->server_config = server_config_init;
   state->source_address_token = source_address_token_init;
   state->server_config_sig = server_config_sig_init;
   state->certs.push_back(cert_init);
   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
 
   // Once we call Persist, IsReadyToPersist should return false until Persist
   // has completed.
   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 
   // Wait until Persist() does the work.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 
   // Persist one more time using the same |quic_server_info| object and without
   // doing another Start() and WaitForDataReady.
-  const string server_config_a = "server_config_a";
-  const string source_address_token_a = "source_address_token_a";
-  const string server_config_sig_a = "server_config_sig_a";
-  const string cert_a = "cert_a";
+  const std::string server_config_a = "server_config_a";
+  const std::string source_address_token_a = "source_address_token_a";
+  const std::string server_config_sig_a = "server_config_sig_a";
+  const std::string cert_a = "cert_a";
 
   state->server_config = server_config_a;
   state->source_address_token = source_address_token_a;
   state->server_config_sig = server_config_sig_a;
   state->certs.push_back(cert_a);
   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
 
   // Once we call Persist, IsReadyToPersist should return false until Persist
   // has completed.
@@ skipping 68 matching lines @@
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   // Wait until Start() does the work.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_TRUE(quic_server_info->IsDataReady());
 
   QuicServerInfo::State* state = quic_server_info->mutable_state();
   EXPECT_TRUE(state->certs.empty());
-  const string server_config_a = "server_config_a";
-  const string source_address_token_a = "source_address_token_a";
-  const string server_config_sig_a = "server_config_sig_a";
-  const string cert_a = "cert_a";
+  const std::string server_config_a = "server_config_a";
+  const std::string source_address_token_a = "source_address_token_a";
+  const std::string server_config_sig_a = "server_config_sig_a";
+  const std::string cert_a = "cert_a";
 
   state->server_config = server_config_a;
   state->source_address_token = source_address_token_a;
   state->server_config_sig = server_config_sig_a;
   state->certs.push_back(cert_a);
   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
   quic_server_info->OnExternalCacheHit();
 
   // Once we call Persist, IsReadyToPersist should return false until Persist
@@ skipping 37 matching lines @@
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   // We do a Start(), but don't call WaitForDataReady(). Because we haven't
   // created the backend, we will wait and data wouldn't be ready.
   quic_server_info->Start();
   EXPECT_FALSE(quic_server_info->IsDataReady());
 
   // Persist data once, even though the backend is not ready.
   QuicServerInfo::State* state = quic_server_info->mutable_state();
   EXPECT_TRUE(state->certs.empty());
-  const string server_config_init = "server_config_init";
-  const string source_address_token_init = "source_address_token_init";
-  const string server_config_sig_init = "server_config_sig_init";
-  const string cert_init = "cert_init";
+  const std::string server_config_init = "server_config_init";
+  const std::string source_address_token_init = "source_address_token_init";
+  const std::string server_config_sig_init = "server_config_sig_init";
+  const std::string cert_init = "cert_init";
 
   state->server_config = server_config_init;
   state->source_address_token = source_address_token_init;
   state->server_config_sig = server_config_sig_init;
   state->certs.push_back(cert_init);
   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 
   // Now complete the backend creation and let the callback run.
@@ skipping 31 matching lines @@
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
   EXPECT_TRUE(quic_server_info->IsDataReady());
 
   // Persist data once.
   QuicServerInfo::State* state = quic_server_info->mutable_state();
   EXPECT_TRUE(state->certs.empty());
-  const string server_config_init = "server_config_init";
-  const string source_address_token_init = "source_address_token_init";
-  const string server_config_sig_init = "server_config_sig_init";
-  const string cert_init = "cert_init";
+  const std::string server_config_init = "server_config_init";
+  const std::string source_address_token_init = "source_address_token_init";
+  const std::string server_config_sig_init = "server_config_sig_init";
+  const std::string cert_init = "cert_init";
 
   state->server_config = server_config_init;
   state->source_address_token = source_address_token_init;
   state->server_config_sig = server_config_sig_init;
   state->certs.push_back(cert_init);
   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
 
   // Once we call Persist, IsReadyToPersist should return false until Persist
   // has completed.
   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 
   // Persist one more time using the same |quic_server_info| object and without
   // doing another Start() and WaitForDataReady.
-  const string server_config_a = "server_config_a";
-  const string source_address_token_a = "source_address_token_a";
-  const string server_config_sig_a = "server_config_sig_a";
-  const string cert_a = "cert_a";
+  const std::string server_config_a = "server_config_a";
+  const std::string source_address_token_a = "source_address_token_a";
+  const std::string server_config_sig_a = "server_config_sig_a";
+  const std::string cert_a = "cert_a";
 
   state->server_config = server_config_a;
   state->source_address_token = source_address_token_a;
   state->server_config_sig = server_config_sig_a;
   state->certs.push_back(cert_a);
   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
   quic_server_info->Persist();
 
   // Wait until Persist() does the work.
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 13 matching lines @@
   EXPECT_EQ(server_config_a, state1.server_config);
   EXPECT_EQ(source_address_token_a, state1.source_address_token);
   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
   EXPECT_EQ(1U, state1.certs.size());
   EXPECT_EQ(cert_a, state1.certs[0]);
 
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 }  // namespace net