Expose packet loss counts from QUIC to NetworkQualityEstimator

net/base/network_quality_estimator_unittest.cc

 // Copyright 2015 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/base/network_quality_estimator.h"
 
+#include <stddef.h>
 #include <stdint.h>
+
 #include <limits>
 #include <map>
+#include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "net/base/external_estimate_provider.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
+#include "net/base/socket_performance_watcher_factory.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
@@ skipping 114 matching lines @@
       int32_t throughput_kbps,
       const base::TimeTicks& timestamp,
       net::NetworkQualityEstimator::ObservationSource source) override {
     observations_.push_back(Observation(throughput_kbps, timestamp, source));
   }
 
  private:
   std::vector<Observation> observations_;
 };
 
+class TestPacketLossObserver
+    : public net::NetworkQualityEstimator::PacketLossObserver {
+ public:
+  struct Observation {
+    Observation(size_t packets_missing,
+                size_t packets_received_in_order,
+                size_t packets_received_out_of_order,
+                const base::TimeTicks& ts,
+                net::NetworkQualityEstimator::ObservationSource src)
+        : packets_missing(packets_missing),
+          packets_received_in_order(packets_received_in_order),
+          packets_received_out_of_order(packets_received_out_of_order),
+          timestamp(ts),
+          source(src) {}
+    size_t packets_missing;
+    size_t packets_received_in_order;
+    size_t packets_received_out_of_order;
+    base::TimeTicks timestamp;
+    net::NetworkQualityEstimator::ObservationSource source;
+  };
+
+  std::vector<Observation>& observations() { return observations_; }
+
+  // PacketLossObserver implementation:
+  void OnPacketLossObservation(
+      size_t packets_missing,
+      size_t packets_received_in_order,
+      size_t packets_received_out_of_order,
+      const base::TimeTicks& timestamp,
+      net::NetworkQualityEstimator::ObservationSource source) override {
+    observations_.push_back(
+        Observation(packets_missing, packets_received_in_order,
+                    packets_received_out_of_order, timestamp, source));
+  }
+
+ private:
+  std::vector<Observation> observations_;
+};
+
 }  // namespace
 
 namespace net {
 
 TEST(NetworkQualityEstimatorTest, TestKbpsRTTUpdates) {
   base::HistogramTester histogram_tester;
   // Enable requests to local host to be used for network quality estimation.
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
@@ skipping 78 matching lines @@
   EXPECT_EQ(NetworkQualityEstimator::InvalidRTT(),
             estimator.GetRTTEstimateInternal(base::TimeTicks(), 100));
   EXPECT_EQ(NetworkQualityEstimator::kInvalidThroughput,
             estimator.GetDownlinkThroughputKbpsEstimateInternal(
                 base::TimeTicks(), 100));
 
   EXPECT_FALSE(estimator.GetRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 }
 
+// Tests that packet loss rate is updated correctly.
+TEST(NetworkQualityEstimatorTest, TestPacketLossRateUpdates) {
+  std::map<std::string, std::string> variation_params;
+  TestNetworkQualityEstimator estimator(variation_params);
+
+  float packet_loss_rate;
+  EXPECT_FALSE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+
+  estimator.OnUpdatedPacketCountAvailable(
+      NetworkQualityEstimator::PROTOCOL_QUIC, 0, 1, 1);
+
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(0.0f, packet_loss_rate, 0.001f);
+
+  estimator.SimulateNetworkChangeTo(
+      NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, std::string());
+
+  EXPECT_FALSE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+
+  // Expecting packet number i, but received packet numbers from i+9 to i+11.
+  estimator.OnUpdatedPacketCountAvailable(
+      NetworkQualityEstimator::PROTOCOL_QUIC, 9, 3, 0);
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(9.0f / 12, packet_loss_rate, 0.001f);
+
+  // Expecting packet number i+12, and received packet number i+12.
+  estimator.OnUpdatedPacketCountAvailable(
+      NetworkQualityEstimator::PROTOCOL_QUIC, 0, 1, 0);
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(9.0f / 13, packet_loss_rate, 0.001f);
+
+  // Expecting packet number i+13, and received packet number i+3.
+  estimator.OnUpdatedPacketCountAvailable(
+      NetworkQualityEstimator::PROTOCOL_QUIC, 0, 0, 1);
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(9.0f / 13, packet_loss_rate, 0.001f);
+
+  // Expecting packet number i+13, and received packet number i+15.
+  estimator.OnUpdatedPacketCountAvailable(
+      NetworkQualityEstimator::PROTOCOL_QUIC, 0, 1, 0);
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(9.0f / 14, packet_loss_rate, 0.001f);
+}
+
+// Tests that packet loss UMA histogram is recorded properly.
+TEST(NetworkQualityEstimatorTest, TestPacketLossRateHistogram) {
+  std::map<std::string, std::string> variation_params;
+  TestNetworkQualityEstimator estimator(variation_params);
+
+  TestDelegate test_delegate;
+  TestURLRequestContext context(true);
+  context.set_network_quality_estimator(&estimator);
+  context.Init();
+
+  const struct {
+    bool notify_packet_counts;
+    bool set_mainframe_flag;
+  } tests[] = {
+      {
+          false, false,
+      },
+      {
+          false, true,
+      },
+      {
+          true, false,
+      },
+      {
+          true, true,
+      },
+  };
+
+  for (const auto& test : tests) {
+    base::HistogramTester histogram_tester;
+    estimator.SimulateNetworkChangeTo(
+        NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI, "test");
+
+    float packet_loss_rate;
+    EXPECT_FALSE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+
+    if (test.notify_packet_counts) {
+      estimator.OnUpdatedPacketCountAvailable(
+          NetworkQualityEstimator::PROTOCOL_QUIC, 0, 1, 1);
+    }
+    EXPECT_EQ(test.notify_packet_counts,
+              estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+
+    for (size_t i = 0; i < 2; ++i) {
+      // Check UMA histograms.
+      scoped_ptr<URLRequest> request(context.CreateRequest(
+          estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
+      if (test.set_mainframe_flag) {
+        request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
+      }
+      request->Start();
+      base::RunLoop().Run();
+      size_t expect_histogram_count =
+          test.notify_packet_counts && test.set_mainframe_flag ? i + 1 : 0;
+      histogram_tester.ExpectTotalCount("NQE.PacketLossRate.WiFi",
+                                        expect_histogram_count);
+    }
+  }
+}
+
 TEST(NetworkQualityEstimatorTest, StoreObservations) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   // Push 10 more observations than the maximum buffer size.
@@ skipping 24 matching lines @@
 TEST(NetworkQualityEstimatorTest, PercentileSameTimestamps) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   base::TimeTicks now = base::TimeTicks::Now();
 
   // Network quality should be unavailable when no observations are available.
   base::TimeDelta rtt;
   EXPECT_FALSE(estimator.GetRTTEstimate(&rtt));
   int32_t kbps;
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
+  float packet_loss_rate;
+  EXPECT_FALSE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
 
   // Insert samples from {1,2,3,..., 100}. First insert odd samples, then even
   // samples. This helps in verifying that the order of samples does not matter.
   for (int i = 1; i <= 99; i += 2) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
         NetworkQualityEstimator::ThroughputObservation(
             i, now, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
             base::TimeDelta::FromMilliseconds(i), now,
             NetworkQualityEstimator::URL_REQUEST));
+    estimator.packet_loss_rate_observations_.AddObservation(
+        NetworkQualityEstimator::PacketLossRateObservation(
+            0.0f, now, NetworkQualityEstimator::QUIC));
     EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
     EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
+    EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
   }
 
   for (int i = 2; i <= 100; i += 2) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
         NetworkQualityEstimator::ThroughputObservation(
             i, now, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
             base::TimeDelta::FromMilliseconds(i), now,
             NetworkQualityEstimator::URL_REQUEST));
+    estimator.packet_loss_rate_observations_.AddObservation(
+        NetworkQualityEstimator::PacketLossRateObservation(
+            1.0, now, NetworkQualityEstimator::QUIC));
     EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
     EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
+    EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
   }
 
   for (int i = 0; i <= 100; ++i) {
     // Checks if the difference between the two integers is less than 1. This is
     // required because computed percentiles may be slightly different from
     // what is expected due to floating point computation errors and integer
     // rounding off errors.
     EXPECT_NEAR(estimator.GetDownlinkThroughputKbpsEstimateInternal(
                     base::TimeTicks(), i),
                 100 - i, 1);
     EXPECT_NEAR(
         estimator.GetRTTEstimateInternal(base::TimeTicks(), i).InMilliseconds(),
         i, 1);
   }
 
   EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   // |network_quality| should be equal to the 50 percentile value.
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimateInternal(
                   base::TimeTicks(), 50) > 0);
   EXPECT_TRUE(estimator.GetRTTEstimateInternal(base::TimeTicks(), 50) !=
               NetworkQualityEstimator::InvalidRTT());
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(0.5f, packet_loss_rate, 0.001f);
 }
 
 // Verifies that the percentiles are correctly computed. Observations have
 // different timestamps with half the observations being very old and the rest
 // of them being very recent. Percentiles should factor in recent observations
 // much more heavily than older samples. Kbps percentiles must be in decreasing
 // order. RTT percentiles must be in increasing order.
 TEST(NetworkQualityEstimatorTest, PercentileDifferentTimestamps) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks very_old = base::TimeTicks::UnixEpoch();
 
