Pass OnDatagramProcessed() calls into the network service.

Bug: 1150350
Change-Id: I735ab6e7379e4a307e0770faaa77e9303e437485
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2556449
Commit-Queue: Victor Vasiliev <vasilvv@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Cr-Commit-Position: refs/heads/master@{#830612}

net/quic/quic_transport_client.cc

@@ -286,7 +286,7 @@ void QuicTransportClient::CreateConnection() {
   session_ = std::make_unique<quic::QuicTransportClientSession>(
       connection_.get(), this, InitializeQuicConfig(*quic_context_->params()),
       supported_versions_, url_, &crypto_config_, origin_, this,
-      /*datagram_observer=*/nullptr);
+      std::make_unique<DatagramObserverProxy>(this));
 
   packet_reader_ = std::make_unique<QuicChromiumPacketReader>(
       socket_.get(), quic_context_->clock(), this, kQuicYieldAfterPacketsRead,
@@ -481,4 +481,11 @@ void QuicTransportClient::OnConnectionClosed(
   TransitionToState(FAILED);
 }
 
+void QuicTransportClient::DatagramObserverProxy::OnDatagramProcessed(
+    absl::optional<quic::MessageStatus> status) {
+  client_->visitor_->OnDatagramProcessed(
+      status.has_value() ? base::Optional<quic::MessageStatus>(*status)
+                         : base::Optional<quic::MessageStatus>());
+}
+
 }  // namespace net

net/quic/quic_transport_client.h

@@ -81,6 +81,8 @@ class NET_EXPORT QuicTransportClient
     virtual void OnDatagramReceived(base::StringPiece datagram) = 0;
     virtual void OnCanCreateNewOutgoingBidirectionalStream() = 0;
     virtual void OnCanCreateNewOutgoingUnidirectionalStream() = 0;
+    virtual void OnDatagramProcessed(
+        base::Optional<quic::MessageStatus> status) = 0;
   };
 
   struct NET_EXPORT Parameters {
@@ -176,6 +178,17 @@ class NET_EXPORT QuicTransportClient
     CONNECT_STATE_NUM_STATES,
   };
 
+  class DatagramObserverProxy : public quic::QuicDatagramQueue::Observer {
+   public:
+    explicit DatagramObserverProxy(QuicTransportClient* client)
+        : client_(client) {}
+    void OnDatagramProcessed(
+        absl::optional<quic::MessageStatus> status) override;
+
+   private:
+    QuicTransportClient* client_;
+  };
+
   // DoLoop processing the Connect() call.
   void DoLoop(int rv);
   // Verifies the basic preconditions for setting up the connection.

net/quic/quic_transport_end_to_end_test.cc

@@ -30,6 +30,9 @@ namespace net {
 namespace test {
 namespace {
 
+using ::quic::test::MemSliceFromString;
+using ::testing::_;
+
 class MockVisitor : public QuicTransportClient::Visitor {
  public:
   MOCK_METHOD0(OnConnected, void());
@@ -42,6 +45,7 @@ class MockVisitor : public QuicTransportClient::Visitor {
   MOCK_METHOD1(OnDatagramReceived, void(base::StringPiece));
   MOCK_METHOD0(OnCanCreateNewOutgoingBidirectionalStream, void());
   MOCK_METHOD0(OnCanCreateNewOutgoingUnidirectionalStream, void());
+  MOCK_METHOD1(OnDatagramProcessed, void(base::Optional<quic::MessageStatus>));
 };
 
 // A clock that only mocks out WallNow(), but uses real Now() and
@@ -178,6 +182,22 @@ TEST_F(QuicTransportEndToEndTest, Connect) {
   EXPECT_TRUE(client_->session()->IsSessionReady());
 }
 
+TEST_F(QuicTransportEndToEndTest, SendDatagram) {
+  StartServer();
+  client_ = std::make_unique<QuicTransportClient>(
+      GetURL("/discard"), origin_, &visitor_, isolation_key_, context_.get(),
+      QuicTransportClient::Parameters());
+  client_->Connect();
+  EXPECT_CALL(visitor_, OnConnected()).WillOnce(StopRunning());
+  Run();
+  ASSERT_TRUE(client_->session() != nullptr);
+  EXPECT_TRUE(client_->session()->IsSessionReady());
+
+  EXPECT_CALL(visitor_, OnDatagramProcessed(_)).Times(1);
+  client_->session()->datagram_queue()->SendOrQueueDatagram(
+      MemSliceFromString("test"));
+}
+
 TEST_F(QuicTransportEndToEndTest, EchoUnidirectionalStream) {
   StartServer();
   client_ = std::make_unique<QuicTransportClient>(
@@ -297,6 +317,11 @@ TEST_F(QuicTransportEndToEndTest, OldVersion) {
       GetStringValueFromParams(events[0], "version"),
       quic::ParsedQuicVersionToString(
           QuicTransportClient::QuicVersionsForWebTransportOriginTrial()[1]));
+
+  // Ensure the observer is set correctly after the version negotiation process.
+  EXPECT_CALL(visitor_, OnDatagramProcessed(_)).Times(1);
+  client_->session()->datagram_queue()->SendOrQueueDatagram(
+      MemSliceFromString("test"));
 }
 
 }  // namespace

services/network/quic_transport.cc

@@ -586,6 +586,11 @@ void QuicTransport::OnCanCreateNewOutgoingUnidirectionalStream() {
   // TODO(yhirano): Implement this.
 }
 
+void QuicTransport::OnDatagramProcessed(
+    base::Optional<quic::MessageStatus> status) {
+  // TODO(yhirano): Implement this.
+}
+
 void QuicTransport::TearDown() {
   torn_down_ = true;
   receiver_.reset();

services/network/quic_transport.h

@@ -77,6 +77,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) QuicTransport final
   void OnDatagramReceived(base::StringPiece datagram) override;
   void OnCanCreateNewOutgoingBidirectionalStream() override;
   void OnCanCreateNewOutgoingUnidirectionalStream() override;
+  void OnDatagramProcessed(base::Optional<quic::MessageStatus> status) override;
 
   bool torn_down() const { return torn_down_; }