Support the use of MESSAGE/DATAGRAM frames in QBONE.

Received MESSAGE frames are always processed.  By default, sending MESSAGE frames is disabled, but can be enabled via flags.

gfe-relnote: n/a (QBONE-only change)
PiperOrigin-RevId: 267679822
Change-Id: I1263435cc16c17bd6ff8efa82d78b11c761164b2

quic/qbone/qbone_session_base.cc

diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index 23b29d2..01917d2 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -81,6 +81,11 @@
   QuicSession::OnStreamFrame(frame);
 }
 
+void QboneSessionBase::OnMessageReceived(QuicStringPiece message) {
+  ++num_message_packets_;
+  ProcessPacketFromPeer(message);
+}
+
 QuicStream* QboneSessionBase::CreateIncomingStream(QuicStreamId id) {
   return ActivateDataStream(CreateDataStream(id));
 }
@@ -122,6 +127,23 @@
 }
 
 void QboneSessionBase::SendPacketToPeer(QuicStringPiece packet) {
+  if (crypto_stream_ == nullptr) {
+    QUIC_BUG << "Attempting to send packet before encryption established";
+    return;
+  }
+
+  if (send_packets_as_messages_) {
+    QuicMemSlice slice(connection()->helper()->GetStreamSendBufferAllocator(),
+                       packet.size());
+    memcpy(const_cast<char*>(slice.data()), packet.data(), packet.size());
+    if (SendMessage(QuicMemSliceSpan(&slice)).status ==
+        MESSAGE_STATUS_SUCCESS) {
+      return;
+    }
+    // If SendMessage() fails for any reason, fall back to ephemeral streams.
+    num_fallback_to_stream_++;
+  }
+
   // Qbone streams are ephemeral.
   QuicStream* stream = CreateOutgoingStream();
   if (!stream) {
@@ -142,6 +164,14 @@
   return num_streamed_packets_;
 }
 
+uint64_t QboneSessionBase::GetNumMessagePackets() const {
+  return num_message_packets_;
+}
+
+uint64_t QboneSessionBase::GetNumFallbackToStream() const {
+  return num_fallback_to_stream_;
+}
+
 void QboneSessionBase::set_writer(QbonePacketWriter* writer) {
   writer_ = writer;
   testing::testvalue::Adjust("quic_QbonePacketWriter", &writer_);

quic/qbone/qbone_session_base.h

diff --git a/quic/qbone/qbone_session_base.h b/quic/qbone/qbone_session_base.h
index 5bfc9be..41afc6b 100644
--- a/quic/qbone/qbone_session_base.h
+++ b/quic/qbone/qbone_session_base.h
@@ -35,6 +35,8 @@
   void CloseStream(QuicStreamId stream_id) override;
   // This will check if the packet is wholly contained.
   void OnStreamFrame(const QuicStreamFrame& frame) override;
+  // Called whenever a MESSAGE frame is received.
+  void OnMessageReceived(QuicStringPiece message) override;
 
   virtual void ProcessPacketFromNetwork(QuicStringPiece packet) = 0;
   virtual void ProcessPacketFromPeer(QuicStringPiece packet) = 0;
@@ -48,7 +50,18 @@
   // multiple packets, requiring the creation of a QboneReadOnlyStream.
   uint64_t GetNumStreamedPackets() const;
 
+  // Returns the number of QBONE network packets that were received using QUIC
+  // MESSAGE frame.
+  uint64_t GetNumMessagePackets() const;
+
+  // Returns the number of times sending a MESSAGE frame failed, and the session
+  // used an ephemeral stream instead.
+  uint64_t GetNumFallbackToStream() const;
+
   void set_writer(QbonePacketWriter* writer);
+  void set_send_packets_as_messages(bool send_packets_as_messages) {
+    send_packets_as_messages_ = send_packets_as_messages;
+  }
 
  protected:
   virtual std::unique_ptr<QuicCryptoStream> CreateCryptoStream() = 0;
@@ -79,12 +92,24 @@
 
   QbonePacketWriter* writer_;
 
+  // If true, MESSAGE frames are used for short datagrams.  If false, ephemeral
+  // streams are used instead.  Note that receiving MESSAGE frames is always
+  // supported.
+  bool send_packets_as_messages_ = false;
+
  private:
   // Used for the crypto handshake.
   std::unique_ptr<QuicCryptoStream> crypto_stream_;
 
+  // Statistics for the packets received by the session.
   uint64_t num_ephemeral_packets_ = 0;
+  uint64_t num_message_packets_ = 0;
   uint64_t num_streamed_packets_ = 0;
+
+  // Number of times the connection has failed to send packets as MESSAGE frame
+  // and used streams as a fallback.
+  uint64_t num_fallback_to_stream_ = 0;
+
   QuicUnorderedSet<QuicStreamId> reliable_streams_;
 };
 

quic/qbone/qbone_session_test.cc

diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index 016b2f3..b58f39e 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -354,7 +354,7 @@
 
   // Test handshake establishment and sending/receiving of data for two
   // directions.
-  void TestStreamConnection() {
+  void TestStreamConnection(bool use_messages) {
     ASSERT_TRUE(server_peer_->IsCryptoHandshakeConfirmed());
     ASSERT_TRUE(client_peer_->IsCryptoHandshakeConfirmed());
     ASSERT_TRUE(server_peer_->IsEncryptionEstablished());
@@ -406,10 +406,19 @@
     EXPECT_THAT(server_writer_->data(), Contains(TestPacketOut(long_data)));
     EXPECT_THAT(client_peer_->GetNumSentClientHellos(), Eq(2));
     EXPECT_THAT(client_peer_->GetNumReceivedServerConfigUpdates(), Eq(0));
-    EXPECT_THAT(client_peer_->GetNumEphemeralPackets(), Eq(2));
     EXPECT_THAT(client_peer_->GetNumStreamedPackets(), Eq(1));
-    EXPECT_THAT(server_peer_->GetNumEphemeralPackets(), Eq(2));
     EXPECT_THAT(server_peer_->GetNumStreamedPackets(), Eq(1));
+    if (use_messages) {
+      EXPECT_THAT(client_peer_->GetNumEphemeralPackets(), Eq(0));
+      EXPECT_THAT(server_peer_->GetNumEphemeralPackets(), Eq(0));
+      EXPECT_THAT(client_peer_->GetNumMessagePackets(), Eq(2));
+      EXPECT_THAT(server_peer_->GetNumMessagePackets(), Eq(2));
+    } else {
+      EXPECT_THAT(client_peer_->GetNumEphemeralPackets(), Eq(2));
+      EXPECT_THAT(server_peer_->GetNumEphemeralPackets(), Eq(2));
+      EXPECT_THAT(client_peer_->GetNumMessagePackets(), Eq(0));
+      EXPECT_THAT(server_peer_->GetNumMessagePackets(), Eq(0));
+    }
 
     // All streams are ephemeral and should be gone.
     EXPECT_EQ(0u, server_peer_->GetNumActiveStreams());
@@ -449,8 +458,18 @@
 
 TEST_F(QboneSessionTest, StreamConnection) {
   CreateClientAndServerSessions();
+  client_peer_->set_send_packets_as_messages(false);
+  server_peer_->set_send_packets_as_messages(false);
   StartHandshake();
-  TestStreamConnection();
+  TestStreamConnection(false);
+}
+
+TEST_F(QboneSessionTest, Messages) {
+  CreateClientAndServerSessions();
+  client_peer_->set_send_packets_as_messages(true);
+  server_peer_->set_send_packets_as_messages(true);
+  StartHandshake();
+  TestStreamConnection(true);
 }
 
 TEST_F(QboneSessionTest, ClientRejection) {
@@ -481,9 +500,9 @@
 TEST_F(QboneSessionTest, CannotCreateDataStreamBeforeHandshake) {
   CreateClientAndServerSessions();
   EXPECT_QUIC_BUG(client_peer_->ProcessPacketFromNetwork(TestPacketIn("hello")),
-                  "Failed to create an outgoing QBONE stream");
+                  "Attempting to send packet before encryption established");
   EXPECT_QUIC_BUG(server_peer_->ProcessPacketFromNetwork(TestPacketIn("hello")),
-                  "Failed to create an outgoing QBONE stream");
+                  "Attempting to send packet before encryption established");
   EXPECT_EQ(0u, server_peer_->GetNumActiveStreams());
   EXPECT_EQ(0u, client_peer_->GetNumActiveStreams());
 }