Remove using namespace in net/quic/quic_stream_sequencer.h

net/quic/quic_crypto_server_stream.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/quic_crypto_server_stream.h"
 
 #include "base/base64.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/cached_network_parameters.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 67 matching lines @@
       validate_client_hello_cb_);
 }
 
 void QuicCryptoServerStream::FinishProcessingHandshakeMessage(
     const CryptoHandshakeMessage& message,
     const ValidateClientHelloResultCallback::Result& result) {
   // Clear the callback that got us here.
   DCHECK(validate_client_hello_cb_ != nullptr);
   validate_client_hello_cb_ = nullptr;
 
-  string error_details;
+  std::string error_details;
   CryptoHandshakeMessage reply;
   QuicErrorCode error = ProcessClientHello(
       message, result, &reply, &error_details);
 
   if (error != QUIC_NO_ERROR) {
     CloseConnectionWithDetails(error, error_details);
     return;
   }
 
   if (reply.tag() != kSHLO) {
@@ skipping 69 matching lines @@
           crypto_negotiated_params_,
           cached_network_params,
           &server_config_update_message)) {
     DVLOG(1) << "Server: Failed to build server config update (SCUP)!";
     return;
   }
 
   DVLOG(1) << "Server: Sending server config update: "
            << server_config_update_message.DebugString();
   const QuicData& data = server_config_update_message.GetSerialized();
-  WriteOrBufferData(string(data.data(), data.length()), false, nullptr);
+  WriteOrBufferData(std::string(data.data(), data.length()), false, nullptr);
 
   ++num_server_config_update_messages_sent_;
 }
 
 void QuicCryptoServerStream::OnServerHelloAcked() {
   session()->connection()->OnHandshakeComplete();
 }
 
 void QuicCryptoServerStream::set_previous_cached_network_params(
     CachedNetworkParameters cached_network_params) {
   previous_cached_network_params_.reset(
       new CachedNetworkParameters(cached_network_params));
 }
 
 bool QuicCryptoServerStream::GetBase64SHA256ClientChannelID(
-    string* output) const {
+    std::string* output) const {
   if (!encryption_established_ ||
       crypto_negotiated_params_.channel_id.empty()) {
     return false;
   }
 
-  const string& channel_id(crypto_negotiated_params_.channel_id);
+  const std::string& channel_id(crypto_negotiated_params_.channel_id);
   scoped_ptr<crypto::SecureHash> hash(
       crypto::SecureHash::Create(crypto::SecureHash::SHA256));
   hash->Update(channel_id.data(), channel_id.size());
   uint8 digest[32];
   hash->Finish(digest, sizeof(digest));
 
-  base::Base64Encode(string(
+  base::Base64Encode(std::string(
       reinterpret_cast<const char*>(digest), sizeof(digest)), output);
   // Remove padding.
   size_t len = output->size();
   if (len >= 2) {
     if ((*output)[len - 1] == '=') {
       len--;
       if ((*output)[len - 1] == '=') {
         len--;
       }
       output->resize(len);
     }
   }
   return true;
 }
 
 QuicErrorCode QuicCryptoServerStream::ProcessClientHello(
     const CryptoHandshakeMessage& message,
     const ValidateClientHelloResultCallback::Result& result,
     CryptoHandshakeMessage* reply,
-    string* error_details) {
+    std::string* error_details) {
   // Store the bandwidth estimate from the client.
   if (result.cached_network_params.bandwidth_estimate_bytes_per_second() > 0) {
     previous_cached_network_params_.reset(
         new CachedNetworkParameters(result.cached_network_params));
   }
 
   return crypto_config_.ProcessClientHello(
       result,
       session()->connection()->connection_id(),
       session()->connection()->peer_address(),
@@ skipping 20 matching lines @@
 
 void QuicCryptoServerStream::ValidateCallback::RunImpl(
     const CryptoHandshakeMessage& client_hello,
     const Result& result) {
   if (parent_ != nullptr) {
     parent_->FinishProcessingHandshakeMessage(client_hello, result);
   }
 }
 
 }  // namespace net