BASELINE: Update Chromium to 69.0.3497.70

Change-Id: I2b7b56e4e7a8b26656930def0d4575dc32b900a0
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

18 files changed, 309 insertions, 258 deletions

diff --git a/chromium/net/tools/quic/crypto_message_printer_bin.cc b/chromium/net/tools/quic/crypto_message_printer_bin.cc
index dfb5db2e83f..b438ee16ad1 100644
--- a/chromium/net/tools/quic/crypto_message_printer_bin.cc
+++ b/chromium/net/tools/quic/crypto_message_printer_bin.cc
@@ -13,7 +13,7 @@
 #include "net/third_party/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quic/platform/api/quic_text_utils.h"
 
-using net::Perspective;
+using quic::Perspective;
 using std::cerr;
 using std::cout;
 using std::endl;
@@ -22,21 +22,22 @@ std::string FLAGS_perspective = "";
 
 namespace net {
 
-class CryptoMessagePrinter : public net::CryptoFramerVisitorInterface {
+class CryptoMessagePrinter : public quic::CryptoFramerVisitorInterface {
  public:
-  explicit CryptoMessagePrinter(Perspective perspective)
+  explicit CryptoMessagePrinter(quic::Perspective perspective)
       : perspective_(perspective) {}
 
-  void OnHandshakeMessage(const CryptoHandshakeMessage& message) override {
+  void OnHandshakeMessage(
+      const quic::CryptoHandshakeMessage& message) override {
     cout << message.DebugString(perspective_) << endl;
   }
 
-  void OnError(CryptoFramer* framer) override {
+  void OnError(quic::CryptoFramer* framer) override {
     cerr << "Error code: " << framer->error() << endl;
     cerr << "Error details: " << framer->error_detail() << endl;
   }
 
-  Perspective perspective_;
+  quic::Perspective perspective_;
 };
 
 }  // namespace net
@@ -61,15 +62,15 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
-  Perspective perspective = FLAGS_perspective == "server"
-                                ? Perspective::IS_SERVER
-                                : Perspective::IS_CLIENT;
+  quic::Perspective perspective = FLAGS_perspective == "server"
+                                      ? quic::Perspective::IS_SERVER
+                                      : quic::Perspective::IS_CLIENT;
 
   net::CryptoMessagePrinter printer(perspective);
-  net::CryptoFramer framer;
+  quic::CryptoFramer framer;
   framer.set_visitor(&printer);
   framer.set_process_truncated_messages(true);
-  std::string input = net::QuicTextUtils::HexDecode(argv[1]);
+  std::string input = quic::QuicTextUtils::HexDecode(argv[1]);
   if (!framer.ProcessInput(input, perspective)) {
     return 1;
   }
diff --git a/chromium/net/tools/quic/quic_client_message_loop_network_helper.cc b/chromium/net/tools/quic/quic_client_message_loop_network_helper.cc
index 0075af6293a..c6154dea784 100644
--- a/chromium/net/tools/quic/quic_client_message_loop_network_helper.cc
+++ b/chromium/net/tools/quic/quic_client_message_loop_network_helper.cc
@@ -34,26 +34,30 @@ using std::string;
 namespace net {
 
 QuicClientMessageLooplNetworkHelper::QuicClientMessageLooplNetworkHelper(
-    QuicChromiumClock* clock,
-    QuicClientBase* client)
+    quic::QuicChromiumClock* clock,
+    quic::QuicClientBase* client)
     : packet_reader_started_(false), clock_(clock), client_(client) {}
 
 QuicClientMessageLooplNetworkHelper::~QuicClientMessageLooplNetworkHelper() =
     default;
 
 bool QuicClientMessageLooplNetworkHelper::CreateUDPSocketAndBind(
-    QuicSocketAddress server_address,
-    QuicIpAddress bind_to_address,
+    quic::QuicSocketAddress server_address,
+    quic::QuicIpAddress bind_to_address,
     int bind_to_port) {
   auto socket = std::make_unique<UDPClientSocket>(DatagramSocket::DEFAULT_BIND,
                                                   &net_log_, NetLogSource());
 
   if (bind_to_address.IsInitialized()) {
-    client_address_ = QuicSocketAddress(bind_to_address, client_->local_port());
-  } else if (server_address.host().address_family() == IpAddressFamily::IP_V4) {
-    client_address_ = QuicSocketAddress(QuicIpAddress::Any4(), bind_to_port);
+    client_address_ =
+        quic::QuicSocketAddress(bind_to_address, client_->local_port());
+  } else if (server_address.host().address_family() ==
+             quic::IpAddressFamily::IP_V4) {
+    client_address_ =
+        quic::QuicSocketAddress(quic::QuicIpAddress::Any4(), bind_to_port);
   } else {
-    client_address_ = QuicSocketAddress(QuicIpAddress::Any6(), bind_to_port);
+    client_address_ =
+        quic::QuicSocketAddress(quic::QuicIpAddress::Any6(), bind_to_port);
   }
 
   int rc = socket->Connect(server_address.impl().socket_address());
@@ -62,13 +66,13 @@ bool QuicClientMessageLooplNetworkHelper::CreateUDPSocketAndBind(
     return false;
   }
 
-  rc = socket->SetReceiveBufferSize(kDefaultSocketReceiveBuffer);
+  rc = socket->SetReceiveBufferSize(quic::kDefaultSocketReceiveBuffer);
   if (rc != OK) {
     LOG(ERROR) << "SetReceiveBufferSize() failed: " << ErrorToShortString(rc);
     return false;
   }
 
-  rc = socket->SetSendBufferSize(kDefaultSocketReceiveBuffer);
+  rc = socket->SetSendBufferSize(quic::kDefaultSocketReceiveBuffer);
   if (rc != OK) {
     LOG(ERROR) << "SetSendBufferSize() failed: " << ErrorToShortString(rc);
     return false;
@@ -80,12 +84,14 @@ bool QuicClientMessageLooplNetworkHelper::CreateUDPSocketAndBind(
     LOG(ERROR) << "GetLocalAddress failed: " << ErrorToShortString(rc);
     return false;
   }
-  client_address_ = QuicSocketAddress(QuicSocketAddressImpl(address));
+  client_address_ =
+      quic::QuicSocketAddress(quic::QuicSocketAddressImpl(address));
 
   socket_.swap(socket);
   packet_reader_.reset(new QuicChromiumPacketReader(
       socket_.get(), clock_, this, kQuicYieldAfterPacketsRead,
-      QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
+      quic::QuicTime::Delta::FromMilliseconds(
+          kQuicYieldAfterDurationMilliseconds),
       NetLogWithSource()));
 
   if (socket != nullptr) {
@@ -113,7 +119,7 @@ void QuicClientMessageLooplNetworkHelper::RunEventLoop() {
   base::RunLoop().RunUntilIdle();
 }
 
-QuicPacketWriter*
+quic::QuicPacketWriter*
 QuicClientMessageLooplNetworkHelper::CreateQuicPacketWriter() {
   return new QuicChromiumPacketWriter(
       socket_.get(), base::ThreadTaskRunnerHandle::Get().get());
@@ -126,15 +132,15 @@ void QuicClientMessageLooplNetworkHelper::OnReadError(
   client_->Disconnect();
 }
 
-QuicSocketAddress QuicClientMessageLooplNetworkHelper::GetLatestClientAddress()
-    const {
+quic::QuicSocketAddress
+QuicClientMessageLooplNetworkHelper::GetLatestClientAddress() const {
   return client_address_;
 }
 
 bool QuicClientMessageLooplNetworkHelper::OnPacket(
-    const QuicReceivedPacket& packet,
-    const QuicSocketAddress& local_address,
-    const QuicSocketAddress& peer_address) {
+    const quic::QuicReceivedPacket& packet,
+    const quic::QuicSocketAddress& local_address,
+    const quic::QuicSocketAddress& peer_address) {
   client_->session()->connection()->ProcessUdpPacket(local_address,
                                                      peer_address, packet);
   if (!client_->session()->connection()->connected()) {
diff --git a/chromium/net/tools/quic/quic_client_message_loop_network_helper.h b/chromium/net/tools/quic/quic_client_message_loop_network_helper.h
index 2a75444145d..a41f7fd3a39 100644
--- a/chromium/net/tools/quic/quic_client_message_loop_network_helper.h
+++ b/chromium/net/tools/quic/quic_client_message_loop_network_helper.h
@@ -29,39 +29,39 @@ namespace net {
 
 class UDPClientSocket;
 
-// An implementation of the QuicClientBase::NetworkHelper based off
+// An implementation of the quic::QuicClientBase::NetworkHelper based off
 // the chromium epoll server.
 class QuicClientMessageLooplNetworkHelper
-    : public QuicClientBase::NetworkHelper,
+    : public quic::QuicClientBase::NetworkHelper,
       public QuicChromiumPacketReader::Visitor {
  public:
   // Create a quic client, which will have events managed by an externally owned
   // EpollServer.
-  QuicClientMessageLooplNetworkHelper(QuicChromiumClock* clock,
-                                      QuicClientBase* client);
+  QuicClientMessageLooplNetworkHelper(quic::QuicChromiumClock* clock,
+                                      quic::QuicClientBase* client);
 
   ~QuicClientMessageLooplNetworkHelper() override;
 
   // QuicChromiumPacketReader::Visitor
   void OnReadError(int result, const DatagramClientSocket* socket) override;
-  bool OnPacket(const QuicReceivedPacket& packet,
-                const QuicSocketAddress& local_address,
-                const QuicSocketAddress& peer_address) override;
+  bool OnPacket(const quic::QuicReceivedPacket& packet,
+                const quic::QuicSocketAddress& local_address,
+                const quic::QuicSocketAddress& peer_address) override;
 
   // From NetworkHelper.
   void RunEventLoop() override;
-  bool CreateUDPSocketAndBind(QuicSocketAddress server_address,
-                              QuicIpAddress bind_to_address,
+  bool CreateUDPSocketAndBind(quic::QuicSocketAddress server_address,
+                              quic::QuicIpAddress bind_to_address,
                               int bind_to_port) override;
   void CleanUpAllUDPSockets() override;
-  QuicSocketAddress GetLatestClientAddress() const override;
-  QuicPacketWriter* CreateQuicPacketWriter() override;
+  quic::QuicSocketAddress GetLatestClientAddress() const override;
+  quic::QuicPacketWriter* CreateQuicPacketWriter() override;
 
  private:
   void StartPacketReaderIfNotStarted();
 
   // Address of the client if the client is connected to the server.
-  QuicSocketAddress client_address_;
+  quic::QuicSocketAddress client_address_;
 
   // UDP socket connected to the server.
   std::unique_ptr<UDPClientSocket> socket_;
@@ -73,8 +73,8 @@ class QuicClientMessageLooplNetworkHelper
 
   bool packet_reader_started_;
 
-  QuicChromiumClock* clock_;
-  QuicClientBase* client_;
+  quic::QuicChromiumClock* clock_;
+  quic::QuicClientBase* client_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicClientMessageLooplNetworkHelper);
 };
diff --git a/chromium/net/tools/quic/quic_simple_client.cc b/chromium/net/tools/quic/quic_simple_client.cc
index dbd6fff4b4a..ac17ee6c6a9 100644
--- a/chromium/net/tools/quic/quic_simple_client.cc
+++ b/chromium/net/tools/quic/quic_simple_client.cc
@@ -34,17 +34,17 @@ using std::string;
 namespace net {
 
 QuicSimpleClient::QuicSimpleClient(
-    QuicSocketAddress server_address,
-    const QuicServerId& server_id,
-    const ParsedQuicVersionVector& supported_versions,
-    std::unique_ptr<ProofVerifier> proof_verifier)
-    : QuicSpdyClientBase(
+    quic::QuicSocketAddress server_address,
+    const quic::QuicServerId& server_id,
+    const quic::ParsedQuicVersionVector& supported_versions,
+    std::unique_ptr<quic::ProofVerifier> proof_verifier)
+    : quic::QuicSpdyClientBase(
           server_id,
           supported_versions,
-          QuicConfig(),
+          quic::QuicConfig(),
           CreateQuicConnectionHelper(),
           CreateQuicAlarmFactory(),
-          QuicWrapUnique(
+          quic::QuicWrapUnique(
               new QuicClientMessageLooplNetworkHelper(&clock_, this)),
           std::move(proof_verifier)),
       initialized_(false),
@@ -55,13 +55,14 @@ QuicSimpleClient::QuicSimpleClient(
 QuicSimpleClient::~QuicSimpleClient() {
   if (connected()) {
     session()->connection()->CloseConnection(
-        QUIC_PEER_GOING_AWAY, "Shutting down",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+        quic::QUIC_PEER_GOING_AWAY, "Shutting down",
+        quic::ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 }
 
 QuicChromiumConnectionHelper* QuicSimpleClient::CreateQuicConnectionHelper() {
-  return new QuicChromiumConnectionHelper(&clock_, QuicRandom::GetInstance());
+  return new QuicChromiumConnectionHelper(&clock_,
+                                          quic::QuicRandom::GetInstance());
 }
 
 QuicChromiumAlarmFactory* QuicSimpleClient::CreateQuicAlarmFactory() {
diff --git a/chromium/net/tools/quic/quic_simple_client.h b/chromium/net/tools/quic/quic_simple_client.h
index d3329f6598d..d9144b369b7 100644
--- a/chromium/net/tools/quic/quic_simple_client.h
+++ b/chromium/net/tools/quic/quic_simple_client.h
@@ -35,13 +35,13 @@ namespace test {
 class QuicClientPeer;
 }  // namespace test
 
-class QuicSimpleClient : public QuicSpdyClientBase {
+class QuicSimpleClient : public quic::QuicSpdyClientBase {
  public:
   // Create a quic client, which will have events managed by the message loop.
-  QuicSimpleClient(QuicSocketAddress server_address,
-                   const QuicServerId& server_id,
-                   const ParsedQuicVersionVector& supported_versions,
-                   std::unique_ptr<ProofVerifier> proof_verifier);
+  QuicSimpleClient(quic::QuicSocketAddress server_address,
+                   const quic::QuicServerId& server_id,
+                   const quic::ParsedQuicVersionVector& supported_versions,
+                   std::unique_ptr<quic::ProofVerifier> proof_verifier);
 
   ~QuicSimpleClient() override;
 
@@ -52,7 +52,7 @@ class QuicSimpleClient : public QuicSpdyClientBase {
   QuicChromiumConnectionHelper* CreateQuicConnectionHelper();
 
   //  Used by |helper_| to time alarms.
-  QuicChromiumClock clock_;
+  quic::QuicChromiumClock clock_;
 
   // Tracks if the client is initialized to connect.
   bool initialized_;
diff --git a/chromium/net/tools/quic/quic_simple_client_bin.cc b/chromium/net/tools/quic/quic_simple_client_bin.cc
index f21ef04445c..aeb533651f0 100644
--- a/chromium/net/tools/quic/quic_simple_client_bin.cc
+++ b/chromium/net/tools/quic/quic_simple_client_bin.cc
@@ -69,10 +69,10 @@
 using net::CertVerifier;
 using net::CTVerifier;
 using net::MultiLogCTVerifier;
-using net::ProofVerifier;
+using quic::ProofVerifier;
 using net::ProofVerifierChromium;
-using net::QuicStringPiece;
-using net::QuicTextUtils;
+using quic::QuicStringPiece;
+using quic::QuicTextUtils;
 using net::TransportSecurityState;
 using spdy::SpdyHeaderBlock;
 using std::cout;
@@ -105,32 +105,32 @@ bool FLAGS_redirect_is_success = true;
 // Initial MTU of the connection.
 int32_t FLAGS_initial_mtu = 0;
 
-class FakeProofVerifier : public ProofVerifier {
+class FakeProofVerifier : public quic::ProofVerifier {
  public:
-  net::QuicAsyncStatus VerifyProof(
+  quic::QuicAsyncStatus VerifyProof(
       const string& hostname,
       const uint16_t port,
       const string& server_config,
-      net::QuicTransportVersion quic_version,
-      QuicStringPiece chlo_hash,
+      quic::QuicTransportVersion quic_version,
+      quic::QuicStringPiece chlo_hash,
       const std::vector<string>& certs,
       const string& cert_sct,
       const string& signature,
-      const net::ProofVerifyContext* context,
+      const quic::ProofVerifyContext* context,
       string* error_details,
-      std::unique_ptr<net::ProofVerifyDetails>* details,
-      std::unique_ptr<net::ProofVerifierCallback> callback) override {
-    return net::QUIC_SUCCESS;
+      std::unique_ptr<quic::ProofVerifyDetails>* details,
+      std::unique_ptr<quic::ProofVerifierCallback> callback) override {
+    return quic::QUIC_SUCCESS;
   }
 
-  net::QuicAsyncStatus VerifyCertChain(
+  quic::QuicAsyncStatus VerifyCertChain(
       const std::string& hostname,
       const std::vector<std::string>& certs,
-      const net::ProofVerifyContext* verify_context,
+      const quic::ProofVerifyContext* verify_context,
       std::string* error_details,
-      std::unique_ptr<net::ProofVerifyDetails>* verify_details,
-      std::unique_ptr<net::ProofVerifierCallback> callback) override {
-    return net::QUIC_SUCCESS;
+      std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
+      std::unique_ptr<quic::ProofVerifierCallback> callback) override {
+    return quic::QUIC_SUCCESS;
   }
 };
 
@@ -224,7 +224,7 @@ int main(int argc, char* argv[]) {
   base::MessageLoopForIO message_loop;
 
   // Determine IP address to connect to from supplied hostname.
-  net::QuicIpAddress ip_addr;
+  quic::QuicIpAddress ip_addr;
 
   GURL url(urls[0]);
   string host = FLAGS_host;
@@ -244,21 +244,21 @@ int main(int argc, char* argv[]) {
       return 1;
     }
     ip_addr =
-        net::QuicIpAddress(net::QuicIpAddressImpl(addresses[0].address()));
+        quic::QuicIpAddress(quic::QuicIpAddressImpl(addresses[0].address()));
   }
 
-  string host_port = net::QuicStrCat(ip_addr.ToString(), ":", port);
+  string host_port = quic::QuicStrCat(ip_addr.ToString(), ":", port);
   VLOG(1) << "Resolved " << host << " to " << host_port << endl;
 
   // Build the client, and try to connect.
-  net::QuicServerId server_id(url.host(), url.EffectiveIntPort(),
-                              net::PRIVACY_MODE_DISABLED);
-  net::ParsedQuicVersionVector versions = net::AllSupportedVersions();
+  quic::QuicServerId server_id(url.host(), url.EffectiveIntPort(),
+                               net::PRIVACY_MODE_DISABLED);
+  quic::ParsedQuicVersionVector versions = quic::CurrentSupportedVersions();
   if (FLAGS_quic_version != -1) {
     versions.clear();
-    versions.push_back(net::ParsedQuicVersion(
-        net::PROTOCOL_QUIC_CRYPTO,
-        static_cast<net::QuicTransportVersion>(FLAGS_quic_version)));
+    versions.push_back(quic::ParsedQuicVersion(
+        quic::PROTOCOL_QUIC_CRYPTO,
+        static_cast<quic::QuicTransportVersion>(FLAGS_quic_version)));
   }
   // For secure QUIC we need to verify the cert chain.
   std::unique_ptr<CertVerifier> cert_verifier(CertVerifier::CreateDefault());
@@ -267,7 +267,7 @@ int main(int argc, char* argv[]) {
   std::unique_ptr<MultiLogCTVerifier> ct_verifier(new MultiLogCTVerifier());
   std::unique_ptr<net::CTPolicyEnforcer> ct_policy_enforcer(
       new net::DefaultCTPolicyEnforcer());
-  std::unique_ptr<ProofVerifier> proof_verifier;
+  std::unique_ptr<quic::ProofVerifier> proof_verifier;
   if (line->HasSwitch("disable-certificate-verification")) {
     proof_verifier.reset(new FakeProofVerifier());
   } else {
@@ -275,17 +275,17 @@ int main(int argc, char* argv[]) {
         cert_verifier.get(), ct_policy_enforcer.get(),
         transport_security_state.get(), ct_verifier.get()));
   }
-  net::QuicSimpleClient client(net::QuicSocketAddress(ip_addr, port), server_id,
-                               versions, std::move(proof_verifier));
+  net::QuicSimpleClient client(quic::QuicSocketAddress(ip_addr, port),
+                               server_id, versions, std::move(proof_verifier));
   client.set_initial_max_packet_length(
-      FLAGS_initial_mtu != 0 ? FLAGS_initial_mtu : net::kDefaultMaxPacketSize);
+      FLAGS_initial_mtu != 0 ? FLAGS_initial_mtu : quic::kDefaultMaxPacketSize);
   if (!client.Initialize()) {
     cerr << "Failed to initialize client." << endl;
     return 1;
   }
   if (!client.Connect()) {
-    net::QuicErrorCode error = client.session()->error();
-    if (FLAGS_version_mismatch_ok && error == net::QUIC_INVALID_VERSION) {
+    quic::QuicErrorCode error = client.session()->error();
+    if (FLAGS_version_mismatch_ok && error == quic::QUIC_INVALID_VERSION) {
       cout << "Server talks QUIC, but none of the versions supported by "
            << "this client: " << ParsedQuicVersionVectorToString(versions)
            << endl;
@@ -293,7 +293,7 @@ int main(int argc, char* argv[]) {
       return 0;
     }
     cerr << "Failed to connect to " << host_port
-         << ". Error: " << net::QuicErrorCodeToString(error) << endl;
+         << ". Error: " << quic::QuicErrorCodeToString(error) << endl;
     return 1;
   }
   cout << "Connected to " << host_port << endl;
@@ -302,7 +302,7 @@ int main(int argc, char* argv[]) {
   string body = FLAGS_body;
   if (!FLAGS_body_hex.empty()) {
     DCHECK(FLAGS_body.empty()) << "Only set one of --body and --body_hex.";
-    body = QuicTextUtils::HexDecode(FLAGS_body_hex);
+    body = quic::QuicTextUtils::HexDecode(FLAGS_body_hex);
   }
 
   // Construct a GET or POST request for supplied URL.
@@ -313,14 +313,15 @@ int main(int argc, char* argv[]) {
   header_block[":path"] = url.path();
 
   // Append any additional headers supplied on the command line.
-  for (QuicStringPiece sp : QuicTextUtils::Split(FLAGS_headers, ';')) {
-    QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
+  for (quic::QuicStringPiece sp :
+       quic::QuicTextUtils::Split(FLAGS_headers, ';')) {
+    quic::QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
     if (sp.empty()) {
       continue;
     }
-    std::vector<QuicStringPiece> kv = QuicTextUtils::Split(sp, ':');
-    QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
-    QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
+    std::vector<quic::QuicStringPiece> kv = quic::QuicTextUtils::Split(sp, ':');
+    quic::QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
+    quic::QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
     header_block[kv[0]] = kv[1];
   }
 
@@ -337,7 +338,8 @@ int main(int argc, char* argv[]) {
     if (!FLAGS_body_hex.empty()) {
       // Print the user provided hex, rather than binary body.
       cout << "body:\n"
-           << QuicTextUtils::HexDump(QuicTextUtils::HexDecode(FLAGS_body_hex))
+           << quic::QuicTextUtils::HexDump(
+                  quic::QuicTextUtils::HexDecode(FLAGS_body_hex))
            << endl;
     } else {
       cout << "body: " << body << endl;
@@ -348,7 +350,7 @@ int main(int argc, char* argv[]) {
     string response_body = client.latest_response_body();
     if (!FLAGS_body_hex.empty()) {
       // Assume response is binary data.
-      cout << "body:\n" << QuicTextUtils::HexDump(response_body) << endl;
+      cout << "body:\n" << quic::QuicTextUtils::HexDump(response_body) << endl;
     } else {
       cout << "body: " << response_body << endl;
     }
diff --git a/chromium/net/tools/quic/quic_simple_client_test.cc b/chromium/net/tools/quic/quic_simple_client_test.cc
index 39ccbe63625..ec12c45d43f 100644
--- a/chromium/net/tools/quic/quic_simple_client_test.cc
+++ b/chromium/net/tools/quic/quic_simple_client_test.cc
@@ -15,12 +15,12 @@ namespace test {
 
 TEST(QuicSimpleClientTest, Initialize) {
   base::test::ScopedTaskEnvironment scoped_task_environment;
-  QuicSocketAddress server_address(QuicIpAddress::Loopback4(), 80);
-  QuicServerId server_id("hostname", server_address.port(),
-                         PRIVACY_MODE_DISABLED);
-  ParsedQuicVersionVector versions = AllSupportedVersions();
-  QuicSimpleClient client(server_address, server_id, versions,
-                          crypto_test_utils::ProofVerifierForTesting());
+  quic::QuicSocketAddress server_address(quic::QuicIpAddress::Loopback4(), 80);
+  quic::QuicServerId server_id("hostname", server_address.port(), false);
+  quic::ParsedQuicVersionVector versions = quic::AllSupportedVersions();
+  QuicSimpleClient client(
+      server_address, server_id, versions,
+      quic::test::crypto_test_utils::ProofVerifierForTesting());
   EXPECT_TRUE(client.Initialize());
 }
 
diff --git a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc b/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc
index 9046a9b7b88..d57af46aeaa 100644
--- a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc
+++ b/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.cc
@@ -18,16 +18,17 @@ QuicSimplePerConnectionPacketWriter::QuicSimplePerConnectionPacketWriter(
 QuicSimplePerConnectionPacketWriter::~QuicSimplePerConnectionPacketWriter() =
     default;
 
-QuicPacketWriter* QuicSimplePerConnectionPacketWriter::shared_writer() const {
+quic::QuicPacketWriter* QuicSimplePerConnectionPacketWriter::shared_writer()
+    const {
   return shared_writer_;
 }
 
-WriteResult QuicSimplePerConnectionPacketWriter::WritePacket(
+quic::WriteResult QuicSimplePerConnectionPacketWriter::WritePacket(
     const char* buffer,
     size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    PerPacketOptions* options) {
+    const quic::QuicIpAddress& self_address,
+    const quic::QuicSocketAddress& peer_address,
+    quic::PerPacketOptions* options) {
   return shared_writer_->WritePacketWithCallback(
       buffer, buf_len, self_address, peer_address, options,
       base::Bind(&QuicSimplePerConnectionPacketWriter::OnWriteComplete,
@@ -46,14 +47,15 @@ void QuicSimplePerConnectionPacketWriter::SetWritable() {
   shared_writer_->SetWritable();
 }
 
-void QuicSimplePerConnectionPacketWriter::OnWriteComplete(WriteResult result) {
-  if (connection_ && result.status == WRITE_STATUS_ERROR) {
+void QuicSimplePerConnectionPacketWriter::OnWriteComplete(
+    quic::WriteResult result) {
+  if (connection_ && result.status == quic::WRITE_STATUS_ERROR) {
     connection_->OnWriteError(result.error_code);
   }
 }
 
-QuicByteCount QuicSimplePerConnectionPacketWriter::GetMaxPacketSize(
-    const QuicSocketAddress& peer_address) const {
+quic::QuicByteCount QuicSimplePerConnectionPacketWriter::GetMaxPacketSize(
+    const quic::QuicSocketAddress& peer_address) const {
   return shared_writer_->GetMaxPacketSize(peer_address);
 }
 
diff --git a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h b/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h
index 7e5132e59b5..08d615b15be 100644
--- a/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h
+++ b/chromium/net/tools/quic/quic_simple_per_connection_packet_writer.h
@@ -20,35 +20,37 @@ class QuicSimpleServerPacketWriter;
 // writes to the shared QuicServerPacketWriter complete.
 // This class is necessary because multiple connections can share the same
 // QuicServerPacketWriter, so it has no way to know which connection to notify.
-class QuicSimplePerConnectionPacketWriter : public QuicPacketWriter {
+class QuicSimplePerConnectionPacketWriter : public quic::QuicPacketWriter {
  public:
   // Does not take ownership of |shared_writer| or |connection|.
   QuicSimplePerConnectionPacketWriter(
       QuicSimpleServerPacketWriter* shared_writer);
   ~QuicSimplePerConnectionPacketWriter() override;
 
-  QuicPacketWriter* shared_writer() const;
-  void set_connection(QuicConnection* connection) { connection_ = connection; }
-  QuicConnection* connection() const { return connection_; }
-
-  // Default implementation of the QuicPacketWriter interface: Passes everything
-  // to |shared_writer_|.
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
-                          const QuicIpAddress& self_address,
-                          const QuicSocketAddress& peer_address,
-                          PerPacketOptions* options) override;
+  quic::QuicPacketWriter* shared_writer() const;
+  void set_connection(quic::QuicConnection* connection) {
+    connection_ = connection;
+  }
+  quic::QuicConnection* connection() const { return connection_; }
+
+  // Default implementation of the quic::QuicPacketWriter interface: Passes
+  // everything to |shared_writer_|.
+  quic::WriteResult WritePacket(const char* buffer,
+                                size_t buf_len,
+                                const quic::QuicIpAddress& self_address,
+                                const quic::QuicSocketAddress& peer_address,
+                                quic::PerPacketOptions* options) override;
   bool IsWriteBlockedDataBuffered() const override;
   bool IsWriteBlocked() const override;
   void SetWritable() override;
-  QuicByteCount GetMaxPacketSize(
-      const QuicSocketAddress& peer_address) const override;
+  quic::QuicByteCount GetMaxPacketSize(
+      const quic::QuicSocketAddress& peer_address) const override;
 
  private:
-  void OnWriteComplete(WriteResult result);
+  void OnWriteComplete(quic::WriteResult result);
 
   QuicSimpleServerPacketWriter* shared_writer_;  // Not owned.
-  QuicConnection* connection_;                   // Not owned.
+  quic::QuicConnection* connection_;             // Not owned.
 
   base::WeakPtrFactory<QuicSimplePerConnectionPacketWriter> weak_factory_;
 
diff --git a/chromium/net/tools/quic/quic_simple_server.cc b/chromium/net/tools/quic/quic_simple_server.cc
index 1e990db9af1..2d1c7042d84 100644
--- a/chromium/net/tools/quic/quic_simple_server.cc
+++ b/chromium/net/tools/quic/quic_simple_server.cc
@@ -33,28 +33,29 @@ const size_t kNumSessionsToCreatePerSocketEvent = 16;
 
 // Allocate some extra space so we can send an error if the client goes over
 // the limit.
-const int kReadBufferSize = 2 * kMaxPacketSize;
+const int kReadBufferSize = 2 * quic::kMaxPacketSize;
 
 }  // namespace
 
 QuicSimpleServer::QuicSimpleServer(
-    std::unique_ptr<ProofSource> proof_source,
-    const QuicConfig& config,
-    const QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
-    const ParsedQuicVersionVector& supported_versions,
-    QuicSimpleServerBackend* quic_simple_server_backend)
+    std::unique_ptr<quic::ProofSource> proof_source,
+    const quic::QuicConfig& config,
+    const quic::QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
+    const quic::ParsedQuicVersionVector& supported_versions,
+    quic::QuicSimpleServerBackend* quic_simple_server_backend)
     : version_manager_(supported_versions),
       helper_(
-          new QuicChromiumConnectionHelper(&clock_, QuicRandom::GetInstance())),
+          new QuicChromiumConnectionHelper(&clock_,
+                                           quic::QuicRandom::GetInstance())),
       alarm_factory_(new QuicChromiumAlarmFactory(
           base::ThreadTaskRunnerHandle::Get().get(),
           &clock_)),
       config_(config),
       crypto_config_options_(crypto_config_options),
       crypto_config_(kSourceAddressTokenSecret,
-                     QuicRandom::GetInstance(),
+                     quic::QuicRandom::GetInstance(),
                      std::move(proof_source),
-                     TlsServerHandshaker::CreateSslCtx()),
+                     quic::TlsServerHandshaker::CreateSslCtx()),
       read_pending_(false),
       synchronous_read_count_(0),
       read_buffer_(new IOBufferWithSize(kReadBufferSize)),
@@ -73,19 +74,20 @@ void QuicSimpleServer::Initialize() {
   const uint32_t kInitialSessionFlowControlWindow = 1 * 1024 * 1024;  // 1 MB
   const uint32_t kInitialStreamFlowControlWindow = 64 * 1024;         // 64 KB
   if (config_.GetInitialStreamFlowControlWindowToSend() ==
-      kMinimumFlowControlSendWindow) {
+      quic::kMinimumFlowControlSendWindow) {
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindow);
   }
   if (config_.GetInitialSessionFlowControlWindowToSend() ==
-      kMinimumFlowControlSendWindow) {
+      quic::kMinimumFlowControlSendWindow) {
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindow);
   }
 
-  std::unique_ptr<CryptoHandshakeMessage> scfg(crypto_config_.AddDefaultConfig(
-      helper_->GetRandomGenerator(), helper_->GetClock(),
-      crypto_config_options_));
+  std::unique_ptr<quic::CryptoHandshakeMessage> scfg(
+      crypto_config_.AddDefaultConfig(helper_->GetRandomGenerator(),
+                                      helper_->GetClock(),
+                                      crypto_config_options_));
 }
 
 QuicSimpleServer::~QuicSimpleServer() = default;
@@ -106,13 +108,13 @@ int QuicSimpleServer::Listen(const IPEndPoint& address) {
   // because the default usage of QuicSimpleServer is as a test server with
   // one or two clients.  Adjust higher for use with many clients.
   rc = socket->SetReceiveBufferSize(
-      static_cast<int32_t>(kDefaultSocketReceiveBuffer));
+      static_cast<int32_t>(quic::kDefaultSocketReceiveBuffer));
   if (rc < 0) {
     LOG(ERROR) << "SetReceiveBufferSize() failed: " << ErrorToString(rc);
     return rc;
   }
 
-  rc = socket->SetSendBufferSize(20 * kMaxPacketSize);
+  rc = socket->SetSendBufferSize(20 * quic::kMaxPacketSize);
   if (rc < 0) {
     LOG(ERROR) << "SetSendBufferSize() failed: " << ErrorToString(rc);
     return rc;
@@ -128,12 +130,12 @@ int QuicSimpleServer::Listen(const IPEndPoint& address) {
 
   socket_.swap(socket);
 
-  dispatcher_.reset(new QuicSimpleDispatcher(
+  dispatcher_.reset(new quic::QuicSimpleDispatcher(
       config_, &crypto_config_, &version_manager_,
-      std::unique_ptr<QuicConnectionHelperInterface>(helper_),
-      std::unique_ptr<QuicCryptoServerStream::Helper>(
-          new QuicSimpleServerSessionHelper(QuicRandom::GetInstance())),
-      std::unique_ptr<QuicAlarmFactory>(alarm_factory_),
+      std::unique_ptr<quic::QuicConnectionHelperInterface>(helper_),
+      std::unique_ptr<quic::QuicCryptoServerStream::Helper>(
+          new QuicSimpleServerSessionHelper(quic::QuicRandom::GetInstance())),
+      std::unique_ptr<quic::QuicAlarmFactory>(alarm_factory_),
       quic_simple_server_backend_));
   QuicSimpleServerPacketWriter* writer =
       new QuicSimpleServerPacketWriter(socket_.get(), dispatcher_.get());
@@ -205,11 +207,12 @@ void QuicSimpleServer::OnReadComplete(int result) {
     return;
   }
 
-  QuicReceivedPacket packet(read_buffer_->data(), result,
-                            helper_->GetClock()->Now(), false);
+  quic::QuicReceivedPacket packet(read_buffer_->data(), result,
+                                  helper_->GetClock()->Now(), false);
   dispatcher_->ProcessPacket(
-      QuicSocketAddress(QuicSocketAddressImpl(server_address_)),
-      QuicSocketAddress(QuicSocketAddressImpl(client_address_)), packet);
+      quic::QuicSocketAddress(quic::QuicSocketAddressImpl(server_address_)),
+      quic::QuicSocketAddress(quic::QuicSocketAddressImpl(client_address_)),
+      packet);
 
   StartReading();
 }
diff --git a/chromium/net/tools/quic/quic_simple_server.h b/chromium/net/tools/quic/quic_simple_server.h
index faae4fb4f75..9e6fde1826e 100644
--- a/chromium/net/tools/quic/quic_simple_server.h
+++ b/chromium/net/tools/quic/quic_simple_server.h
@@ -26,8 +26,11 @@ namespace net {
 
 class UDPServerSocket;
 
-
+}  // namespace net
+namespace quic {
 class QuicDispatcher;
+}  // namespace quic
+namespace net {
 
 namespace test {
 class QuicSimpleServerPeer;
@@ -36,11 +39,11 @@ class QuicSimpleServerPeer;
 class QuicSimpleServer {
  public:
   QuicSimpleServer(
-      std::unique_ptr<ProofSource> proof_source,
-      const QuicConfig& config,
-      const QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
-      const ParsedQuicVersionVector& supported_versions,
-      QuicSimpleServerBackend* quic_simple_server_backend);
+      std::unique_ptr<quic::ProofSource> proof_source,
+      const quic::QuicConfig& config,
+      const quic::QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
+      const quic::ParsedQuicVersionVector& supported_versions,
+      quic::QuicSimpleServerBackend* quic_simple_server_backend);
 
   virtual ~QuicSimpleServer();
 
@@ -58,7 +61,7 @@ class QuicSimpleServer {
   // continues the read loop.
   void OnReadComplete(int result);
 
-  QuicDispatcher* dispatcher() { return dispatcher_.get(); }
+  quic::QuicDispatcher* dispatcher() { return dispatcher_.get(); }
 
   IPEndPoint server_address() const { return server_address_; }
 
@@ -68,13 +71,13 @@ class QuicSimpleServer {
   // Initialize the internal state of the server.
   void Initialize();
 
-  QuicVersionManager version_manager_;
+  quic::QuicVersionManager version_manager_;
 
   // Accepts data from the framer and demuxes clients to sessions.
-  std::unique_ptr<QuicDispatcher> dispatcher_;
+  std::unique_ptr<quic::QuicDispatcher> dispatcher_;
 
   // Used by the helper_ to time alarms.
-  QuicChromiumClock clock_;
+  quic::QuicChromiumClock clock_;
 
   // Used to manage the message loop. Owned by dispatcher_.
   QuicChromiumConnectionHelper* helper_;
@@ -87,12 +90,12 @@ class QuicSimpleServer {
 
   // config_ contains non-crypto parameters that are negotiated in the crypto
   // handshake.
-  QuicConfig config_;
+  quic::QuicConfig config_;
   // crypto_config_ contains crypto parameters that are negotiated in the crypto
   // handshake.
-  QuicCryptoServerConfig::ConfigOptions crypto_config_options_;
+  quic::QuicCryptoServerConfig::ConfigOptions crypto_config_options_;
   // crypto_config_ contains crypto parameters for the handshake.
-  QuicCryptoServerConfig crypto_config_;
+  quic::QuicCryptoServerConfig crypto_config_;
 
   // The address that the server listens on.
   IPEndPoint server_address_;
@@ -114,7 +117,7 @@ class QuicSimpleServer {
   // The log to use for the socket.
   NetLog net_log_;
 
-  QuicSimpleServerBackend* quic_simple_server_backend_;
+  quic::QuicSimpleServerBackend* quic_simple_server_backend_;
 
   base::WeakPtrFactory<QuicSimpleServer> weak_factory_;
 
diff --git a/chromium/net/tools/quic/quic_simple_server_bin.cc b/chromium/net/tools/quic/quic_simple_server_bin.cc
index 57c4f1a9c7a..42cc3cada44 100644
--- a/chromium/net/tools/quic/quic_simple_server_bin.cc
+++ b/chromium/net/tools/quic/quic_simple_server_bin.cc
@@ -30,7 +30,7 @@ std::string FLAGS_quic_mode = "cache";
 // generated using `wget -p --save-headers <url>`
 std::string FLAGS_quic_response_cache_dir = "";
 
-std::unique_ptr<net::ProofSource> CreateProofSource(
+std::unique_ptr<quic::ProofSource> CreateProofSource(
     const base::FilePath& cert_path,
     const base::FilePath& key_path) {
   std::unique_ptr<net::ProofSourceChromium> proof_source(
@@ -71,7 +71,7 @@ int main(int argc, char* argv[]) {
     exit(0);
   }
 
-  net::QuicMemoryCacheBackend memory_cache_backend;
+  quic::QuicMemoryCacheBackend memory_cache_backend;
   if (line->HasSwitch("mode")) {
     FLAGS_quic_mode = line->GetSwitchValueASCII("mode");
   }
@@ -110,12 +110,12 @@ int main(int argc, char* argv[]) {
 
   net::IPAddress ip = net::IPAddress::IPv6AllZeros();
 
-  net::QuicConfig config;
+  quic::QuicConfig config;
   net::QuicSimpleServer server(
       CreateProofSource(line->GetSwitchValuePath("certificate_file"),
                         line->GetSwitchValuePath("key_file")),
-      config, net::QuicCryptoServerConfig::ConfigOptions(),
-      net::AllSupportedVersions(), &memory_cache_backend);
+      config, quic::QuicCryptoServerConfig::ConfigOptions(),
+      quic::AllSupportedVersions(), &memory_cache_backend);
 
   int rc = server.Listen(net::IPEndPoint(ip, FLAGS_port));
   if (rc < 0) {
diff --git a/chromium/net/tools/quic/quic_simple_server_packet_writer.cc b/chromium/net/tools/quic/quic_simple_server_packet_writer.cc
index c20b835bb0f..803751b656e 100644
--- a/chromium/net/tools/quic/quic_simple_server_packet_writer.cc
+++ b/chromium/net/tools/quic/quic_simple_server_packet_writer.cc
@@ -17,7 +17,7 @@ namespace net {
 
 QuicSimpleServerPacketWriter::QuicSimpleServerPacketWriter(
     UDPServerSocket* socket,
-    QuicDispatcher* dispatcher)
+    quic::QuicDispatcher* dispatcher)
     : socket_(socket),
       dispatcher_(dispatcher),
       write_blocked_(false),
@@ -25,18 +25,18 @@ QuicSimpleServerPacketWriter::QuicSimpleServerPacketWriter(
 
 QuicSimpleServerPacketWriter::~QuicSimpleServerPacketWriter() = default;
 
-WriteResult QuicSimpleServerPacketWriter::WritePacketWithCallback(
+quic::WriteResult QuicSimpleServerPacketWriter::WritePacketWithCallback(
     const char* buffer,
     size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    PerPacketOptions* options,
+    const quic::QuicIpAddress& self_address,
+    const quic::QuicSocketAddress& peer_address,
+    quic::PerPacketOptions* options,
     WriteCallback callback) {
   DCHECK(callback_.is_null());
   callback_ = callback;
-  WriteResult result =
+  quic::WriteResult result =
       WritePacket(buffer, buf_len, self_address, peer_address, options);
-  if (result.status != WRITE_STATUS_BLOCKED) {
+  if (result.status != quic::WRITE_STATUS_BLOCKED) {
     callback_.Reset();
   }
   return result;
@@ -45,7 +45,8 @@ WriteResult QuicSimpleServerPacketWriter::WritePacketWithCallback(
 void QuicSimpleServerPacketWriter::OnWriteComplete(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   write_blocked_ = false;
-  WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv);
+  quic::WriteResult result(
+      rv < 0 ? quic::WRITE_STATUS_ERROR : quic::WRITE_STATUS_OK, rv);
   if (!callback_.is_null()) {
     base::ResetAndReturn(&callback_).Run(result);
   }
@@ -65,12 +66,12 @@ void QuicSimpleServerPacketWriter::SetWritable() {
   write_blocked_ = false;
 }
 
-WriteResult QuicSimpleServerPacketWriter::WritePacket(
+quic::WriteResult QuicSimpleServerPacketWriter::WritePacket(
     const char* buffer,
     size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    PerPacketOptions* options) {
+    const quic::QuicIpAddress& self_address,
+    const quic::QuicSocketAddress& peer_address,
+    quic::PerPacketOptions* options) {
   scoped_refptr<StringIOBuffer> buf(
       new StringIOBuffer(std::string(buffer, buf_len)));
   DCHECK(!IsWriteBlocked());
@@ -84,22 +85,38 @@ WriteResult QuicSimpleServerPacketWriter::WritePacket(
   } else {
     rv = ERR_MSG_TOO_BIG;
   }
-  WriteStatus status = WRITE_STATUS_OK;
+  quic::WriteStatus status = quic::WRITE_STATUS_OK;
   if (rv < 0) {
     if (rv != ERR_IO_PENDING) {
-      base::UmaHistogramSparse("Net.QuicSession.WriteError", -rv);
-      status = WRITE_STATUS_ERROR;
+      base::UmaHistogramSparse("Net.quic::QuicSession.WriteError", -rv);
+      status = quic::WRITE_STATUS_ERROR;
     } else {
-      status = WRITE_STATUS_BLOCKED;
+      status = quic::WRITE_STATUS_BLOCKED;
       write_blocked_ = true;
     }
   }
-  return WriteResult(status, rv);
+  return quic::WriteResult(status, rv);
 }
 
-QuicByteCount QuicSimpleServerPacketWriter::GetMaxPacketSize(
-    const QuicSocketAddress& peer_address) const {
-  return kMaxPacketSize;
+quic::QuicByteCount QuicSimpleServerPacketWriter::GetMaxPacketSize(
+    const quic::QuicSocketAddress& peer_address) const {
+  return quic::kMaxPacketSize;
+}
+
+bool QuicSimpleServerPacketWriter::SupportsReleaseTime() const {
+  return false;
+}
+
+bool QuicSimpleServerPacketWriter::IsBatchMode() const {
+  return false;
+}
+
+char* QuicSimpleServerPacketWriter::GetNextWriteLocation() const {
+  return nullptr;
+}
+
+quic::WriteResult QuicSimpleServerPacketWriter::Flush() {
+  return quic::WriteResult(quic::WRITE_STATUS_OK, 0);
 }
 
 }  // namespace net
diff --git a/chromium/net/tools/quic/quic_simple_server_packet_writer.h b/chromium/net/tools/quic/quic_simple_server_packet_writer.h
index 5b266aa6914..fb5ec3861a6 100644
--- a/chromium/net/tools/quic/quic_simple_server_packet_writer.h
+++ b/chromium/net/tools/quic/quic_simple_server_packet_writer.h
@@ -14,51 +14,60 @@
 #include "net/third_party/quic/core/quic_packet_writer.h"
 #include "net/third_party/quic/core/quic_packets.h"
 
-namespace net {
-
+namespace quic {
 class QuicDispatcher;
+}  // namespace quic
+namespace net {
 class UDPServerSocket;
+}  // namespace net
+namespace quic {
 struct WriteResult;
-
+}  // namespace quic
+namespace net {
 
 // Chrome specific packet writer which uses a UDPServerSocket for writing
 // data.
-class QuicSimpleServerPacketWriter : public QuicPacketWriter {
+class QuicSimpleServerPacketWriter : public quic::QuicPacketWriter {
  public:
-  typedef base::Callback<void(WriteResult)> WriteCallback;
+  typedef base::Callback<void(quic::WriteResult)> WriteCallback;
 
   QuicSimpleServerPacketWriter(UDPServerSocket* socket,
-                               QuicDispatcher* dispatcher);
+                               quic::QuicDispatcher* dispatcher);
   ~QuicSimpleServerPacketWriter() override;
 
   // Wraps WritePacket, and ensures that |callback| is run on successful write.
-  WriteResult WritePacketWithCallback(const char* buffer,
-                                      size_t buf_len,
-                                      const QuicIpAddress& self_address,
-                                      const QuicSocketAddress& peer_address,
-                                      PerPacketOptions* options,
-                                      WriteCallback callback);
-
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
-                          const QuicIpAddress& self_address,
-                          const QuicSocketAddress& peer_address,
-                          PerPacketOptions* options) override;
+  quic::WriteResult WritePacketWithCallback(
+      const char* buffer,
+      size_t buf_len,
+      const quic::QuicIpAddress& self_address,
+      const quic::QuicSocketAddress& peer_address,
+      quic::PerPacketOptions* options,
+      WriteCallback callback);
+
+  quic::WriteResult WritePacket(const char* buffer,
+                                size_t buf_len,
+                                const quic::QuicIpAddress& self_address,
+                                const quic::QuicSocketAddress& peer_address,
+                                quic::PerPacketOptions* options) override;
 
   void OnWriteComplete(int rv);
 
-  // QuicPacketWriter implementation:
+  // quic::QuicPacketWriter implementation:
   bool IsWriteBlockedDataBuffered() const override;
   bool IsWriteBlocked() const override;
   void SetWritable() override;
-  QuicByteCount GetMaxPacketSize(
-      const QuicSocketAddress& peer_address) const override;
+  quic::QuicByteCount GetMaxPacketSize(
+      const quic::QuicSocketAddress& peer_address) const override;
+  bool SupportsReleaseTime() const override;
+  bool IsBatchMode() const override;
+  char* GetNextWriteLocation() const override;
+  quic::WriteResult Flush() override;
 
  private:
   UDPServerSocket* socket_;
 
   // To be notified after every successful asynchronous write.
-  QuicDispatcher* dispatcher_;
+  quic::QuicDispatcher* dispatcher_;
 
   // To call once the write completes.
   WriteCallback callback_;
diff --git a/chromium/net/tools/quic/quic_simple_server_session_helper.cc b/chromium/net/tools/quic/quic_simple_server_session_helper.cc
index 21a7977cd17..1e212eac8c2 100644
--- a/chromium/net/tools/quic/quic_simple_server_session_helper.cc
+++ b/chromium/net/tools/quic/quic_simple_server_session_helper.cc
@@ -6,21 +6,23 @@
 
 namespace net {
 
-QuicSimpleServerSessionHelper::QuicSimpleServerSessionHelper(QuicRandom* random)
+QuicSimpleServerSessionHelper::QuicSimpleServerSessionHelper(
+    quic::QuicRandom* random)
     : random_(random) {}
 
 QuicSimpleServerSessionHelper::~QuicSimpleServerSessionHelper() = default;
 
-QuicConnectionId QuicSimpleServerSessionHelper::GenerateConnectionIdForReject(
-    QuicConnectionId /*connection_id*/) const {
+quic::QuicConnectionId
+QuicSimpleServerSessionHelper::GenerateConnectionIdForReject(
+    quic::QuicConnectionId /*connection_id*/) const {
   return random_->RandUint64();
 }
 
 bool QuicSimpleServerSessionHelper::CanAcceptClientHello(
-    const CryptoHandshakeMessage& message,
-    const QuicSocketAddress& client_address,
-    const QuicSocketAddress& peer_address,
-    const QuicSocketAddress& self_address,
+    const quic::CryptoHandshakeMessage& message,
+    const quic::QuicSocketAddress& client_address,
+    const quic::QuicSocketAddress& peer_address,
+    const quic::QuicSocketAddress& self_address,
     std::string* error_details) const {
   return true;
 }
diff --git a/chromium/net/tools/quic/quic_simple_server_session_helper.h b/chromium/net/tools/quic/quic_simple_server_session_helper.h
index 6ddd5d96dfd..b176e26816c 100644
--- a/chromium/net/tools/quic/quic_simple_server_session_helper.h
+++ b/chromium/net/tools/quic/quic_simple_server_session_helper.h
@@ -12,23 +12,24 @@ namespace net {
 
 // Simple helper for server sessions which generates a new random
 // connection ID for stateless rejects.
-class QuicSimpleServerSessionHelper : public QuicCryptoServerStream::Helper {
+class QuicSimpleServerSessionHelper
+    : public quic::QuicCryptoServerStream::Helper {
  public:
-  explicit QuicSimpleServerSessionHelper(QuicRandom* random);
+  explicit QuicSimpleServerSessionHelper(quic::QuicRandom* random);
 
   ~QuicSimpleServerSessionHelper() override;
 
-  QuicConnectionId GenerateConnectionIdForReject(
-      QuicConnectionId /*connection_id*/) const override;
+  quic::QuicConnectionId GenerateConnectionIdForReject(
+      quic::QuicConnectionId /*connection_id*/) const override;
 
-  bool CanAcceptClientHello(const CryptoHandshakeMessage& message,
-                            const QuicSocketAddress& client_address,
-                            const QuicSocketAddress& peer_address,
-                            const QuicSocketAddress& self_address,
+  bool CanAcceptClientHello(const quic::CryptoHandshakeMessage& message,
+                            const quic::QuicSocketAddress& client_address,
+                            const quic::QuicSocketAddress& peer_address,
+                            const quic::QuicSocketAddress& self_address,
                             std::string* error_details) const override;
 
  private:
-  QuicRandom* random_;  // Unowned.
+  quic::QuicRandom* random_;  // Unowned.
 };
 
 }  // namespace net
diff --git a/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc b/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc
index b2bd7a922a0..f3afa028e77 100644
--- a/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc
+++ b/chromium/net/tools/quic/quic_simple_server_session_helper_test.cc
@@ -10,8 +10,8 @@
 namespace net {
 
 TEST(QuicSimpleCryptoServerStreamHelperTest, GenerateConnectionIdForReject) {
-  test::MockRandom random;
-  QuicSimpleCryptoServerStreamHelper helper(&random);
+  quic::test::MockRandom random;
+  quic::QuicSimpleCryptoServerStreamHelper helper(&random);
 
   EXPECT_EQ(random.RandUint64(), helper.GenerateConnectionIdForReject(42));
 }
diff --git a/chromium/net/tools/quic/quic_simple_server_test.cc b/chromium/net/tools/quic/quic_simple_server_test.cc
index 2b99b65b99a..0b64733af8a 100644
--- a/chromium/net/tools/quic/quic_simple_server_test.cc
+++ b/chromium/net/tools/quic/quic_simple_server_test.cc
@@ -26,36 +26,38 @@ class QuicChromeServerDispatchPacketTest : public QuicTest {
  public:
   QuicChromeServerDispatchPacketTest()
       : crypto_config_("blah",
-                       QuicRandom::GetInstance(),
-                       crypto_test_utils::ProofSourceForTesting(),
-                       TlsServerHandshaker::CreateSslCtx()),
-        version_manager_(AllSupportedVersions()),
-        dispatcher_(
-            config_,
-            &crypto_config_,
-            &version_manager_,
-            std::unique_ptr<MockQuicConnectionHelper>(
-                new net::test::MockQuicConnectionHelper),
-            std::unique_ptr<QuicCryptoServerStream::Helper>(
-                new QuicSimpleServerSessionHelper(QuicRandom::GetInstance())),
-            std::unique_ptr<MockAlarmFactory>(new net::test::MockAlarmFactory),
-            &memory_cache_backend_) {
+                       quic::QuicRandom::GetInstance(),
+                       quic::test::crypto_test_utils::ProofSourceForTesting(),
+                       quic::TlsServerHandshaker::CreateSslCtx()),
+        version_manager_(quic::AllSupportedVersions()),
+        dispatcher_(config_,
+                    &crypto_config_,
+                    &version_manager_,
+                    std::unique_ptr<quic::test::MockQuicConnectionHelper>(
+                        new quic::test::MockQuicConnectionHelper),
+                    std::unique_ptr<quic::QuicCryptoServerStream::Helper>(
+                        new QuicSimpleServerSessionHelper(
+                            quic::QuicRandom::GetInstance())),
+                    std::unique_ptr<quic::test::MockAlarmFactory>(
+                        new quic::test::MockAlarmFactory),
+                    &memory_cache_backend_) {
     dispatcher_.InitializeWithWriter(nullptr);
   }
 
-  void DispatchPacket(const QuicReceivedPacket& packet) {
+  void DispatchPacket(const quic::QuicReceivedPacket& packet) {
     IPEndPoint client_addr, server_addr;
     dispatcher_.ProcessPacket(
-        QuicSocketAddress(QuicSocketAddressImpl(server_addr)),
-        QuicSocketAddress(QuicSocketAddressImpl(client_addr)), packet);
+        quic::QuicSocketAddress(quic::QuicSocketAddressImpl(server_addr)),
+        quic::QuicSocketAddress(quic::QuicSocketAddressImpl(client_addr)),
+        packet);
   }
 
  protected:
-  QuicConfig config_;
-  QuicCryptoServerConfig crypto_config_;
-  QuicVersionManager version_manager_;
-  net::test::MockQuicDispatcher dispatcher_;
-  QuicMemoryCacheBackend memory_cache_backend_;
+  quic::QuicConfig config_;
+  quic::QuicCryptoServerConfig crypto_config_;
+  quic::QuicVersionManager version_manager_;
+  quic::test::MockQuicDispatcher dispatcher_;
+  quic::QuicMemoryCacheBackend memory_cache_backend_;
 };
 
 TEST_F(QuicChromeServerDispatchPacketTest, DispatchPacket) {
@@ -68,9 +70,9 @@ TEST_F(QuicChromeServerDispatchPacketTest, DispatchPacket) {
                                   0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
                                   // private flags
                                   0x00};
-  QuicReceivedPacket encrypted_valid_packet(
+  quic::QuicReceivedPacket encrypted_valid_packet(
       reinterpret_cast<char*>(valid_packet), arraysize(valid_packet),
-      QuicTime::Zero(), false);
+      quic::QuicTime::Zero(), false);
 
   EXPECT_CALL(dispatcher_, ProcessPacket(_, _, _)).Times(1);
   DispatchPacket(encrypted_valid_packet);