Remove using namespace in net/quic/quic_stream_sequencer.h

net/quic/congestion_control/send_algorithm_simulator.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/quic/congestion_control/send_algorithm_simulator.h"
 
 #include <limits>
+#include <string>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/quic/crypto/quic_random.h"
 
 using std::list;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::vector;
@@ skipping 22 matching lines @@
       max_cwnd(0),
       min_cwnd(100000),
       max_cwnd_drop(0),
       last_cwnd(0),
       last_transfer_bandwidth(QuicBandwidth::Zero()),
       last_transfer_loss_rate(0) {}
 
 SendAlgorithmSimulator::Transfer::Transfer(Sender* sender,
                                            QuicByteCount num_bytes,
                                            QuicTime start_time,
-                                           string name)
+                                           std::string name)

[ramant (doing other things), 2014/12/02 04:14:43]

We share net/quic and net/tools/quic code with internal source and merging
becomes harder for every line that has "std::string".

Is it possible to add "using std::string;" and delete all changes that add
"std::"?

We use "using std::string;" construct at other places in chromium codebase.

https://code.google.com/p/chromium/codesearch#search/&q=%22using%20std::strin...

Thanks.

[haltonhuo, 2014/12/02 04:57:07]

Does that make sense that adding "using std::string;" for .cc and add "std::"
for .h?
I guess you agree that "using std" in header is bad behavior, do you want to
change in this CL or separate one?

[ramant (doing other things), 2014/12/03 01:10:09]

We use "std::" in the header files (we don't specify "using ..." in .h files).

     : sender(sender),
       num_bytes(num_bytes),
       bytes_acked(0),
       bytes_lost(0),
       bytes_in_flight(0),
       start_time(start_time),
       name(name) {}
 
 SendAlgorithmSimulator::SendAlgorithmSimulator(
     MockClock* clock,
@@ skipping 14 matching lines @@
 }
 
 SendAlgorithmSimulator::~SendAlgorithmSimulator() {}
 
 void SendAlgorithmSimulator::AddTransfer(Sender* sender, size_t num_bytes) {
   AddTransfer(sender, num_bytes, clock_->Now(),
               StringPrintf("#%zu", pending_transfers_.size()));
 }
 
 void SendAlgorithmSimulator::AddTransfer(
-    Sender* sender, size_t num_bytes, QuicTime start_time, string name) {
+    Sender* sender, size_t num_bytes, QuicTime start_time, std::string name) {
   pending_transfers_.push_back(Transfer(sender, num_bytes, start_time, name));
   // Record initial stats from when the transfer begins.
   pending_transfers_.back().sender->RecordStats();
 }
 
 void SendAlgorithmSimulator::TransferBytes() {
   TransferBytes(kuint64max, QuicTime::Delta::Infinite());
 }
 
 void SendAlgorithmSimulator::TransferBytes(QuicByteCount max_bytes,
@@ skipping 290 matching lines @@
   }
   transfer->bytes_in_flight += kPacketSize;
 }
 
 // Advance the time by |delta| without sending anything.
 void SendAlgorithmSimulator::AdvanceTime(QuicTime::Delta delta) {
   clock_->AdvanceTime(delta);
 }
 
 }  // namespace net