Allow BackoffEntry to be serialized and deserialized.

net/base/backoff_entry_unittest.cc

Index: net/base/backoff_entry_unittest.cc
diff --git a/net/base/backoff_entry_unittest.cc b/net/base/backoff_entry_unittest.cc
index 29a42817ed8bf00b634c87f20ba5447c06403ca3..7804c620bf148c56d060ab5478a6b236c3759481 100644
--- a/net/base/backoff_entry_unittest.cc
+++ b/net/base/backoff_entry_unittest.cc
@@ -4,18 +4,30 @@
 
 #include "net/base/backoff_entry.h"
 
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/time/tick_clock.h"
+#include "base/values.h"
+#include "net/base/backoff_entry_serializer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
+using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
-BackoffEntry::Policy base_policy = { 0, 1000, 2.0, 0.0, 20000, 2000, false };
+BackoffEntry::Policy base_policy = {
+  0 /* num_errors_to_ignore */,
+  1000 /* initial_delay_ms */,
+  2.0 /* multiply_factor */,
+  0.0 /* jitter_factor */,
+  20000 /* maximum_backoff_ms */,
+  2000 /* entry_lifetime_ms */,
+  false /* always_use_initial_delay */
+};
 
 class TestTickClock : public base::TickClock {
  public:
@@ -311,6 +323,100 @@ TEST(BackoffEntryTest, OverflowProtection) {
   EXPECT_EQ(20000, custom.GetTimeUntilRelease().InMilliseconds());
 }
 
+TEST(BackoffEntryTest, SerializeTimeOffsets) {

[mmenke, 2015/05/05 15:47:52]

These should probably go in backoff_entry_serializer_unittest.cc

[johnme, 2015/05/06 12:46:47]

Done.

+  TestTickClock now_ticks;
+  BackoffEntry original(&base_policy, &now_ticks);
+  // 2 errors.
+  original.InformOfRequest(false);
+  original.InformOfRequest(false);
+  scoped_ptr<base::ListValue> serialized =
+      BackoffEntrySerializer::SerializeToValue(original, base::Time());
+
+  {
+    // Test that immediate deserializeation round-trips.
+    scoped_ptr<BackoffEntry> deserialized =
+        BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
+                                                     &now_ticks, base::Time());
+    ASSERT_TRUE(deserialized.get());
+    EXPECT_EQ(original.failure_count(), deserialized->failure_count());
+    EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
+  }
+
+  {
+    // Test deserialization when wall clock has advanced but TimeTicks haven't
+    // (e.g. device was rebooted).
+    base::Time later = base::Time() + TimeDelta::FromDays(1);
+    scoped_ptr<BackoffEntry> deserialized =
+        BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
+                                                     &now_ticks, later);
+    ASSERT_TRUE(deserialized.get());
+    EXPECT_EQ(original.failure_count(), deserialized->failure_count());
+    EXPECT_EQ(original.GetReleaseTime() - TimeDelta::FromDays(1),
+              deserialized->GetReleaseTime());
+  }
+
+  {
+    // Test deserialization when TimeTicks have advanced but wall clock hasn't
+    // (e.g. it's an hour later, but a DST change cancelled that out).
+    TestTickClock later_ticks;
+    later_ticks.set_now(base::TimeTicks() + TimeDelta::FromDays(1));
+    scoped_ptr<BackoffEntry> deserialized =
+        BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
+                                                     &later_ticks,
+                                                     base::Time());
+    ASSERT_TRUE(deserialized.get());
+    EXPECT_EQ(original.failure_count(), deserialized->failure_count());
+    EXPECT_EQ(original.GetReleaseTime() + TimeDelta::FromDays(1),
+              deserialized->GetReleaseTime());
+  }
+
+  {
+    // Test deserialization when both wall clock and TimeTicks have advanced
+    // (e.g. it's just later than it's used to be).
+    TestTickClock later_ticks;
+    later_ticks.set_now(base::TimeTicks() + TimeDelta::FromDays(1));
+    base::Time later = base::Time() + TimeDelta::FromDays(1);
+    scoped_ptr<BackoffEntry> deserialized =
+        BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
+                                                     &later_ticks, later);
+    ASSERT_TRUE(deserialized.get());
+    EXPECT_EQ(original.failure_count(), deserialized->failure_count());
+    EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
+  }
+
+  {
+    // Test deserialization when wall clock has gone backwards but TimeTicks
+    // haven't (e.g. the system clock was fast but they fixed it).
+    EXPECT_LT(TimeDelta::FromSeconds(1), original.GetTimeUntilRelease());
+    base::Time earlier = base::Time() - TimeDelta::FromSeconds(1);
+    scoped_ptr<BackoffEntry> deserialized =
+        BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
+                                                     &now_ticks, earlier);
+    ASSERT_TRUE(deserialized.get());
+    EXPECT_EQ(original.failure_count(), deserialized->failure_count());
+    // Deserialization should not exceed original time_until_release in such a
+    // situation.
+    EXPECT_EQ(original.GetTimeUntilRelease(),
+              deserialized->GetTimeUntilRelease());
+    // Since TimeTicks are equal, the release times will be too.
+    EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
+  }
+}
+
+TEST(BackoffEntryTest, SerializeNoFailures) {
+  TestTickClock now_ticks;
+  BackoffEntry original(&base_policy, &now_ticks);
+  scoped_ptr<base::ListValue> serialized =
+      BackoffEntrySerializer::SerializeToValue(original, base::Time());
+
+  scoped_ptr<BackoffEntry> deserialized =
+      BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
+                                                   &now_ticks, base::Time());
+  ASSERT_TRUE(deserialized.get());
+  EXPECT_EQ(original.failure_count(), deserialized->failure_count());
+  EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
+}
+
 }  // namespace
 
 }  // namespace net