+  float packet_loss_rate;
+  EXPECT_FALSE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+
   // First 50 samples have very old timestamp.
   for (int i = 1; i <= 50; ++i) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
         NetworkQualityEstimator::ThroughputObservation(
             i, very_old, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
             base::TimeDelta::FromMilliseconds(i), very_old,
             NetworkQualityEstimator::URL_REQUEST));
+    estimator.packet_loss_rate_observations_.AddObservation(
+        NetworkQualityEstimator::PacketLossRateObservation(
+            0.0f, very_old, NetworkQualityEstimator::QUIC));
   }
 
   // Next 50 (i.e., from 51 to 100) have recent timestamp.
   for (int i = 51; i <= 100; ++i) {
     estimator.downstream_throughput_kbps_observations_.AddObservation(
         NetworkQualityEstimator::ThroughputObservation(
             i, now, NetworkQualityEstimator::URL_REQUEST));
     estimator.rtt_msec_observations_.AddObservation(
         NetworkQualityEstimator::RttObservation(
             base::TimeDelta::FromMilliseconds(i), now,
             NetworkQualityEstimator::URL_REQUEST));
+    estimator.packet_loss_rate_observations_.AddObservation(
+        NetworkQualityEstimator::PacketLossRateObservation(
+            1.0, now, NetworkQualityEstimator::QUIC));
   }
 
   // Older samples have very little weight. So, all percentiles are >= 51
   // (lowest value among recent observations).
   for (int i = 1; i < 100; ++i) {
     // Checks if the difference between the two integers is less than 1. This is
     // required because computed percentiles may be slightly different from
     // what is expected due to floating point computation errors and integer
     // rounding off errors.
     EXPECT_NEAR(estimator.GetDownlinkThroughputKbpsEstimateInternal(
                     base::TimeTicks(), i),
                 51 + 0.49 * (100 - i), 1);
     EXPECT_NEAR(
         estimator.GetRTTEstimateInternal(base::TimeTicks(), i).InMilliseconds(),
         51 + 0.49 * i, 1);
   }
 
   EXPECT_EQ(NetworkQualityEstimator::InvalidRTT(),
             estimator.GetRTTEstimateInternal(
                 base::TimeTicks::Now() + base::TimeDelta::FromMinutes(10), 50));
   EXPECT_EQ(NetworkQualityEstimator::kInvalidThroughput,
             estimator.GetDownlinkThroughputKbpsEstimateInternal(
                 base::TimeTicks::Now() + base::TimeDelta::FromMinutes(10), 50));
