You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by ma...@apache.org on 2018/09/03 02:42:36 UTC

[trafficserver] branch quic-latest updated: Rename create_server_protected_packet to create_protected_packet

This is an automated email from the ASF dual-hosted git repository.

masaori pushed a commit to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git


The following commit(s) were added to refs/heads/quic-latest by this push:
     new d74d636  Rename create_server_protected_packet to create_protected_packet
d74d636 is described below

commit d74d6369a13f3154523cb722adc6a5bfe9bbe2f7
Author: Masaori Koshiba <ma...@apache.org>
AuthorDate: Mon Sep 3 11:42:16 2018 +0900

    Rename create_server_protected_packet to create_protected_packet
---
 iocore/net/QUICNetVConnection.cc              |  6 +--
 iocore/net/quic/QUICPacket.cc                 |  4 +-
 iocore/net/quic/QUICPacket.h                  |  4 +-
 iocore/net/quic/test/test_QUICFrame.cc        |  4 +-
 iocore/net/quic/test/test_QUICLossDetector.cc | 54 +++++++++++++--------------
 5 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc
index 83a3cb0..ab150be 100644
--- a/iocore/net/QUICNetVConnection.cc
+++ b/iocore/net/QUICNetVConnection.cc
@@ -1434,9 +1434,9 @@ QUICNetVConnection::_build_packet(ats_unique_buf buf, size_t len, bool retransmi
     break;
   }
   case QUICPacketType::PROTECTED: {
-    packet = this->_packet_factory.create_server_protected_packet(this->_peer_quic_connection_id,
-                                                                  this->largest_acked_packet_number(QUICEncryptionLevel::ONE_RTT),
-                                                                  std::move(buf), len, retransmittable);
+    packet = this->_packet_factory.create_protected_packet(this->_peer_quic_connection_id,
+                                                           this->largest_acked_packet_number(QUICEncryptionLevel::ONE_RTT),
+                                                           std::move(buf), len, retransmittable);
     break;
   }
   default:
diff --git a/iocore/net/quic/QUICPacket.cc b/iocore/net/quic/QUICPacket.cc
index ebd9f68..bbda5c6 100644
--- a/iocore/net/quic/QUICPacket.cc
+++ b/iocore/net/quic/QUICPacket.cc
@@ -1150,8 +1150,8 @@ QUICPacketFactory::create_handshake_packet(QUICConnectionId destination_cid, QUI
 }
 
 QUICPacketUPtr
-QUICPacketFactory::create_server_protected_packet(QUICConnectionId connection_id, QUICPacketNumber base_packet_number,
-                                                  ats_unique_buf payload, size_t len, bool retransmittable)
+QUICPacketFactory::create_protected_packet(QUICConnectionId connection_id, QUICPacketNumber base_packet_number,
+                                           ats_unique_buf payload, size_t len, bool retransmittable)
 {
   int index           = QUICTypeUtil::pn_space_index(QUICEncryptionLevel::ONE_RTT);
   QUICPacketNumber pn = this->_packet_number_generator[index].next();
diff --git a/iocore/net/quic/QUICPacket.h b/iocore/net/quic/QUICPacket.h
index 4760bf2..d4fb0fc 100644
--- a/iocore/net/quic/QUICPacket.h
+++ b/iocore/net/quic/QUICPacket.h
@@ -398,8 +398,8 @@ public:
   QUICPacketUPtr create_handshake_packet(QUICConnectionId destination_cid, QUICConnectionId source_cid,
                                          QUICPacketNumber base_packet_number, ats_unique_buf payload, size_t len,
                                          bool retransmittable);
-  QUICPacketUPtr create_server_protected_packet(QUICConnectionId connection_id, QUICPacketNumber base_packet_number,
-                                                ats_unique_buf payload, size_t len, bool retransmittable);
+  QUICPacketUPtr create_protected_packet(QUICConnectionId connection_id, QUICPacketNumber base_packet_number,
+                                         ats_unique_buf payload, size_t len, bool retransmittable);
   void set_version(QUICVersion negotiated_version);
   void set_hs_protocol(QUICHandshakeProtocol *hs_protocol);
   bool is_ready_to_create_protected_packet();
diff --git a/iocore/net/quic/test/test_QUICFrame.cc b/iocore/net/quic/test/test_QUICFrame.cc
index 711d30f..d7dc8f9 100644
--- a/iocore/net/quic/test/test_QUICFrame.cc
+++ b/iocore/net/quic/test/test_QUICFrame.cc
@@ -1270,8 +1270,8 @@ TEST_CASE("Retransmit", "[quic][frame][retransmit]")
   QUICPacketFactory factory;
   MockQUICHandshakeProtocol hs_protocol;
   factory.set_hs_protocol(&hs_protocol);
-  QUICPacketUPtr packet = factory.create_server_protected_packet({reinterpret_cast<const uint8_t *>("\x01\x02\x03\x04"), 4}, 0,
-                                                                 {nullptr, [](void *p) { ats_free(p); }}, 0, true);
+  QUICPacketUPtr packet = factory.create_protected_packet({reinterpret_cast<const uint8_t *>("\x01\x02\x03\x04"), 4}, 0,
+                                                          {nullptr, [](void *p) { ats_free(p); }}, 0, true);
   SECTION("STREAM frame split")
   {
     size_t len;
diff --git a/iocore/net/quic/test/test_QUICLossDetector.cc b/iocore/net/quic/test/test_QUICLossDetector.cc
index a414872..8ba4f1d 100644
--- a/iocore/net/quic/test/test_QUICLossDetector.cc
+++ b/iocore/net/quic/test/test_QUICLossDetector.cc
@@ -84,33 +84,33 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]")
     CHECK(tx->retransmitted.size() == 0);
 
     // Send packet (1) to (7)
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet1 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet2 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet3 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet4 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet5 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet6 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet7 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet8 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
-    payload                = ats_unique_malloc(16);
-    QUICPacketUPtr packet9 = pf.create_server_protected_packet(connection_id, detector.largest_acked_packet_number(),
-                                                               std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet1 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet2 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet3 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet4 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet5 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet6 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet7 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet8 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
+    payload = ats_unique_malloc(16);
+    QUICPacketUPtr packet9 =
+      pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), payload_len, true);
 
     QUICPacketNumber pn1 = packet1->packet_number();
     QUICPacketNumber pn2 = packet2->packet_number();