Expose packet loss counts from QUIC to NetworkQualityEstimator

net/quic/quic_connection_logger_unittest.cc

 // Copyright 2014 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 "net/quic/quic_connection_logger.h"
 
+#include <stddef.h>
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
 #include "net/base/socket_performance_watcher.h"
+#include "net/base/socket_performance_watcher_factory.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace base {
+class TimeDelta;
+}
+
 namespace net {
 namespace test {
 
+class TestSocketPerformanceWatcherFactory
+    : public SocketPerformanceWatcherFactory {
+ public:
+  TestSocketPerformanceWatcherFactory()
+      : packets_missing_(0),
+        packets_received_in_order_(0),
+        packets_received_out_of_order_(0) {}
+
+  ~TestSocketPerformanceWatcherFactory() override {}
+
+  scoped_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher(
+      const Protocol protocol) override {
+    if (protocol != PROTOCOL_QUIC) {
+      NOTIMPLEMENTED();
+    }
+    return scoped_ptr<SocketPerformanceWatcher>(
+        new SocketPerformanceWatcher(protocol, this));
+  }
+
+  void OnUpdatedRTTAvailable(const Protocol protocol,
+                             const base::TimeDelta& rtt) override {}
+
+  void OnIncrementalPacketCountAvailable(
+      Protocol protocol,
+      size_t packets_missing,
+      size_t packets_received_in_order,
+      size_t packets_received_out_of_order) override {
+    if (protocol != PROTOCOL_QUIC) {
+      NOTIMPLEMENTED();
+    }
+    packets_missing_ = packets_missing;
+    packets_received_in_order_ = packets_received_in_order;
+    packets_received_out_of_order_ = packets_received_out_of_order;
+  }
+
+  void VerifyAndResetPacketCounts(size_t packets_missing,
+                                  size_t packets_received_in_order,
+                                  size_t packets_received_out_of_order) {
+    EXPECT_EQ(packets_missing, packets_missing_);
+    EXPECT_EQ(packets_received_in_order, packets_received_in_order_);
+    EXPECT_EQ(packets_received_out_of_order, packets_received_out_of_order_);
+    packets_missing_ = 0;
+    packets_received_in_order_ = 0;
+    packets_received_out_of_order_ = 0;
+  }
+
+ private:
+  size_t packets_missing_;
+  size_t packets_received_in_order_;
+  size_t packets_received_out_of_order_;
+  DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcherFactory);
+};
+
 class QuicConnectionLoggerPeer {
  public:
-  static size_t num_truncated_acks_sent(const QuicConnectionLogger& logger) {
-    return logger.num_truncated_acks_sent_;
+  static size_t num_truncated_acks_sent(const QuicConnectionLogger* logger) {
+    return logger->num_truncated_acks_sent_;
   }
 
-  static void set_num_packets_received(QuicConnectionLogger& logger,
+  static void set_num_packets_received(QuicConnectionLogger* logger,
                                        int value) {
-    logger.num_packets_received_ = value;
+    logger->num_packets_received_ = value;
   }
 
-  static void set_largest_received_packet_number(QuicConnectionLogger& logger,
+  static void set_largest_received_packet_number(QuicConnectionLogger* logger,
                                                  int value) {
-    logger.largest_received_packet_number_ = value;
+    logger->largest_received_packet_number_ = value;
+  }
+
+  static void ReportPacketCounts(
+      QuicConnectionLogger* logger,
+      size_t previous_largest_received_packet_number) {
+    logger->ReportIncrementalPacketCounts(
+        previous_largest_received_packet_number);
   }
 };
 
 class QuicConnectionLoggerTest : public ::testing::Test {
  protected:
   QuicConnectionLoggerTest()
-      : session_(new MockConnection(&helper_, Perspective::IS_CLIENT)),
-        logger_(&session_,
-                "CONNECTION_UNKNOWN",
-                /*socket_performance_watcher=*/nullptr,
-                net_log_) {}
+      : session_(new MockConnection(&helper_, Perspective::IS_CLIENT)) {
+    logger_.reset(new QuicConnectionLogger(
+        &session_, "CONNECTION_UNKNOWN",
+        socket_performance_watcher_factory_.CreateSocketPerformanceWatcher(
+            SocketPerformanceWatcherFactory::PROTOCOL_QUIC),
+        net_log_));
+  }
 
   BoundNetLog net_log_;
   MockConnectionHelper helper_;
+  TestSocketPerformanceWatcherFactory socket_performance_watcher_factory_;
   MockQuicSpdySession session_;
-  QuicConnectionLogger logger_;
+  scoped_ptr<QuicConnectionLogger> logger_;
 };
 
 TEST_F(QuicConnectionLoggerTest, TruncatedAcksSentNotChanged) {
   QuicAckFrame frame;
-  logger_.OnFrameAddedToPacket(QuicFrame(&frame));
-  EXPECT_EQ(0u, QuicConnectionLoggerPeer::num_truncated_acks_sent(logger_));
+  logger_->OnFrameAddedToPacket(QuicFrame(&frame));
+  EXPECT_EQ(0u,
+            QuicConnectionLoggerPeer::num_truncated_acks_sent(logger_.get()));
 
   for (QuicPacketNumber i = 0; i < 256; ++i) {
     frame.missing_packets.Add(i);
   }
-  logger_.OnFrameAddedToPacket(QuicFrame(&frame));
-  EXPECT_EQ(0u, QuicConnectionLoggerPeer::num_truncated_acks_sent(logger_));
+  logger_->OnFrameAddedToPacket(QuicFrame(&frame));
+  EXPECT_EQ(0u,
+            QuicConnectionLoggerPeer::num_truncated_acks_sent(logger_.get()));
 }
 
 TEST_F(QuicConnectionLoggerTest, TruncatedAcksSent) {
   QuicAckFrame frame;
   for (QuicPacketNumber i = 0; i < 512; i += 2) {
     frame.missing_packets.Add(i);
   }
-  logger_.OnFrameAddedToPacket(QuicFrame(&frame));
-  EXPECT_EQ(1u, QuicConnectionLoggerPeer::num_truncated_acks_sent(logger_));
+  logger_->OnFrameAddedToPacket(QuicFrame(&frame));
+  EXPECT_EQ(1u,
+            QuicConnectionLoggerPeer::num_truncated_acks_sent(logger_.get()));
 }
 
 TEST_F(QuicConnectionLoggerTest, ReceivedPacketLossRate) {
-  QuicConnectionLoggerPeer::set_num_packets_received(logger_, 1);
-  QuicConnectionLoggerPeer::set_largest_received_packet_number(logger_, 2);
-  EXPECT_EQ(0.5f, logger_.ReceivedPacketLossRate());
+  QuicConnectionLoggerPeer::set_num_packets_received(logger_.get(), 1);
+  QuicConnectionLoggerPeer::set_largest_received_packet_number(logger_.get(),
+                                                               2);
+  EXPECT_EQ(0.5f, logger_->ReceivedPacketLossRate());
+}
+
+TEST_F(QuicConnectionLoggerTest, ReportIncrementalPacketCounts) {
+  // Expecting packet 10. Received packet 10.
+  QuicConnectionLoggerPeer::set_largest_received_packet_number(logger_.get(),
+                                                               10);
+  QuicConnectionLoggerPeer::ReportPacketCounts(logger_.get(), 9);
+  socket_performance_watcher_factory_.VerifyAndResetPacketCounts(0, 1, 0);
+
+  // Expecting packet 11. Received packet 12.
+  QuicConnectionLoggerPeer::set_largest_received_packet_number(logger_.get(),
+                                                               12);
+  QuicConnectionLoggerPeer::ReportPacketCounts(logger_.get(), 10);
+  socket_performance_watcher_factory_.VerifyAndResetPacketCounts(1, 1, 0);
+
+  // Expecting packet 13. Received packet with sequence number less than 13.
+  QuicConnectionLoggerPeer::set_largest_received_packet_number(logger_.get(),
+                                                               12);
+  QuicConnectionLoggerPeer::ReportPacketCounts(logger_.get(), 12);
+  socket_performance_watcher_factory_.VerifyAndResetPacketCounts(0, 0, 1);
 }
 
 }  // namespace test
 }  // namespace net