+
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(1.0, packet_loss_rate, 0.001f);
 }
 
 // This test notifies NetworkQualityEstimator of received data. Next,
 // throughput and RTT percentiles are checked for correctness by doing simple
 // verifications.
 TEST(NetworkQualityEstimatorTest, ComputedPercentiles) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   EXPECT_EQ(NetworkQualityEstimator::InvalidRTT(),
@@ skipping 114 matching lines @@
 }
 
 TEST(NetworkQualityEstimatorTest, HalfLifeParam) {
   // Verifies if |weight_multiplier_per_second_| is set to correct value for
   // various values of half life parameter.
   std::map<std::string, std::string> variation_params;
   {
     // Half life parameter is not set. Default value of
     // |weight_multiplier_per_second_| should be used.
     TestNetworkQualityEstimator estimator(variation_params);
-    EXPECT_NEAR(0.988, estimator.downstream_throughput_kbps_observations_
-                           .weight_multiplier_per_second_,
-                0.001);
+    EXPECT_NEAR(0.988f, estimator.downstream_throughput_kbps_observations_
+                            .weight_multiplier_per_second_,
+                0.001f);
   }
 
   variation_params["HalfLifeSeconds"] = "-100";
   {
     // Half life parameter is set to a negative value.  Default value of
     // |weight_multiplier_per_second_| should be used.
     TestNetworkQualityEstimator estimator(variation_params);
-    EXPECT_NEAR(0.988, estimator.downstream_throughput_kbps_observations_
-                           .weight_multiplier_per_second_,
-                0.001);
+    EXPECT_NEAR(0.988f, estimator.downstream_throughput_kbps_observations_
+                            .weight_multiplier_per_second_,
+                0.001f);
   }
 
   variation_params["HalfLifeSeconds"] = "0";
   {
     // Half life parameter is set to zero.  Default value of
     // |weight_multiplier_per_second_| should be used.
     TestNetworkQualityEstimator estimator(variation_params);
-    EXPECT_NEAR(0.988, estimator.downstream_throughput_kbps_observations_
-                           .weight_multiplier_per_second_,
-                0.001);
+    EXPECT_NEAR(0.988f, estimator.downstream_throughput_kbps_observations_
+                            .weight_multiplier_per_second_,
+                0.001f);
   }
 
   variation_params["HalfLifeSeconds"] = "10";
   {
     // Half life parameter is set to a valid value.
     TestNetworkQualityEstimator estimator(variation_params);
-    EXPECT_NEAR(0.933, estimator.downstream_throughput_kbps_observations_
-                           .weight_multiplier_per_second_,
-                0.001);
+    EXPECT_NEAR(0.933f, estimator.downstream_throughput_kbps_observations_
+                            .weight_multiplier_per_second_,
+                0.001f);
   }
 }
 
 // Test if the network estimates are cached when network change notification
 // is invoked.
 TEST(NetworkQualityEstimatorTest, TestCaching) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   size_t expected_cache_size = 0;
   EXPECT_EQ(expected_cache_size, estimator.cached_network_qualities_.size());
