Implement QuicTransport.SendDatagram

Bug: 1011392
Change-Id: Iff4e516388bd98f6247f7fa36a26be3d12e11104
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1981240
Commit-Queue: Yutaka Hirano <yhirano@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#727357}

services/network/public/mojom/quic_transport.mojom

@@ -4,10 +4,14 @@
 
 module network.mojom;
 
+import "mojo/public/mojom/base/read_only_buffer.mojom";
 import "url/mojom/url.mojom";
 
 // A mojo interface for https://wicg.github.io/web-transport/#quic-transport.
 interface QuicTransport {
+  // A datagram message is sent from the client. The response message represents
+  // whether the peer has sent or discarded the datagram.
+  SendDatagram(mojo_base.mojom.ReadOnlyBuffer data) => (bool result);
 };
 
 // A mojo interface for the client of QuicTransport.

services/network/quic_transport.cc

@@ -4,6 +4,12 @@
 
 #include "services/network/quic_transport.h"
 
+#include "net/base/io_buffer.h"
+#include "net/quic/platform/impl/quic_mem_slice_impl.h"
+#include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_span.h"
 #include "services/network/network_context.h"
 #include "services/network/public/mojom/quic_transport.mojom.h"
 
@@ -32,6 +38,17 @@ QuicTransport::QuicTransport(
 
 QuicTransport::~QuicTransport() = default;
 
+void QuicTransport::SendDatagram(base::span<const uint8_t> data,
+                                 base::OnceCallback<void(bool)> callback) {
+  auto buffer = base::MakeRefCounted<net::IOBuffer>(data.size());
+  memcpy(buffer->data(), data.data(), data.size());
+  quic::QuicMemSlice slice(
+      quic::QuicMemSliceImpl(std::move(buffer), data.size()));
+  const quic::MessageResult result =
+      transport_->session()->SendMessage(quic::QuicMemSliceSpan(&slice));
+  std::move(callback).Run(result.status == quic::MESSAGE_STATUS_SUCCESS);
+}
+
 void QuicTransport::OnConnected() {
   DCHECK(handshake_client_);
 

services/network/quic_transport.h

@@ -41,6 +41,10 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) QuicTransport final
                     handshake_client);
   ~QuicTransport() override;
 
+  // mojom::QuicTransport implementation:
+  void SendDatagram(base::span<const uint8_t> data,
+                    base::OnceCallback<void(bool)> callback) override;
+
   // net::QuicTransportClient::Visitor implementation:
   void OnConnected() override;
   void OnConnectionFailed() override;

services/network/quic_transport_unittest.cc

@@ -4,6 +4,9 @@
 
 #include "services/network/quic_transport.h"
 
+#include <vector>
+
+#include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
@@ -183,5 +186,62 @@ TEST_F(QuicTransportTest, ConnectWithError) {
   EXPECT_FALSE(test_handshake_client.has_seen_mojo_connection_error());
 }
 
+TEST_F(QuicTransportTest, SendDatagram) {
+  base::RunLoop run_loop_for_handshake;
+  mojo::PendingRemote<mojom::QuicTransportHandshakeClient> handshake_client;
+  TestHandshakeClient test_handshake_client(
+      handshake_client.InitWithNewPipeAndPassReceiver(),
+      run_loop_for_handshake.QuitClosure());
+
+  auto transport = CreateQuicTransport(
+      GetURL("/discard"), url::Origin::Create(GURL("https://example.org/")),
+      std::move(handshake_client));
+
+  run_loop_for_handshake.Run();
+
+  base::RunLoop run_loop_for_datagram;
+  bool result;
+  uint8_t data[] = {1, 2, 3, 4, 5};
+  mojo::Remote<mojom::QuicTransport> transport_remote(
+      test_handshake_client.PassTransport());
+  transport_remote->SendDatagram(base::make_span(data),
+                                 base::BindLambdaForTesting([&](bool r) {
+                                   result = r;
+                                   run_loop_for_datagram.Quit();
+                                 }));
+  run_loop_for_datagram.Run();
+  EXPECT_TRUE(result);
+}
+
+TEST_F(QuicTransportTest, SendToolargeDatagram) {
+  base::RunLoop run_loop_for_handshake;
+  mojo::PendingRemote<mojom::QuicTransportHandshakeClient> handshake_client;
+  TestHandshakeClient test_handshake_client(
+      handshake_client.InitWithNewPipeAndPassReceiver(),
+      run_loop_for_handshake.QuitClosure());
+
+  auto transport = CreateQuicTransport(
+      GetURL("/discard"), url::Origin::Create(GURL("https://example.org/")),
+      std::move(handshake_client));
+
+  run_loop_for_handshake.Run();
+
+  base::RunLoop run_loop_for_datagram;
+  bool result;
+  // The actual upper limit for one datagram is platform specific, but
+  // 786kb should be large enough for any platform.
+  std::vector<uint8_t> data(786 * 1024, 99);
+  mojo::Remote<mojom::QuicTransport> transport_remote(
+      test_handshake_client.PassTransport());
+
+  transport_remote->SendDatagram(base::make_span(data),
+                                 base::BindLambdaForTesting([&](bool r) {
+                                   result = r;
+                                   run_loop_for_datagram.Quit();
+                                 }));
+  run_loop_for_datagram.Run();
+  EXPECT_FALSE(result);
+}
+
 }  // namespace
 }  // namespace network

third_party/blink/renderer/modules/webtransport/quic_transport_test.cc

@@ -68,7 +68,8 @@ class MockQuicTransport final : public network::mojom::blink::QuicTransport {
                         pending_receiver)
       : receiver_(this, std::move(pending_receiver)) {}
 
-  // TODO(ricea): Add methods when there are some.
+  void SendDatagram(base::span<const uint8_t> data,
+                    base::OnceCallback<void(bool)> callback) override {}
 
  private:
   mojo::Receiver<network::mojom::blink::QuicTransport> receiver_;