diff --git a/quic/qbone/platform/ip_range.cc b/quic/qbone/platform/ip_range.cc
index 03ad640..04198d0 100644
--- a/quic/qbone/platform/ip_range.cc
+++ b/quic/qbone/platform/ip_range.cc
@@ -74,9 +74,9 @@
   return !(*this == other);
 }
 
-bool IpRange::FromString(const string& range) {
+bool IpRange::FromString(const std::string& range) {
   size_t slash_pos = range.find('/');
-  if (slash_pos == string::npos) {
+  if (slash_pos == std::string::npos) {
     return false;
   }
   QuicIpAddress prefix;
diff --git a/quic/qbone/platform/ip_range.h b/quic/qbone/platform/ip_range.h
index cc84bb2..c9f1f34 100644
--- a/quic/qbone/platform/ip_range.h
+++ b/quic/qbone/platform/ip_range.h
@@ -24,10 +24,10 @@
 
   // Parses range that looks like "10.0.0.1/8". Tailing bits will be set to zero
   // after prefix_length. Return false if the parsing failed.
-  bool FromString(const string& range);
+  bool FromString(const std::string& range);
 
   // Returns the string representation of this object.
-  string ToString() const {
+  std::string ToString() const {
     if (IsInitialized()) {
       return quiche::QuicheStrCat(prefix_.ToString(), "/", prefix_length_);
     }
diff --git a/quic/qbone/platform/mock_netlink.h b/quic/qbone/platform/mock_netlink.h
index 5c1e7bc..e9f5d68 100644
--- a/quic/qbone/platform/mock_netlink.h
+++ b/quic/qbone/platform/mock_netlink.h
@@ -12,7 +12,7 @@
 
 class MockNetlink : public NetlinkInterface {
  public:
-  MOCK_METHOD2(GetLinkInfo, bool(const string&, LinkInfo*));
+  MOCK_METHOD2(GetLinkInfo, bool(const std::string&, LinkInfo*));
 
   MOCK_METHOD4(GetAddresses,
                bool(int, uint8_t, std::vector<AddressInfo>*, int*));
diff --git a/quic/qbone/platform/netlink.cc b/quic/qbone/platform/netlink.cc
index 307d2bc..719551d 100644
--- a/quic/qbone/platform/netlink.cc
+++ b/quic/qbone/platform/netlink.cc
@@ -75,7 +75,7 @@
 
 class LinkInfoParser : public NetlinkParserInterface {
  public:
-  LinkInfoParser(string interface_name, Netlink::LinkInfo* link_info)
+  LinkInfoParser(std::string interface_name, Netlink::LinkInfo* link_info)
       : interface_name_(std::move(interface_name)), link_info_(link_info) {}
 
   void Run(struct nlmsghdr* netlink_message) override {
@@ -101,7 +101,7 @@
     size_t hardware_address_length = 0;
     char broadcast_address[kHwAddrSize];
     size_t broadcast_address_length = 0;
-    string name;
+    std::string name;
 
     // loop through the attributes
     struct rtattr* rta;
@@ -131,8 +131,8 @@
           break;
         }
         case IFLA_IFNAME: {
-          name =
-              string(reinterpret_cast<char*>(RTA_DATA(rta)), RTA_PAYLOAD(rta));
+          name = std::string(reinterpret_cast<char*>(RTA_DATA(rta)),
+                             RTA_PAYLOAD(rta));
           // The name maybe a 0 terminated c string.
           name = name.substr(0, name.find('\0'));
           break;
@@ -163,14 +163,15 @@
   bool found_link() { return found_link_; }
 
  private:
-  const string interface_name_;
+  const std::string interface_name_;
   Netlink::LinkInfo* const link_info_;
   bool found_link_ = false;
 };
 
 }  // namespace
 
-bool Netlink::GetLinkInfo(const string& interface_name, LinkInfo* link_info) {
+bool Netlink::GetLinkInfo(const std::string& interface_name,
+                          LinkInfo* link_info) {
   auto message = LinkMessage::New(RtnetlinkMessage::Operation::GET,
                                   NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST,
                                   seq_, getpid(), nullptr);
diff --git a/quic/qbone/platform/netlink.h b/quic/qbone/platform/netlink.h
index 591da0f..6c85658 100644
--- a/quic/qbone/platform/netlink.h
+++ b/quic/qbone/platform/netlink.h
@@ -38,7 +38,8 @@
   //
   // This is a synchronous communication. That should not be a problem since the
   // kernel should answer immediately.
-  bool GetLinkInfo(const string& interface_name, LinkInfo* link_info) override;
+  bool GetLinkInfo(const std::string& interface_name,
+                   LinkInfo* link_info) override;
 
   // Gets the addresses for the given interface referred by the given
   // interface_index.
diff --git a/quic/qbone/platform/netlink_interface.h b/quic/qbone/platform/netlink_interface.h
index 447c8b2..1b1ba11 100644
--- a/quic/qbone/platform/netlink_interface.h
+++ b/quic/qbone/platform/netlink_interface.h
@@ -36,7 +36,7 @@
 
   // Gets the link information for the interface referred by the given
   // interface_name.
-  virtual bool GetLinkInfo(const string& interface_name,
+  virtual bool GetLinkInfo(const std::string& interface_name,
                            LinkInfo* link_info) = 0;
 
   // Address information reported back from GetAddresses.
diff --git a/quic/qbone/platform/netlink_test.cc b/quic/qbone/platform/netlink_test.cc
index d6a4adf..f8d0f19 100644
--- a/quic/qbone/platform/netlink_test.cc
+++ b/quic/qbone/platform/netlink_test.cc
@@ -57,10 +57,11 @@
           EXPECT_GE(msg->msg_iovlen, 1);
           EXPECT_GE(msg->msg_iov[0].iov_len, sizeof(struct nlmsghdr));
 
-          string buf;
+          std::string buf;
           for (int i = 0; i < msg->msg_iovlen; i++) {
-            buf.append(string(reinterpret_cast<char*>(msg->msg_iov[i].iov_base),
-                              msg->msg_iov[i].iov_len));
+            buf.append(
+                std::string(reinterpret_cast<char*>(msg->msg_iov[i].iov_base),
+                            msg->msg_iov[i].iov_len));
           }
 
           auto* netlink_message =
@@ -130,7 +131,7 @@
 }
 
 void CreateIfinfomsg(struct nlmsghdr* netlink_message,
-                     const string& interface_name,
+                     const std::string& interface_name,
                      uint16_t type,
                      int index,
                      unsigned int flags,
diff --git a/quic/qbone/platform/rtnetlink_message_test.cc b/quic/qbone/platform/rtnetlink_message_test.cc
index b129237..64931c7 100644
--- a/quic/qbone/platform/rtnetlink_message_test.cc
+++ b/quic/qbone/platform/rtnetlink_message_test.cc
@@ -48,7 +48,7 @@
   auto message = LinkMessage::New(RtnetlinkMessage::Operation::NEW, flags, seq,
                                   pid, &interface_info_header);
 
-  string device_name = "device0";
+  std::string device_name = "device0";
   message.AppendAttribute(IFLA_IFNAME, device_name.c_str(), device_name.size());
 
   // One rtattr appended.
@@ -81,8 +81,9 @@
   auto* rta = reinterpret_cast<struct rtattr*>(iov[1].iov_base);
   EXPECT_EQ(IFLA_IFNAME, rta->rta_type);
   EXPECT_EQ(RTA_LENGTH(device_name.size()), rta->rta_len);
-  EXPECT_THAT(device_name, StrEq(string(reinterpret_cast<char*>(RTA_DATA(rta)),
-                                        RTA_PAYLOAD(rta))));
+  EXPECT_THAT(device_name,
+              StrEq(std::string(reinterpret_cast<char*>(RTA_DATA(rta)),
+                                RTA_PAYLOAD(rta))));
 }
 
 TEST(RtnetlinkMessageTest, AddressMessageCanBeCreatedForGetOperation) {
@@ -158,9 +159,9 @@
   auto* rta = reinterpret_cast<struct rtattr*>(iov[1].iov_base);
   EXPECT_EQ(IFA_ADDRESS, rta->rta_type);
   EXPECT_EQ(RTA_LENGTH(ip.ToPackedString().size()), rta->rta_len);
-  EXPECT_THAT(
-      ip.ToPackedString(),
-      StrEq(string(reinterpret_cast<char*>(RTA_DATA(rta)), RTA_PAYLOAD(rta))));
+  EXPECT_THAT(ip.ToPackedString(),
+              StrEq(std::string(reinterpret_cast<char*>(RTA_DATA(rta)),
+                                RTA_PAYLOAD(rta))));
 }
 
 TEST(RtnetlinkMessageTest, RouteMessageCanBeCreatedFromNewOperation) {
@@ -219,9 +220,9 @@
   auto* rta = reinterpret_cast<struct rtattr*>(iov[1].iov_base);
   EXPECT_EQ(RTA_PREFSRC, rta->rta_type);
   EXPECT_EQ(RTA_LENGTH(preferred_source.ToPackedString().size()), rta->rta_len);
-  EXPECT_THAT(
-      preferred_source.ToPackedString(),
-      StrEq(string(reinterpret_cast<char*>(RTA_DATA(rta)), RTA_PAYLOAD(rta))));
+  EXPECT_THAT(preferred_source.ToPackedString(),
+              StrEq(std::string(reinterpret_cast<char*>(RTA_DATA(rta)),
+                                RTA_PAYLOAD(rta))));
 }
 
 }  // namespace
diff --git a/quic/qbone/qbone_client_test.cc b/quic/qbone/qbone_client_test.cc
index e6cbd02..bdc86e7 100644
--- a/quic/qbone/qbone_client_test.cc
+++ b/quic/qbone/qbone_client_test.cc
@@ -32,11 +32,11 @@
 namespace test {
 namespace {
 
-string TestPacketIn(const string& body) {
+std::string TestPacketIn(const std::string& body) {
   return PrependIPv6HeaderForTest(body, 5);
 }
 
-string TestPacketOut(const string& body) {
+std::string TestPacketOut(const std::string& body) {
   return PrependIPv6HeaderForTest(body, 4);
 }
 
@@ -44,17 +44,17 @@
  public:
   void WritePacketToNetwork(const char* packet, size_t size) override {
     QuicWriterMutexLock lock(&mu_);
-    data_.push_back(string(packet, size));
+    data_.push_back(std::string(packet, size));
   }
 
-  std::vector<string> data() {
+  std::vector<std::string> data() {
     QuicWriterMutexLock lock(&mu_);
     return data_;
   }
 
  private:
   QuicMutex mu_;
-  std::vector<string> data_;
+  std::vector<std::string> data_;
 };
 
 // A subclass of a qbone session that will own the connection passed in.
@@ -153,7 +153,7 @@
         &writer_);
   }
 
-  std::vector<string> data() { return writer_.data(); }
+  std::vector<std::string> data() { return writer_.data(); }
 
   void WaitForDataSize(int n) {
     while (data().size() != n) {
@@ -184,7 +184,7 @@
 
   ~QboneTestClient() override {}
 
-  void SendData(const string& data) {
+  void SendData(const std::string& data) {
     qbone_session()->ProcessPacketFromNetwork(data);
   }
 
@@ -200,7 +200,7 @@
     }
   }
 
-  std::vector<string> data() { return qbone_writer_.data(); }
+  std::vector<std::string> data() { return qbone_writer_.data(); }
 
  private:
   DataSavingQbonePacketWriter qbone_writer_;
@@ -234,8 +234,8 @@
                                            ->session_map()
                                            .begin()
                                            ->second.get());
-  string long_data(QboneConstants::kMaxQbonePacketBytes - sizeof(ip6_hdr) - 1,
-                   'A');
+  std::string long_data(
+      QboneConstants::kMaxQbonePacketBytes - sizeof(ip6_hdr) - 1, 'A');
   // Pretend the server gets data.
   server_thread.Schedule([&server_session, &long_data]() {
     server_session->ProcessPacketFromNetwork(
diff --git a/quic/qbone/qbone_control_stream.cc b/quic/qbone/qbone_control_stream.cc
index 225d02f..31a5070 100644
--- a/quic/qbone/qbone_control_stream.cc
+++ b/quic/qbone/qbone_control_stream.cc
@@ -38,7 +38,7 @@
     if (buffer_.size() < pending_message_size_) {
       return;
     }
-    string tmp = buffer_.substr(0, pending_message_size_);
+    std::string tmp = buffer_.substr(0, pending_message_size_);
     buffer_.erase(0, pending_message_size_);
     pending_message_size_ = 0;
     OnMessage(tmp);
@@ -46,7 +46,7 @@
 }
 
 bool QboneControlStreamBase::SendMessage(const proto2::Message& proto) {
-  string tmp;
+  std::string tmp;
   if (!proto.SerializeToString(&tmp)) {
     QUIC_BUG << "Failed to serialize QboneControlRequest";
     return false;
diff --git a/quic/qbone/qbone_control_stream.h b/quic/qbone/qbone_control_stream.h
index 85f8dee..0f4127b 100644
--- a/quic/qbone/qbone_control_stream.h
+++ b/quic/qbone/qbone_control_stream.h
@@ -20,12 +20,12 @@
   void OnDataAvailable() override;
 
  protected:
-  virtual void OnMessage(const string& data) = 0;
+  virtual void OnMessage(const std::string& data) = 0;
   bool SendMessage(const proto2::Message& proto);
 
  private:
   uint16_t pending_message_size_;
-  string buffer_;
+  std::string buffer_;
 };
 
 template <class T>
@@ -48,7 +48,7 @@
   bool SendRequest(const Outgoing& request) { return SendMessage(request); }
 
  protected:
-  void OnMessage(const string& data) override {
+  void OnMessage(const std::string& data) override {
     Incoming request;
     if (!request.ParseFromString(data)) {
       QUIC_LOG(ERROR) << "Failed to parse incoming request";
diff --git a/quic/qbone/qbone_packet_exchanger.cc b/quic/qbone/qbone_packet_exchanger.cc
index d06376d..ded41a2 100644
--- a/quic/qbone/qbone_packet_exchanger.cc
+++ b/quic/qbone/qbone_packet_exchanger.cc
@@ -11,7 +11,7 @@
 bool QbonePacketExchanger::ReadAndDeliverPacket(
     QboneClientInterface* qbone_client) {
   bool blocked = false;
-  string error;
+  std::string error;
   std::unique_ptr<QuicData> packet = ReadPacket(&blocked, &error);
   if (packet == nullptr) {
     if (!blocked) {
@@ -26,7 +26,7 @@
 void QbonePacketExchanger::WritePacketToNetwork(const char* packet,
                                                 size_t size) {
   bool blocked = false;
-  string error;
+  std::string error;
   if (packet_queue_.empty() && !write_blocked_) {
     if (WritePacket(packet, size, &blocked, &error)) {
       return;
@@ -53,7 +53,7 @@
   write_blocked_ = false;
   while (!packet_queue_.empty()) {
     bool blocked = false;
-    string error;
+    std::string error;
     if (WritePacket(packet_queue_.front()->data(),
                     packet_queue_.front()->length(), &blocked, &error)) {
       packet_queue_.pop_front();
diff --git a/quic/qbone/qbone_packet_exchanger.h b/quic/qbone/qbone_packet_exchanger.h
index 8620a49..afdfc2e 100644
--- a/quic/qbone/qbone_packet_exchanger.h
+++ b/quic/qbone/qbone_packet_exchanger.h
@@ -19,8 +19,8 @@
   class Visitor {
    public:
     virtual ~Visitor() {}
-    virtual void OnReadError(const string& error) {}
-    virtual void OnWriteError(const string& error) {}
+    virtual void OnReadError(const std::string& error) {}
+    virtual void OnWriteError(const std::string& error) {}
   };
   // Does not take ownership of visitor.
   QbonePacketExchanger(Visitor* visitor, size_t max_pending_packets)
@@ -53,7 +53,7 @@
   // there is no packet to read, b) the read failed. In the former case, blocked
   // is set to true. error contains the error message.
   virtual std::unique_ptr<QuicData> ReadPacket(bool* blocked,
-                                               string* error) = 0;
+                                               std::string* error) = 0;
 
   // The actual implementation that writes a packet to the local network.
   // Returns true if the write succeeds. blocked will be set to true if the
@@ -62,7 +62,7 @@
   virtual bool WritePacket(const char* packet,
                            size_t size,
                            bool* blocked,
-                           string* error) = 0;
+                           std::string* error) = 0;
 
   std::list<std::unique_ptr<QuicData>> packet_queue_;
 
diff --git a/quic/qbone/qbone_packet_exchanger_test.cc b/quic/qbone/qbone_packet_exchanger_test.cc
index f572177..1f38910 100644
--- a/quic/qbone/qbone_packet_exchanger_test.cc
+++ b/quic/qbone/qbone_packet_exchanger_test.cc
@@ -19,8 +19,8 @@
 
 class MockVisitor : public QbonePacketExchanger::Visitor {
  public:
-  MOCK_METHOD1(OnReadError, void(const string&));
-  MOCK_METHOD1(OnWriteError, void(const string&));
+  MOCK_METHOD1(OnReadError, void(const std::string&));
+  MOCK_METHOD1(OnWriteError, void(const std::string&));
 };
 
 class FakeQbonePacketExchanger : public QbonePacketExchanger {
@@ -37,23 +37,24 @@
 
   // Sets the error to be returned by ReadPacket when the list of packets is
   // empty. If error is empty string, blocked is set by ReadPacket.
-  void SetReadError(const string& error) { read_error_ = error; }
+  void SetReadError(const std::string& error) { read_error_ = error; }
 
   // Force WritePacket to fail with the given status. WritePacket returns true
   // when blocked == true and error is empty.
-  void ForceWriteFailure(bool blocked, const string& error) {
+  void ForceWriteFailure(bool blocked, const std::string& error) {
     write_blocked_ = blocked;
     write_error_ = error;
   }
 
   // Packets that have been successfully written by WritePacket.
-  const std::vector<string>& packets_written() const {
+  const std::vector<std::string>& packets_written() const {
     return packets_written_;
   }
 
  private:
   // Implements QbonePacketExchanger::ReadPacket.
-  std::unique_ptr<QuicData> ReadPacket(bool* blocked, string* error) override {
+  std::unique_ptr<QuicData> ReadPacket(bool* blocked,
+                                       std::string* error) override {
     *blocked = false;
 
     if (packets_to_be_read_.empty()) {
@@ -71,7 +72,7 @@
   bool WritePacket(const char* packet,
                    size_t size,
                    bool* blocked,
-                   string* error) override {
+                   std::string* error) override {
     *blocked = false;
 
     if (write_blocked_ || !write_error_.empty()) {
@@ -80,16 +81,16 @@
       return false;
     }
 
-    packets_written_.push_back(string(packet, size));
+    packets_written_.push_back(std::string(packet, size));
     return true;
   }
 
-  string read_error_;
+  std::string read_error_;
   std::list<std::unique_ptr<QuicData>> packets_to_be_read_;
 
-  string write_error_;
+  std::string write_error_;
   bool write_blocked_ = false;
-  std::vector<string> packets_written_;
+  std::vector<std::string> packets_written_;
 };
 
 TEST(QbonePacketExchangerTest,
@@ -98,7 +99,7 @@
   FakeQbonePacketExchanger exchanger(&visitor, kMaxPendingPackets);
   StrictMock<MockQboneClient> client;
 
-  string packet = "data";
+  std::string packet = "data";
   exchanger.AddPacketToBeRead(
       std::make_unique<QuicData>(packet.data(), packet.length()));
   EXPECT_CALL(client, ProcessPacketFromNetwork(StrEq("data")));
@@ -113,7 +114,7 @@
   MockQboneClient client;
 
   // Force read error.
-  string io_error = "I/O error";
+  std::string io_error = "I/O error";
   exchanger.SetReadError(io_error);
   EXPECT_CALL(visitor, OnReadError(StrEq(io_error))).Times(1);
 
@@ -136,7 +137,7 @@
   FakeQbonePacketExchanger exchanger(&visitor, kMaxPendingPackets);
   MockQboneClient client;
 
-  string packet = "data";
+  std::string packet = "data";
   exchanger.WritePacketToNetwork(packet.data(), packet.length());
 
   ASSERT_EQ(exchanger.packets_written().size(), 1);
@@ -151,7 +152,7 @@
 
   // Force write to be blocked so that packets are queued.
   exchanger.ForceWriteFailure(true, "");
-  std::vector<string> packets = {"packet0", "packet1"};
+  std::vector<std::string> packets = {"packet0", "packet1"};
   for (int i = 0; i < packets.size(); i++) {
     exchanger.WritePacketToNetwork(packets[i].data(), packets[i].length());
   }
@@ -178,7 +179,7 @@
 
   // Force write to be blocked so that packets are queued.
   exchanger.ForceWriteFailure(true, "");
-  std::vector<string> packets = {"packet0", "packet1"};
+  std::vector<std::string> packets = {"packet0", "packet1"};
   for (int i = 0; i < packets.size(); i++) {
     exchanger.WritePacketToNetwork(packets[i].data(), packets[i].length());
   }
@@ -202,7 +203,7 @@
 }
 
 TEST(QbonePacketExchangerTest, WritePacketToNetworkDropsPacketIfQueueIfFull) {
-  std::vector<string> packets = {"packet0", "packet1", "packet2"};
+  std::vector<std::string> packets = {"packet0", "packet1", "packet2"};
   size_t queue_size = packets.size() - 1;
   MockVisitor visitor;
   // exchanger has smaller queue than number of packets.
@@ -230,10 +231,10 @@
   MockVisitor visitor;
   FakeQbonePacketExchanger exchanger(&visitor, kMaxPendingPackets);
   MockQboneClient client;
-  string packet = "data";
+  std::string packet = "data";
 
   // Write error is delivered to visitor during WritePacketToNetwork.
-  string io_error = "I/O error";
+  std::string io_error = "I/O error";
   exchanger.ForceWriteFailure(false, io_error);
   EXPECT_CALL(visitor, OnWriteError(StrEq(io_error))).Times(1);
   exchanger.WritePacketToNetwork(packet.data(), packet.length());
@@ -243,7 +244,7 @@
   exchanger.ForceWriteFailure(true, "");
   exchanger.WritePacketToNetwork(packet.data(), packet.length());
 
-  string sys_error = "sys error";
+  std::string sys_error = "sys error";
   exchanger.ForceWriteFailure(false, sys_error);
   EXPECT_CALL(visitor, OnWriteError(StrEq(sys_error))).Times(1);
   exchanger.SetWritable();
diff --git a/quic/qbone/qbone_packet_processor.cc b/quic/qbone/qbone_packet_processor.cc
index 9475e27..ef78efa 100644
--- a/quic/qbone/qbone_packet_processor.cc
+++ b/quic/qbone/qbone_packet_processor.cc
@@ -60,7 +60,8 @@
   return ProcessingResult::OK;
 }
 
-void QbonePacketProcessor::ProcessPacket(string* packet, Direction direction) {
+void QbonePacketProcessor::ProcessPacket(std::string* packet,
+                                         Direction direction) {
   if (QUIC_PREDICT_FALSE(!IsValid())) {
     QUIC_BUG << "QuicPacketProcessor is invoked in an invalid state.";
     stats_->OnPacketDroppedSilently(direction);
@@ -106,7 +107,7 @@
 }
 
 QbonePacketProcessor::ProcessingResult
-QbonePacketProcessor::ProcessIPv6HeaderAndFilter(string* packet,
+QbonePacketProcessor::ProcessIPv6HeaderAndFilter(std::string* packet,
                                                  Direction direction,
                                                  uint8_t* transport_protocol,
                                                  char** transport_data,
@@ -154,7 +155,7 @@
 }
 
 QbonePacketProcessor::ProcessingResult QbonePacketProcessor::ProcessIPv6Header(
-    string* packet,
+    std::string* packet,
     Direction direction,
     uint8_t* transport_protocol,
     char** transport_data,
diff --git a/quic/qbone/qbone_packet_processor.h b/quic/qbone/qbone_packet_processor.h
index e163566..130770d 100644
--- a/quic/qbone/qbone_packet_processor.h
+++ b/quic/qbone/qbone_packet_processor.h
@@ -143,7 +143,7 @@
   // Accepts an IPv6 packet and handles it accordingly by either forwarding it,
   // replying with an ICMP packet or silently dropping it.  |packet| will be
   // modified in the process, by having the TTL field decreased.
-  void ProcessPacket(string* packet, Direction direction);
+  void ProcessPacket(std::string* packet, Direction direction);
 
   void set_filter(std::unique_ptr<Filter> filter) {
     filter_ = std::move(filter);
@@ -160,7 +160,7 @@
   // Processes the header and returns what should be done with the packet.
   // After that, calls an external packet filter if registered.  TTL of the
   // packet may be decreased in the process.
-  ProcessingResult ProcessIPv6HeaderAndFilter(string* packet,
+  ProcessingResult ProcessIPv6HeaderAndFilter(std::string* packet,
                                               Direction direction,
                                               uint8_t* transport_protocol,
                                               char** transport_data,
@@ -188,7 +188,7 @@
  private:
   // Performs basic sanity and permission checks on the packet, and decreases
   // the TTL.
-  ProcessingResult ProcessIPv6Header(string* packet,
+  ProcessingResult ProcessIPv6Header(std::string* packet,
                                      Direction direction,
                                      uint8_t* transport_protocol,
                                      char** transport_data,
diff --git a/quic/qbone/qbone_packet_processor_test.cc b/quic/qbone/qbone_packet_processor_test.cc
index 8258917..77fb5d5 100644
--- a/quic/qbone/qbone_packet_processor_test.cc
+++ b/quic/qbone/qbone_packet_processor_test.cc
@@ -146,12 +146,12 @@
   }
 
   void SendPacketFromClient(quiche::QuicheStringPiece packet) {
-    string packet_buffer(packet.data(), packet.size());
+    std::string packet_buffer(packet.data(), packet.size());
     processor_->ProcessPacket(&packet_buffer, Direction::FROM_OFF_NETWORK);
   }
 
   void SendPacketFromNetwork(quiche::QuicheStringPiece packet) {
-    string packet_buffer(packet.data(), packet.size());
+    std::string packet_buffer(packet.data(), packet.size());
     processor_->ProcessPacket(&packet_buffer, Direction::FROM_NETWORK);
   }
 
@@ -174,14 +174,14 @@
 
 TEST_F(QbonePacketProcessorTest, RandomGarbage) {
   EXPECT_CALL(stats_, OnPacketDroppedSilently(Direction::FROM_OFF_NETWORK));
-  SendPacketFromClient(string(1280, 'a'));
+  SendPacketFromClient(std::string(1280, 'a'));
 
   EXPECT_CALL(stats_, OnPacketDroppedSilently(Direction::FROM_NETWORK));
-  SendPacketFromNetwork(string(1280, 'a'));
+  SendPacketFromNetwork(std::string(1280, 'a'));
 }
 
 TEST_F(QbonePacketProcessorTest, RandomGarbageWithCorrectLengthFields) {
-  string packet(40, 'a');
+  std::string packet(40, 'a');
   packet[4] = 0;
   packet[5] = 0;
 
@@ -215,7 +215,7 @@
 }
 
 TEST_F(QbonePacketProcessorTest, TtlExpired) {
-  string packet(kReferenceNetworkPacket);
+  std::string packet(kReferenceNetworkPacket);
   packet[7] = 1;
 
   EXPECT_CALL(stats_, OnPacketDroppedWithIcmp(Direction::FROM_NETWORK));
@@ -224,7 +224,7 @@
 }
 
 TEST_F(QbonePacketProcessorTest, UnknownProtocol) {
-  string packet(kReferenceNetworkPacket);
+  std::string packet(kReferenceNetworkPacket);
   packet[6] = IPPROTO_SCTP;
 
   EXPECT_CALL(stats_, OnPacketDroppedWithIcmp(Direction::FROM_NETWORK));
diff --git a/quic/qbone/qbone_packet_processor_test_tools.cc b/quic/qbone/qbone_packet_processor_test_tools.cc
index 9f9b623..97655e0 100644
--- a/quic/qbone/qbone_packet_processor_test_tools.cc
+++ b/quic/qbone/qbone_packet_processor_test_tools.cc
@@ -8,7 +8,7 @@
 
 namespace quic {
 
-string PrependIPv6HeaderForTest(const string& body, int hops) {
+std::string PrependIPv6HeaderForTest(const std::string& body, int hops) {
   ip6_hdr header;
   memset(&header, 0, sizeof(header));
 
@@ -19,7 +19,7 @@
   header.ip6_src = in6addr_loopback;
   header.ip6_dst = in6addr_loopback;
 
-  string packet(sizeof(header) + body.size(), '\0');
+  std::string packet(sizeof(header) + body.size(), '\0');
   memcpy(&packet[0], &header, sizeof(header));
   memcpy(&packet[sizeof(header)], body.data(), body.size());
   return packet;
diff --git a/quic/qbone/qbone_packet_processor_test_tools.h b/quic/qbone/qbone_packet_processor_test_tools.h
index 78dd92d..809b542 100644
--- a/quic/qbone/qbone_packet_processor_test_tools.h
+++ b/quic/qbone/qbone_packet_processor_test_tools.h
@@ -31,7 +31,7 @@
   MOCK_METHOD1(OnPacketDeferred, void(QbonePacketProcessor::Direction));
 };
 
-string PrependIPv6HeaderForTest(const string& body, int hops);
+std::string PrependIPv6HeaderForTest(const std::string& body, int hops);
 
 }  // namespace quic
 
diff --git a/quic/qbone/qbone_server_session.cc b/quic/qbone/qbone_server_session.cc
index 53511ad..6561f57 100644
--- a/quic/qbone/qbone_server_session.cc
+++ b/quic/qbone/qbone_server_session.cc
@@ -19,7 +19,7 @@
     const QuicSocketAddress& client_address,
     const QuicSocketAddress& peer_address,
     const QuicSocketAddress& self_address,
-    string* error_details) const {
+    std::string* error_details) const {
   quiche::QuicheStringPiece alpn;
   chlo.GetStringPiece(quic::kALPN, &alpn);
   if (alpn != QboneConstants::kQboneAlpn) {
@@ -74,14 +74,14 @@
 
 void QboneServerSession::ProcessPacketFromNetwork(
     quiche::QuicheStringPiece packet) {
-  string buffer = string(packet);
+  std::string buffer = std::string(packet);
   processor_.ProcessPacket(&buffer,
                            QbonePacketProcessor::Direction::FROM_NETWORK);
 }
 
 void QboneServerSession::ProcessPacketFromPeer(
     quiche::QuicheStringPiece packet) {
-  string buffer = string(packet);
+  std::string buffer = std::string(packet);
   processor_.ProcessPacket(&buffer,
                            QbonePacketProcessor::Direction::FROM_OFF_NETWORK);
 }
diff --git a/quic/qbone/qbone_server_session.h b/quic/qbone/qbone_server_session.h
index d6ef596..e4ff4dd 100644
--- a/quic/qbone/qbone_server_session.h
+++ b/quic/qbone/qbone_server_session.h
@@ -26,7 +26,7 @@
                             const QuicSocketAddress& client_address,
                             const QuicSocketAddress& peer_address,
                             const QuicSocketAddress& self_address,
-                            string* error_details) const override;
+                            std::string* error_details) const override;
 };
 
 class QUIC_EXPORT_PRIVATE QboneServerSession
diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index 05a0d72..1c85c0b 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -36,11 +36,11 @@
 using ::testing::NiceMock;
 using ::testing::Not;
 
-string TestPacketIn(const string& body) {
+std::string TestPacketIn(const std::string& body) {
   return PrependIPv6HeaderForTest(body, 5);
 }
 
-string TestPacketOut(const string& body) {
+std::string TestPacketOut(const std::string& body) {
   return PrependIPv6HeaderForTest(body, 4);
 }
 
@@ -52,8 +52,8 @@
 
   // ProofSource override.
   void GetProof(const QuicSocketAddress& server_address,
-                const string& hostname,
-                const string& server_config,
+                const std::string& hostname,
+                const std::string& server_config,
                 QuicTransportVersion transport_version,
                 quiche::QuicheStringPiece chlo_hash,
                 std::unique_ptr<Callback> callback) override {
@@ -69,11 +69,11 @@
 
   QuicReferenceCountedPointer<Chain> GetCertChain(
       const QuicSocketAddress& server_address,
-      const string& hostname) override {
+      const std::string& hostname) override {
     if (!success_) {
       return QuicReferenceCountedPointer<Chain>();
     }
-    std::vector<string> certs;
+    std::vector<std::string> certs;
     certs.push_back("Required to establish handshake");
     return QuicReferenceCountedPointer<ProofSource::Chain>(
         new ProofSource::Chain(certs));
@@ -81,7 +81,7 @@
 
   void ComputeTlsSignature(
       const QuicSocketAddress& server_address,
-      const string& hostname,
+      const std::string& hostname,
       uint16_t signature_algorithm,
       quiche::QuicheStringPiece in,
       std::unique_ptr<SignatureCallback> callback) override {
@@ -101,28 +101,28 @@
 
   // ProofVerifier override
   QuicAsyncStatus VerifyProof(
-      const string& hostname,
+      const std::string& hostname,
       const uint16_t port,
-      const string& server_config,
+      const std::string& server_config,
       QuicTransportVersion transport_version,
       quiche::QuicheStringPiece chlo_hash,
-      const std::vector<string>& certs,
-      const string& cert_sct,
-      const string& signature,
+      const std::vector<std::string>& certs,
+      const std::string& cert_sct,
+      const std::string& signature,
       const ProofVerifyContext* context,
-      string* error_details,
+      std::string* error_details,
       std::unique_ptr<ProofVerifyDetails>* verify_details,
       std::unique_ptr<ProofVerifierCallback> callback) override {
     return success_ ? QUIC_SUCCESS : QUIC_FAILURE;
   }
 
   QuicAsyncStatus VerifyCertChain(
-      const string& hostname,
-      const std::vector<string>& certs,
+      const std::string& hostname,
+      const std::vector<std::string>& certs,
       const std::string& ocsp_response,
       const std::string& cert_sct,
       const ProofVerifyContext* context,
-      string* error_details,
+      std::string* error_details,
       std::unique_ptr<ProofVerifyDetails>* details,
       std::unique_ptr<ProofVerifierCallback> callback) override {
     return success_ ? QUIC_SUCCESS : QUIC_FAILURE;
@@ -140,13 +140,13 @@
 class DataSavingQbonePacketWriter : public QbonePacketWriter {
  public:
   void WritePacketToNetwork(const char* packet, size_t size) override {
-    data_.push_back(string(packet, size));
+    data_.push_back(std::string(packet, size));
   }
 
-  const std::vector<string>& data() { return data_; }
+  const std::vector<std::string>& data() { return data_; }
 
  private:
-  std::vector<string> data_;
+  std::vector<std::string> data_;
 };
 
 template <class T>
@@ -355,18 +355,18 @@
     runner_.Run();
   }
 
-  void ExpectICMPTooBigResponse(const std::vector<string>& written_packets,
+  void ExpectICMPTooBigResponse(const std::vector<std::string>& written_packets,
                                 const int mtu,
-                                const string& packet) {
+                                const std::string& packet) {
     auto* header = reinterpret_cast<const ip6_hdr*>(packet.data());
     icmp6_hdr icmp_header{};
     icmp_header.icmp6_type = ICMP6_PACKET_TOO_BIG;
     icmp_header.icmp6_mtu = mtu;
 
-    string expected;
+    std::string expected;
     CreateIcmpPacket(header->ip6_dst, header->ip6_src, icmp_header, packet,
                      [&expected](quiche::QuicheStringPiece icmp_packet) {
-                       expected = string(icmp_packet);
+                       expected = std::string(icmp_packet);
                      });
 
     EXPECT_THAT(written_packets, Contains(expected));
@@ -409,8 +409,8 @@
     // Try to send long payloads that are larger than the QUIC MTU but
     // smaller than the QBONE max size.
     // This should trigger the non-ephemeral stream code path.
-    string long_data(QboneConstants::kMaxQbonePacketBytes - sizeof(ip6_hdr) - 1,
-                     'A');
+    std::string long_data(
+        QboneConstants::kMaxQbonePacketBytes - sizeof(ip6_hdr) - 1, 'A');
     QUIC_LOG(INFO) << "Sending server -> client long data";
     server_peer_->ProcessPacketFromNetwork(TestPacketIn(long_data));
     runner_.Run();
diff --git a/quic/qbone/qbone_stream.h b/quic/qbone/qbone_stream.h
index 6a86e4d..c2fb20a 100644
--- a/quic/qbone/qbone_stream.h
+++ b/quic/qbone/qbone_stream.h
@@ -47,7 +47,7 @@
   void OnDataAvailable() override;
 
  private:
-  string buffer_;
+  std::string buffer_;
   QboneSessionBase* session_;
 };
 
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index dcd80bd..06dbd34 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -180,7 +180,7 @@
 
 // Read an entire string.
 TEST_F(QboneReadOnlyStreamTest, ReadDataWhole) {
-  string packet = "Stuff";
+  std::string packet = "Stuff";
   CreateReliableQuicStream();
   QuicStreamFrame frame(kStreamId, true, 0, packet);
   EXPECT_CALL(*session_, ProcessPacketFromPeer("Stuff"));
@@ -190,7 +190,7 @@
 // Test buffering.
 TEST_F(QboneReadOnlyStreamTest, ReadBuffered) {
   CreateReliableQuicStream();
-  string packet = "Stuf";
+  std::string packet = "Stuf";
   {
     QuicStreamFrame frame(kStreamId, false, 0, packet);
     stream_->OnStreamFrame(frame);
@@ -207,7 +207,7 @@
 
 TEST_F(QboneReadOnlyStreamTest, ReadOutOfOrder) {
   CreateReliableQuicStream();
-  string packet = "f";
+  std::string packet = "f";
   {
     QuicStreamFrame frame(kStreamId, true, 4, packet);
     stream_->OnStreamFrame(frame);
@@ -230,7 +230,7 @@
 // Test buffering too many bytes.
 TEST_F(QboneReadOnlyStreamTest, ReadBufferedTooLarge) {
   CreateReliableQuicStream();
-  string packet = "0123456789";
+  std::string packet = "0123456789";
   int iterations = (QboneConstants::kMaxQbonePacketBytes / packet.size()) + 2;
   EXPECT_CALL(*session_,
               SendRstStream(kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _));