Allow BackoffEntry to be serialized and deserialized.

net/base/backoff_entry_unittest.cc

 // Copyright (c) 2012 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/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:
   TestTickClock() {}
   ~TestTickClock() override {}
 
   TimeTicks NowTicks() override { return now_ticks_; }
   void set_now(TimeTicks now) { now_ticks_ = now; }
 
  private:
@@ skipping 275 matching lines @@
   for (int i = 0; i < 129; ++i) {
      now_ticks.set_now(now_ticks.NowTicks() + custom.GetTimeUntilRelease());
      custom.InformOfRequest(false);
      ASSERT_TRUE(custom.ShouldRejectRequest());
   }
 
   // Max delay should still be respected.
   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