Remove using namespace in net/quic/quic_stream_sequencer.h

net/quic/quic_crypto_client_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_client_stream.h"
 
 #include "base/metrics/histogram.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 31 matching lines @@
 
 QuicCryptoClientStream::ProofVerifierCallbackImpl::ProofVerifierCallbackImpl(
     QuicCryptoClientStream* stream)
     : stream_(stream) {}
 
 QuicCryptoClientStream::ProofVerifierCallbackImpl::
 ~ProofVerifierCallbackImpl() {}
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Run(
     bool ok,
-    const string& error_details,
+    const std::string& error_details,
     scoped_ptr<ProofVerifyDetails>* details) {
   if (stream_ == nullptr) {
     return;
   }
 
   stream_->verify_ok_ = ok;
   stream_->verify_error_details_ = error_details;
   stream_->verify_details_.reset(details->release());
   stream_->proof_verify_callback_ = nullptr;
   stream_->DoHandshakeLoop(nullptr);
@@ skipping 71 matching lines @@
   return channel_id_sent_;
 }
 
 bool QuicCryptoClientStream::WasChannelIDSourceCallbackRun() const {
   return channel_id_source_callback_run_;
 }
 
 void QuicCryptoClientStream::HandleServerConfigUpdateMessage(
     const CryptoHandshakeMessage& server_config_update) {
   DCHECK(server_config_update.tag() == kSCUP);
-  string error_details;
+  std::string error_details;
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_->LookupOrCreate(server_id_);
   QuicErrorCode error = crypto_config_->ProcessServerConfigUpdate(
       server_config_update,
       session()->connection()->clock()->WallNow(),
       cached,
       &crypto_negotiated_params_,
       &error_details);
 
   if (error != QUIC_NO_ERROR) {
@@ skipping 115 matching lines @@
       CloseConnection(QUIC_INTERNAL_ERROR);
       return;
     }
     out.set_minimum_size(max_packet_size - kFramingOverhead);
     next_state_ = STATE_RECV_REJ;
     SendHandshakeMessage(out);
     return;
   }
 
   session()->config()->ToHandshakeMessage(&out);
-  string error_details;
+  std::string error_details;
   QuicErrorCode error = crypto_config_->FillClientHello(
       server_id_,
       session()->connection()->connection_id(),
       session()->connection()->supported_versions().front(),
       cached,
       session()->connection()->clock()->WallNow(),
       session()->connection()->random_generator(),
       channel_id_key_.get(),
       &crypto_negotiated_params_,
       &out,
@@ skipping 40 matching lines @@
   // We sent a dummy CHLO because we didn't have enough information to
   // perform a handshake, or we sent a full hello that the server
   // rejected. Here we hope to have a REJ that contains the information
   // that we need.
   if (in->tag() != kREJ) {
     next_state_ = STATE_NONE;
     CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
                                "Expected REJ");
     return;
   }
-  string error_details;
+  std::string error_details;
   QuicErrorCode error = crypto_config_->ProcessRejection(
       *in, session()->connection()->clock()->WallNow(), cached,
       server_id_.is_https(), &crypto_negotiated_params_, &error_details);
   if (error != QUIC_NO_ERROR) {
     next_state_ = STATE_NONE;
     CloseConnectionWithDetails(error, error_details);
     return;
   }
   if (!cached->proof_valid()) {
     if (!server_id_.is_https()) {
@@ skipping 150 matching lines @@
   // alternative_decrypter will be nullptr if the original alternative
   // decrypter latched and became the primary decrypter. That happens
   // if we received a message encrypted with the INITIAL key.
   if (session()->connection()->alternative_decrypter() != nullptr) {
     // The server hello was sent without encryption.
     CloseConnectionWithDetails(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT,
                                "unencrypted SHLO message");
     return;
   }
 
-  string error_details;
+  std::string error_details;
   QuicErrorCode error = crypto_config_->ProcessServerHello(
       *in, session()->connection()->connection_id(),
       session()->connection()->server_supported_versions(),
       cached, &crypto_negotiated_params_, &error_details);
 
   if (error != QUIC_NO_ERROR) {
     CloseConnectionWithDetails(error, "Server hello invalid: " + error_details);
     return;
   }
   error = session()->config()->ProcessPeerHello(*in, SERVER, &error_details);
@@ skipping 69 matching lines @@
     }
   }
   return false;
 }
 
 QuicClientSessionBase* QuicCryptoClientStream::client_session() {
   return reinterpret_cast<QuicClientSessionBase*>(session());
 }
 
 }  // namespace net