Factor out NetworkID and caching mechanism from n_q_e.{h,cc}

net/nqe/network_qualities_manager_unittest.cc

+// Copyright 2016 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/nqe/network_qualities_manager.h"
+
+#include "base/macros.h"

[RyanSturm, 2016/07/12 18:45:38]

Is this needed?

[tbansal1, 2016/07/12 19:40:19]

Done.

+#include "base/strings/string_number_conversions.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "base/time/time.h"
+#include "net/base/network_change_notifier.h"
+#include "net/nqe/cached_network_quality.h"
+#include "net/nqe/network_id.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+TEST(NetworkQualitiesManagerTest, TestCaching) {
+  nqe::internal::NetworkQualitiesManager network_qualities_manager;
+  base::SimpleTestTickClock tick_clock;
+
+  {
+    // Entry will be added for (2G, "test1").
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test1");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    const nqe::internal::CachedNetworkQuality cached_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(1),
+                                      base::TimeDelta::FromSeconds(1), 1));
+    network_qualities_manager.CacheNetworkQualityEstimate(
+        network_id, cached_network_quality);
+    EXPECT_TRUE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+    EXPECT_EQ(cached_network_quality.network_quality(),
+              read_network_quality.network_quality());
+  }
+
+  {
+    // Entry will be added for (2G, "test2").
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test2");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    nqe::internal::CachedNetworkQuality cached_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(2),
+                                      base::TimeDelta::FromSeconds(2), 2));
+    network_qualities_manager.CacheNetworkQualityEstimate(
+        network_id, cached_network_quality);
+    EXPECT_TRUE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+    EXPECT_EQ(read_network_quality.network_quality(),
+              cached_network_quality.network_quality());
+  }
+
+  {
+    // Entry will be added for (3G, "test3").
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_3G,
+                                        "test3");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    nqe::internal::CachedNetworkQuality cached_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(3),
+                                      base::TimeDelta::FromSeconds(3), 3));
+    network_qualities_manager.CacheNetworkQualityEstimate(
+        network_id, cached_network_quality);
+    EXPECT_TRUE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+    EXPECT_EQ(read_network_quality.network_quality(),
+              cached_network_quality.network_quality());
+  }
+
+  {
+    // Entry will not be added for (Unknown, "").
+    nqe::internal::NetworkID network_id(
+        NetworkChangeNotifier::CONNECTION_UNKNOWN, "");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    nqe::internal::CachedNetworkQuality set_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(4),
+                                      base::TimeDelta::FromSeconds(4), 4));
+    network_qualities_manager.CacheNetworkQualityEstimate(network_id,
+                                                          set_network_quality);
+    EXPECT_FALSE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+  }
+
+  {
+    // Existing entry will be read for (2G, "test1").
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test1");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    const nqe::internal::CachedNetworkQuality cached_network_quality(

[RyanSturm, 2016/07/12 18:45:38]

Add a comment that this cached_network_quality is defined in the same way above
when it is added to the map, or better yet, share the cached_network_quality
with the code above.

[tbansal1, 2016/07/12 19:40:19]

Done.

+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(1),
+                                      base::TimeDelta::FromSeconds(1), 1));
+    EXPECT_TRUE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+    EXPECT_EQ(cached_network_quality.network_quality(),
+              read_network_quality.network_quality());
+  }
+
+  {
+    // Existing entry will be overwritten for (2G, "test1").
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test1");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    const nqe::internal::CachedNetworkQuality cached_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(5),
+                                      base::TimeDelta::FromSeconds(5), 5));
+    network_qualities_manager.CacheNetworkQualityEstimate(
+        network_id, cached_network_quality);
+    EXPECT_TRUE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+    EXPECT_EQ(cached_network_quality.network_quality(),
+              read_network_quality.network_quality());
+  }
+
+  {
+    // No entry should exist for (2G, "test4").
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test4");
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    EXPECT_FALSE(network_qualities_manager.GetCachedNetworkQualityEstimate(
+        network_id, &read_network_quality));
+  }
+}
+
+// Tests if the cache size remains bounded. Also, ensure that the cache is
+// LRU.
+TEST(NetworkQualitiesManagerTest, TestLRUCacheMaximumSize) {
+  nqe::internal::NetworkQualitiesManager network_qualities_manager;
+  base::SimpleTestTickClock tick_clock;
+
+  // Add more networks than the maximum size of the cache.
+  const size_t network_count = 100;

[RyanSturm, 2016/07/12 18:45:38]

I'd prefer kMaximumNetworkQualityCacheSize+1, if you are willing to expose that
outside of the NetworkQualitiesManager class. 100 is overkill, and staying in
sync with the limit would be better. If not,  you have a static_assert to keep
the limit under 10, so maybe should make the unittest use 11 as a hard-coded
value.

[tbansal1, 2016/07/12 19:40:18]

Changed to 11. There is a static assert in network_qualities_manager.cc to check
that kMaximumNetworkQualityCacheSize <= 10.

+
+  nqe::internal::CachedNetworkQuality read_network_quality(
+      tick_clock.NowTicks(),
+      nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                    base::TimeDelta::FromSeconds(0), 0));
+
+  for (size_t i = 0; i < network_count; ++i) {
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test" + base::IntToString(i));
+
+    const nqe::internal::CachedNetworkQuality network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(1),
+                                      base::TimeDelta::FromSeconds(1), 1));
+    network_qualities_manager.CacheNetworkQualityEstimate(network_id,
+                                                          network_quality);
+    tick_clock.Advance(base::TimeDelta::FromSeconds(1));
+  }
+
+  base::TimeTicks earliest_last_update_time = tick_clock.NowTicks();
+  size_t cache_match_count = 0;
+  for (size_t i = 0; i < network_count; ++i) {
+    nqe::internal::NetworkID network_id(NetworkChangeNotifier::CONNECTION_2G,
+                                        "test" + base::IntToString(i));
+
+    nqe::internal::CachedNetworkQuality read_network_quality(
+        tick_clock.NowTicks(),
+        nqe::internal::NetworkQuality(base::TimeDelta::FromSeconds(0),
+                                      base::TimeDelta::FromSeconds(0), 0));
+    if (network_qualities_manager.GetCachedNetworkQualityEstimate(
+            network_id, &read_network_quality)) {
+      cache_match_count++;
+      earliest_last_update_time = std::min(
+          earliest_last_update_time, read_network_quality.last_update_time());
+    }
+  }
+
+  // Ensure that the number of entries in cache are fewer than |network_count|.
+  EXPECT_LT(cache_match_count, network_count);
+  EXPECT_GT(cache_match_count, 0u);
+
+  // Ensure that only LRU entries are cached by comparing the
+  // |earliest_last_update_time|.
+  EXPECT_EQ(
+      tick_clock.NowTicks() - base::TimeDelta::FromSeconds(cache_match_count),
+      earliest_last_update_time);
+}
+
+}  // namespace
+
+}  // namespace net