Replace quic_restart_flag_quic_big_endian_connection_id with quic_restart_flag_quic_big_endian_conn…

net/quic/test_tools/simulator/quic_endpoint_test.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/test_tools/simulator/quic_endpoint.h"
 
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simulator/simulator.h"
 #include "net/quic/test_tools/simulator/switch.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::Return;
+using net::test::GetPeerInMemoryConnectionId;
 
 namespace net {
 namespace simulator {
 
 const QuicBandwidth kDefaultBandwidth =
     QuicBandwidth::FromKBitsPerSecond(10 * 1000);
 const QuicTime::Delta kDefaultPropagationDelay =
     QuicTime::Delta::FromMilliseconds(20);
 const QuicByteCount kDefaultBdp = kDefaultBandwidth * kDefaultPropagationDelay;
 
@@ skipping 12 matching lines @@
     return QuicMakeUnique<SymmetricLink>(a, b, kDefaultBandwidth,
                                          kDefaultPropagationDelay);
   }
 };
 
 // Test transmission from one host to another.
 TEST_F(QuicEndpointTest, OneWayTransmission) {
   QuicEndpoint endpoint_a(&simulator_, "Endpoint A", "Endpoint B",
                           Perspective::IS_CLIENT, 42);
   QuicEndpoint endpoint_b(&simulator_, "Endpoint B", "Endpoint A",
-                          Perspective::IS_SERVER, 42);
+                          Perspective::IS_SERVER,
+                          GetPeerInMemoryConnectionId(42));
   auto link_a = Link(&endpoint_a, switch_.port(1));
   auto link_b = Link(&endpoint_b, switch_.port(2));
 
   // First transmit a small, packet-size chunk of data.
   endpoint_a.AddBytesToTransfer(600);
   QuicTime end_time =
       simulator_.GetClock()->Now() + QuicTime::Delta::FromMilliseconds(1000);
   simulator_.RunUntil(
       [this, end_time]() { return simulator_.GetClock()->Now() >= end_time; });
 
@@ skipping 14 matching lines @@
   EXPECT_EQ(0u, endpoint_a.write_blocked_count());
   EXPECT_FALSE(endpoint_a.wrong_data_received());
   EXPECT_FALSE(endpoint_b.wrong_data_received());
 }
 
 // Test the situation in which the writer becomes write-blocked.
 TEST_F(QuicEndpointTest, WriteBlocked) {
   QuicEndpoint endpoint_a(&simulator_, "Endpoint A", "Endpoint B",
                           Perspective::IS_CLIENT, 42);
   QuicEndpoint endpoint_b(&simulator_, "Endpoint B", "Endpoint A",
-                          Perspective::IS_SERVER, 42);
+                          Perspective::IS_SERVER,
+                          GetPeerInMemoryConnectionId(42));
   auto link_a = Link(&endpoint_a, switch_.port(1));
   auto link_b = Link(&endpoint_b, switch_.port(2));
 
   // Will be owned by the sent packet manager.
   auto* sender = new NiceMock<test::MockSendAlgorithm>();
   EXPECT_CALL(*sender, TimeUntilSend(_, _))
       .WillRepeatedly(Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*sender, PacingRate(_))
       .WillRepeatedly(Return(10 * kDefaultBandwidth));
   EXPECT_CALL(*sender, BandwidthEstimate())