@@ skipping 438 matching lines @@
   request->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(2U, estimator.rtt_msec_observations_.Size());
   EXPECT_EQ(2U, estimator.downstream_throughput_kbps_observations_.Size());
 }
 
 TEST(NetworkQualityEstimatorTest, TestObservers) {
   TestRTTObserver rtt_observer;
   TestThroughputObserver throughput_observer;
+  TestPacketLossObserver packet_loss_observer;
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
   estimator.AddRTTObserver(&rtt_observer);
   estimator.AddThroughputObserver(&throughput_observer);
+  estimator.AddPacketLossObserver(&packet_loss_observer);
 
   TestDelegate test_delegate;
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   EXPECT_EQ(0U, rtt_observer.observations().size());
   EXPECT_EQ(0U, throughput_observer.observations().size());
   base::TimeTicks then = base::TimeTicks::Now();
 
   scoped_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
   request->Start();
   base::RunLoop().Run();
 
   scoped_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request2->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME);
   request2->Start();
   base::RunLoop().Run();
 
+  float packet_loss_rate;
+  EXPECT_FALSE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+
+  estimator.OnUpdatedPacketCountAvailable(
+      NetworkQualityEstimator::PROTOCOL_QUIC, 0, 1, 1);
+  EXPECT_TRUE(estimator.GetPacketLossRateEstimate(&packet_loss_rate));
+  EXPECT_NEAR(0.0f, packet_loss_rate, 0.001f);
+
   // Both RTT and downstream throughput should be updated.
   EXPECT_NE(NetworkQualityEstimator::InvalidRTT(),
             estimator.GetRTTEstimateInternal(base::TimeTicks(), 100));
   EXPECT_NE(NetworkQualityEstimator::kInvalidThroughput,
             estimator.GetDownlinkThroughputKbpsEstimateInternal(
                 base::TimeTicks(), 100));
 
   EXPECT_EQ(2U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
-  for (auto observation : rtt_observer.observations()) {
+  ASSERT_EQ(1U, packet_loss_observer.observations().size());
+  for (const auto& observation : rtt_observer.observations()) {
     EXPECT_LE(0, observation.rtt_ms);
     EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
     EXPECT_EQ(NetworkQualityEstimator::URL_REQUEST, observation.source);
   }
-  for (auto observation : throughput_observer.observations()) {
+  for (const auto& observation : throughput_observer.observations()) {
     EXPECT_LE(0, observation.throughput_kbps);
     EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
     EXPECT_EQ(NetworkQualityEstimator::URL_REQUEST, observation.source);
   }
+  for (const auto& observation : packet_loss_observer.observations()) {
+    EXPECT_LE(0u, observation.packets_missing);
+    EXPECT_LE(1u, observation.packets_received_in_order);
+    EXPECT_LE(0u, observation.packets_received_out_of_order);
+    EXPECT_LE(0, (observation.timestamp - then).InMilliseconds());
+    EXPECT_EQ(NetworkQualityEstimator::QUIC, observation.source);
+  }
 
   // Verify that observations from TCP and QUIC are passed on to the observers.
   base::TimeDelta tcp_rtt(base::TimeDelta::FromMilliseconds(1));
   base::TimeDelta quic_rtt(base::TimeDelta::FromMilliseconds(2));
 
   scoped_ptr<SocketPerformanceWatcher> tcp_watcher =
       estimator.CreateSocketPerformanceWatcher(
           SocketPerformanceWatcherFactory::PROTOCOL_TCP);
   scoped_ptr<SocketPerformanceWatcher> quic_watcher =
       estimator.CreateSocketPerformanceWatcher(
           SocketPerformanceWatcherFactory::PROTOCOL_QUIC);
   tcp_watcher->OnUpdatedRTTAvailable(tcp_rtt);
   quic_watcher->OnUpdatedRTTAvailable(quic_rtt);
 
   EXPECT_EQ(4U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
 
   EXPECT_EQ(tcp_rtt.InMilliseconds(), rtt_observer.observations().at(2).rtt_ms);
   EXPECT_EQ(quic_rtt.InMilliseconds(),
             rtt_observer.observations().at(3).rtt_ms);
 }
 
 }  // namespace net