Exposes P2PQuicTransport level stats.

Takes stats from quic::QuicConnection and exposes them in a
P2PQuicTransportStats struct. These stats will be exposed for the
JavaScript API.

Bug: 874296
Change-Id: Iacfe362346d828d319368af23c49fa54862b7057
Reviewed-on: https://chromium-review.googlesource.com/c/1423670
Commit-Queue: Seth Hampson <shampson@chromium.org>
Auto-Submit: Seth Hampson <shampson@chromium.org>
Reviewed-by: Steve Anton <steveanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#624966}

third_party/blink/renderer/modules/peerconnection/BUILD.gn

@@ -29,6 +29,8 @@ blink_modules_sources("peerconnection") {
     "adapters/p2p_quic_transport_factory_impl.h",
     "adapters/p2p_quic_transport_impl.cc",
     "adapters/p2p_quic_transport_impl.h",
+    "adapters/p2p_quic_transport_stats.cc",
+    "adapters/p2p_quic_transport_stats.h",
     "adapters/quic_packet_transport_adapter.cc",
     "adapters/quic_packet_transport_adapter.h",
     "adapters/quic_stream_host.cc",

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport.h

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_TRANSPORT_H_
 
 #include "base/logging.h"
+#include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_stats.h"
 #include "third_party/webrtc/rtc_base/ssl_fingerprint.h"
 
 namespace blink {
@@ -90,6 +91,9 @@ class P2PQuicTransport {
   // - The P2PQuicTransport is deleted.
   virtual P2PQuicStream* CreateStream() = 0;
 
+  // Gets the associated stats. These are QUIC connection level stats.
+  virtual P2PQuicTransportStats GetStats() const = 0;
+
   // TODO(https://crbug.com/874296): Consider adding a getter for the
   // local fingerprints of the certificate(s) set in the constructor.
 };

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.cc

@@ -373,8 +373,15 @@ P2PQuicStreamImpl* P2PQuicTransportImpl::CreateStream() {
   return CreateOutgoingBidirectionalStream();
 }
 
+P2PQuicTransportStats P2PQuicTransportImpl::GetStats() const {
+  return P2PQuicTransportStats(connection_->GetStats(),
+                               num_outgoing_streams_created_,
+                               num_incoming_streams_created_);
+}
+
 P2PQuicStreamImpl* P2PQuicTransportImpl::CreateOutgoingBidirectionalStream() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  num_outgoing_streams_created_++;
   P2PQuicStreamImpl* stream =
       CreateStreamInternal(GetNextOutgoingBidirectionalStreamId());
   ActivateStream(std::unique_ptr<P2PQuicStreamImpl>(stream));
@@ -384,6 +391,7 @@ P2PQuicStreamImpl* P2PQuicTransportImpl::CreateOutgoingBidirectionalStream() {
 P2PQuicStreamImpl* P2PQuicTransportImpl::CreateIncomingStream(
     quic::QuicStreamId id) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  num_incoming_streams_created_++;
   P2PQuicStreamImpl* stream = CreateStreamInternal(id);
   ActivateStream(std::unique_ptr<P2PQuicStreamImpl>(stream));
   delegate_->OnStream(stream);
@@ -393,6 +401,7 @@ P2PQuicStreamImpl* P2PQuicTransportImpl::CreateIncomingStream(
 P2PQuicStreamImpl* P2PQuicTransportImpl::CreateIncomingStream(
     quic::PendingStream pending) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  num_incoming_streams_created_++;
   P2PQuicStreamImpl* stream = CreateStreamInternal(std::move(pending));
   ActivateStream(std::unique_ptr<P2PQuicStreamImpl>(stream));
   delegate_->OnStream(stream);

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.h

@@ -81,6 +81,7 @@ class MODULES_EXPORT P2PQuicTransportImpl final
   void Start(StartConfig config) override;
   // Creates an outgoing stream that is owned by the quic::QuicSession.
   P2PQuicStreamImpl* CreateStream() override;
+  P2PQuicTransportStats GetStats() const override;
 
   // P2PQuicPacketTransport::Delegate override.
   void OnPacketDataReceived(const char* data, size_t data_len) override;
@@ -189,6 +190,10 @@ class MODULES_EXPORT P2PQuicTransportImpl final
   // Determines the size of the write buffer when P2PQuicStreams.
   uint32_t stream_write_buffer_size_;
 
+  // For stats:
+  uint32_t num_outgoing_streams_created_ = 0;
+  uint32_t num_incoming_streams_created_ = 0;
+
   THREAD_CHECKER(thread_checker_);
 };
 

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_stats.cc

+// Copyright 2019 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 "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_stats.h"
+
+namespace blink {
+
+P2PQuicTransportStats::P2PQuicTransportStats()
+    : timestamp(base::TimeTicks::Now()) {}
+
+P2PQuicTransportStats::P2PQuicTransportStats(
+    const quic::QuicConnectionStats& quic_stats,
+    uint32_t num_outgoing_streams_created,
+    uint32_t num_incoming_streams_created)
+    : timestamp(base::TimeTicks::Now()),
+      bytes_sent(quic_stats.bytes_sent),
+      packets_sent(quic_stats.packets_sent),
+      stream_bytes_sent(quic_stats.stream_bytes_sent),
+      stream_bytes_received(quic_stats.stream_bytes_received),
+      num_outgoing_streams_created(num_outgoing_streams_created),
+      num_incoming_streams_created(num_incoming_streams_created),
+      bytes_received(quic_stats.bytes_received),
+      packets_received(quic_stats.packets_received),
+      packets_processed(quic_stats.packets_processed),
+      bytes_retransmitted(quic_stats.bytes_retransmitted),
+      packets_retransmitted(quic_stats.packets_retransmitted),
+      packets_lost(quic_stats.packets_lost),
+      packets_dropped(quic_stats.packets_dropped),
+      crypto_retransmit_count(quic_stats.crypto_retransmit_count),
+      min_rtt_us(quic_stats.min_rtt_us),
+      srtt_us(quic_stats.srtt_us),
+      max_packet_size(quic_stats.max_packet_size),
+      max_received_packet_size(quic_stats.max_received_packet_size),
+      estimated_bandwidth_bps(quic_stats.estimated_bandwidth.ToBitsPerSecond()),
+      packets_reordered(quic_stats.packets_reordered),
+      blocked_frames_received(quic_stats.blocked_frames_received),
+      blocked_frames_sent(quic_stats.blocked_frames_sent),
+      connectivity_probing_packets_received(
+          quic_stats.num_connectivity_probing_received) {}
+}  // namespace blink

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_stats.h

+// Copyright 2019 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_TRANSPORT_STATS_H_
+#define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_TRANSPORT_STATS_H_
+
+#include "base/time/time.h"
+#include "net/third_party/quic/core/quic_connection_stats.h"
+#include "third_party/blink/renderer/modules/modules_export.h"
+
+namespace blink {
+
+// These are stats associated with the P2PQuicTransport object. These
+// stats are mostly copied from quic::QuicConnectionStats, which includes
+// stats for a quic::QuicConnection. These are connection level stats.
+// Currently QUIC does not have stats at the stream level.
+struct MODULES_EXPORT P2PQuicTransportStats {
+  P2PQuicTransportStats();
+  // Note: The following stats are ignored form the QuicConnectionStats:
+  //       -packets_spuriously_retransmitted
+  //       -bytes_spuriously_retransmitted
+  //       -slowstart_packets_sent
+  //       -slowstart_packets_lost
+  //       -slowstart_bytes_lost
+  //       -loss_timeout_count
+  //       -tlp_count
+  //       -rto_count
+  //       -max_sequence_reordering
+  //       -max_time_reordering_us
+  //       -tcp_loss_events
+  //       -connection_creation_time
+  explicit P2PQuicTransportStats(const quic::QuicConnectionStats& stats,
+                                 uint32_t num_outgoing_streams_created,
+                                 uint32_t num_incoming_streams_created);
+  ~P2PQuicTransportStats() = default;
+
+  base::TimeTicks timestamp;
+  // |bytes_sent| includes retransmissions.
+  uint64_t bytes_sent = 0;
+  uint64_t packets_sent = 0;
+  // |stream_bytes_sent| does not include retransmissions.
+  uint64_t stream_bytes_sent = 0;
+  uint64_t stream_bytes_received = 0;
+  uint32_t num_outgoing_streams_created = 0;
+  uint32_t num_incoming_streams_created = 0;
+
+  // These include version negotiation and public reset packets.
+  //
+  // |bytes_received| includes duplicate data for a stream.
+  uint64_t bytes_received = 0;
+  // |packets_received| includes packets which were not processable.
+  uint64_t packets_received = 0;
+  uint64_t packets_processed = 0;
+
+  uint64_t bytes_retransmitted = 0;
+  uint64_t packets_retransmitted = 0;
+  // Number of packets abandoned as lost by the loss detection algorithm.
+  uint64_t packets_lost = 0;
+  uint64_t packets_dropped = 0;
+  size_t crypto_retransmit_count = 0;
+  // Minimum RTT in microseconds.
+  uint64_t min_rtt_us = 0;
+  // Smoothed RTT in microseconds.
+  uint64_t srtt_us = 0;
+  uint64_t max_packet_size = 0;
+  uint64_t max_received_packet_size = 0;
+  // Bits per second.
+  uint64_t estimated_bandwidth_bps = 0;
+  // Reordering stats for received packets.
+  // Number of packets received out of packet number order.
+  uint64_t packets_reordered = 0;
+  uint64_t blocked_frames_received = 0;
+  uint64_t blocked_frames_sent = 0;
+  // Number of connectivity probing packets received by this connection.
+  uint64_t connectivity_probing_packets_received = 0;
+};
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_P2P_QUIC_TRANSPORT_STATS_H_

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_test.cc

@@ -1161,4 +1161,48 @@ TEST_F(P2PQuicTransportTest, StreamDataSentWithFinClosesStreams) {
   ExpectStreamsClosed();
 }
 
+// Tests that the stats returned by the P2PQuicTransportImpl have the correct
+// number of incoming and outgoing streams.
+TEST_F(P2PQuicTransportTest, GetStatsForNumberOfStreams) {
+  Initialize();
+  Connect();
+
+  P2PQuicTransportStats client_stats_1 =
+      client_peer()->quic_transport()->GetStats();
+  EXPECT_EQ(0u, client_stats_1.num_incoming_streams_created);
+  EXPECT_EQ(0u, client_stats_1.num_outgoing_streams_created);
+  P2PQuicTransportStats server_stats_1 =
+      server_peer()->quic_transport()->GetStats();
+  EXPECT_EQ(0u, server_stats_1.num_incoming_streams_created);
+  EXPECT_EQ(0u, server_stats_1.num_outgoing_streams_created);
+
+  // Create a stream on the client side and send some data to trigger a stream
+  // creation on the remote side.
+  client_peer()->CreateStreamWithDelegate();
+  CallbackRunLoop run_loop(runner());
+  base::RepeatingCallback<void()> callback = run_loop.CreateCallback();
+  MockP2PQuicStreamDelegate server_stream_delegate;
+  EXPECT_CALL(*server_peer()->quic_transport_delegate(), OnStream(_))
+      .WillOnce(
+          Invoke([&callback, &server_stream_delegate](P2PQuicStream* stream) {
+            stream->SetDelegate(&server_stream_delegate);
+            callback.Run();
+          }));
+  client_peer()->stream()->WriteData(
+      VectorFromArray(kTriggerRemoteStreamPhrase),
+      /*fin=*/false);
+  run_loop.RunUntilCallbacksFired();
+
+  P2PQuicTransportStats client_stats_2 =
+      client_peer()->quic_transport()->GetStats();
+  EXPECT_EQ(0u, client_stats_2.num_incoming_streams_created);
+  EXPECT_EQ(1u, client_stats_2.num_outgoing_streams_created);
+  EXPECT_GT(client_stats_2.timestamp, client_stats_1.timestamp);
+  P2PQuicTransportStats server_stats_2 =
+      server_peer()->quic_transport()->GetStats();
+  EXPECT_EQ(1u, server_stats_2.num_incoming_streams_created);
+  EXPECT_EQ(0u, server_stats_2.num_outgoing_streams_created);
+  EXPECT_GT(server_stats_2.timestamp, server_stats_1.timestamp);
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_transport.h

@@ -7,6 +7,7 @@
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport.h"
+#include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_stats.h"
 
 namespace blink {
 
@@ -20,6 +21,7 @@ class MockP2PQuicTransport : public testing::NiceMock<P2PQuicTransport> {
   void Start(StartConfig config) override { MockStart(config); }
   MOCK_METHOD1(MockStart, void(const StartConfig&));
   MOCK_METHOD0(CreateStream, P2PQuicStream*());
+  MOCK_CONST_METHOD0(GetStats, P2PQuicTransportStats());
 };
 
 }  // namespace blink