@@ skipping 19 matching lines @@
   EXPECT_FALSE(endpoint_a.wrong_data_received());
   EXPECT_FALSE(endpoint_b.wrong_data_received());
 }
 
 // Test transmission of 1 MiB of data between two hosts simultaneously in both
 // directions.
 TEST_F(QuicEndpointTest, TwoWayTransmission) {
   QuicEndpoint endpoint_a(&simulator_, "Endpoint A", "Endpoint B",
                           Perspective::IS_CLIENT, 42);
   QuicEndpoint endpoint_b(&simulator_, "Endpoint B", "Endpoint A",
-                          Perspective::IS_SERVER, 42);
+                          Perspective::IS_SERVER,
+                          GetPeerInMemoryConnectionId(42));
   auto link_a = Link(&endpoint_a, switch_.port(1));
   auto link_b = Link(&endpoint_b, switch_.port(2));
 
   endpoint_a.AddBytesToTransfer(1024 * 1024);
   endpoint_b.AddBytesToTransfer(1024 * 1024);
   QuicTime end_time =
       simulator_.GetClock()->Now() + QuicTime::Delta::FromSeconds(5);
   simulator_.RunUntil(
       [this, end_time]() { return simulator_.GetClock()->Now() >= end_time; });
 
   EXPECT_EQ(1024u * 1024u, endpoint_a.bytes_transferred());
   EXPECT_EQ(1024u * 1024u, endpoint_b.bytes_transferred());
   EXPECT_EQ(1024u * 1024u, endpoint_a.bytes_received());
   EXPECT_EQ(1024u * 1024u, endpoint_b.bytes_received());
   EXPECT_FALSE(endpoint_a.wrong_data_received());
   EXPECT_FALSE(endpoint_b.wrong_data_received());
 }
 
 // Simulate three hosts trying to send data to a fourth one simultaneously.
 TEST_F(QuicEndpointTest, Competition) {
   simulator_.set_enable_random_delays(true);
 
   auto endpoint_a = QuicMakeUnique<QuicEndpoint>(
       &simulator_, "Endpoint A", "Endpoint D (A)", Perspective::IS_CLIENT, 42);
   auto endpoint_b = QuicMakeUnique<QuicEndpoint>(
       &simulator_, "Endpoint B", "Endpoint D (B)", Perspective::IS_CLIENT, 43);
   auto endpoint_c = QuicMakeUnique<QuicEndpoint>(
       &simulator_, "Endpoint C", "Endpoint D (C)", Perspective::IS_CLIENT, 44);
   auto endpoint_d_a = QuicMakeUnique<QuicEndpoint>(
-      &simulator_, "Endpoint D (A)", "Endpoint A", Perspective::IS_SERVER, 42);
+      &simulator_, "Endpoint D (A)", "Endpoint A", Perspective::IS_SERVER,
+      GetPeerInMemoryConnectionId(42));
   auto endpoint_d_b = QuicMakeUnique<QuicEndpoint>(
-      &simulator_, "Endpoint D (B)", "Endpoint B", Perspective::IS_SERVER, 43);
+      &simulator_, "Endpoint D (B)", "Endpoint B", Perspective::IS_SERVER,
+      GetPeerInMemoryConnectionId(43));
   auto endpoint_d_c = QuicMakeUnique<QuicEndpoint>(
-      &simulator_, "Endpoint D (C)", "Endpoint C", Perspective::IS_SERVER, 44);
+      &simulator_, "Endpoint D (C)", "Endpoint C", Perspective::IS_SERVER,
+      GetPeerInMemoryConnectionId(44));
   QuicEndpointMultiplexer endpoint_d(
       "Endpoint D",
       {endpoint_d_a.get(), endpoint_d_b.get(), endpoint_d_c.get()});
 
   auto link_a = Link(endpoint_a.get(), switch_.port(1));
   auto link_b = Link(endpoint_b.get(), switch_.port(2));
   auto link_c = Link(endpoint_c.get(), switch_.port(3));
   auto link_d = Link(&endpoint_d, switch_.port(4));
 
   endpoint_a->AddBytesToTransfer(2 * 1024 * 1024);
@@ skipping 11 matching lines @@
   }
   for (QuicEndpoint* endpoint :
        {endpoint_d_a.get(), endpoint_d_b.get(), endpoint_d_c.get()}) {
     EXPECT_EQ(2u * 1024u * 1024u, endpoint->bytes_received());
     EXPECT_FALSE(endpoint->wrong_data_received());
   }
 }
 
 }  // namespace simulator
 }  // namespace net