Make SDCH dictionaries persistent across browser restart.

net/sdch/sdch_owner_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 "base/memory/memory_pressure_listener.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "net/base/net_log.h"
 #include "net/base/sdch_manager.h"
@@ skipping 102 matching lines @@
 
   bool IsHandledURL(const GURL& url) const override {
     return url.SchemeIs("http");
   }
 
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 };
 
+// File testing infrastructure summary:
+// * NewSdchDictionary(): Creates a dictionary of a specific size.
+// * URLRequestErrorCountingJob: A URLRequestJob that returns an error
+//   and counts the number of outstanding (started but not finished)
+//   jobs, and calls a global callback when that number transitions to zero.
+// * MockURLRequestJobFactory: Factory to create the above jobs.  Tracks
+//   the number of jobs created.
+// * SdchOwnerTest: Interfaces
+//      * Access manager, owner, and net log
+//      * Return the number of jobs created in a time interval
+//      * Return dictionary present in the manager
+//      * Notify SdchOwner of an incoming dictionary (& wait until jobs clear)
+//      * Attempt to add a dictionary and test for success.
+// Test patterns:
+//      * Let the owner know about a Get-Dictionary header and test for
+//        appropriate jobs being created.
+//      * Let the owner know that a dictionary was successfully fetched
+//        and test for appropriate outcome.
+//      * Either of the above, having previously added dictionaries to create
+//        a particular initial state.
 class SdchOwnerTest : public testing::Test {
  public:
   static const size_t kMaxSizeForTesting = 1000 * 50;
   static const size_t kMinFetchSpaceForTesting = 500;
 
   SdchOwnerTest()
       : last_jobs_created_(error_jobs_created),
         dictionary_creation_index_(0),
         sdch_owner_(&sdch_manager_, &url_request_context_) {
     // Any jobs created on this context will immediately error,
@@ skipping 32 matching lines @@
     base::Closure quit_closure(run_loop.QuitClosure());
     empty_url_request_jobs_callback = &quit_closure;
     run_loop.Run();
     empty_url_request_jobs_callback = NULL;
   }
 
   // Create a unique (by hash) dictionary of the given size,
   // associate it with a unique URL, add it to the manager through
   // SdchOwner::OnDictionaryFetched(), and return whether that
   // addition was successful or not.
-  bool CreateAndAddDictionary(size_t size, std::string* server_hash_p) {
+  bool CreateAndAddDictionary(size_t size,
+                              std::string* server_hash_p,
+                              base::Time last_used_time) {
     GURL dictionary_url(
         base::StringPrintf("%s/d%d", generic_url, dictionary_creation_index_));
     std::string dictionary_text(NewSdchDictionary(size - 4));
     dictionary_text += base::StringPrintf("%04d", dictionary_creation_index_);
     ++dictionary_creation_index_;
     std::string client_hash;
     std::string server_hash;
     SdchManager::GenerateHash(dictionary_text, &client_hash, &server_hash);
 
     if (DictionaryPresentInManager(server_hash))
       return false;
-    sdch_owner().OnDictionaryFetched(dictionary_text, dictionary_url, net_log_);
+    sdch_owner().OnDictionaryFetched(last_used_time, 0, dictionary_text,
+                                     dictionary_url, net_log_);
     if (server_hash_p)
       *server_hash_p = server_hash;
     return DictionaryPresentInManager(server_hash);
   }
 
  private:
   int last_jobs_created_;
   BoundNetLog net_log_;
   int dictionary_creation_index_;
 
@@ skipping 15 matching lines @@
 
   // Fetch generated when empty.
   GURL dict_url1(std::string(generic_url) + "/d1");
   EXPECT_EQ(0, JobsRecentlyCreated());
   SignalGetDictionaryAndClearJobs(request_url, dict_url1);
   EXPECT_EQ(1, JobsRecentlyCreated());
 
   // Fetch generated when half full.
   GURL dict_url2(std::string(generic_url) + "/d2");
   std::string dictionary1(NewSdchDictionary(kMaxSizeForTesting / 2));
-  sdch_owner().OnDictionaryFetched(dictionary1, dict_url1, bound_net_log());
+  sdch_owner().OnDictionaryFetched(base::Time::Now(), 1, dictionary1, dict_url1,
+                                   bound_net_log());
   EXPECT_EQ(0, JobsRecentlyCreated());
   SignalGetDictionaryAndClearJobs(request_url, dict_url2);
   EXPECT_EQ(1, JobsRecentlyCreated());
 
   // Fetch not generated when close to completely full.
   GURL dict_url3(std::string(generic_url) + "/d3");
   std::string dictionary2(NewSdchDictionary(
       (kMaxSizeForTesting / 2 - kMinFetchSpaceForTesting / 2)));
-  sdch_owner().OnDictionaryFetched(dictionary2, dict_url2, bound_net_log());
+  sdch_owner().OnDictionaryFetched(base::Time::Now(), 1, dictionary2, dict_url2,
+                                   bound_net_log());
   EXPECT_EQ(0, JobsRecentlyCreated());
   SignalGetDictionaryAndClearJobs(request_url, dict_url3);
   EXPECT_EQ(0, JobsRecentlyCreated());
 }
 
 // Make sure attempts to add dictionaries do what they should.
 TEST_F(SdchOwnerTest, OnDictionaryFetched_Fetching) {
   GURL request_url(std::string(generic_url) + "/r1");
   std::string client_hash;
   std::string server_hash;
 
+  // In the past, but still fresh for an unused dictionary.
+  base::Time dictionary_last_used_time(base::Time::Now() -
+                                       base::TimeDelta::FromMinutes(30));
+
   // Add successful when empty.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr,
+                                     dictionary_last_used_time));
   EXPECT_EQ(0, JobsRecentlyCreated());
 
   // Add successful when half full.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr,
+                                     dictionary_last_used_time));
   EXPECT_EQ(0, JobsRecentlyCreated());
 
   // Add unsuccessful when full.
-  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr));
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr,
+                                      dictionary_last_used_time));
   EXPECT_EQ(0, JobsRecentlyCreated());
 }
 
 // Confirm auto-eviction happens if space is needed.
 TEST_F(SdchOwnerTest, ConfirmAutoEviction) {
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
   // Add two dictionaries, one recent, one more than a day in the past.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d1));
+  base::Time fresh(base::Time::Now() - base::TimeDelta::FromHours(23));
+  base::Time stale(base::Time::Now() - base::TimeDelta::FromHours(25));
 
-  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
-  sdch_owner().SetClockForTesting(clock.Pass());
-
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d2));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d1, fresh));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d2, stale));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
 
-  // The addition of a new dictionary should succeed, evicting the old one.
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now());
-  sdch_owner().SetClockForTesting(clock.Pass());
-
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d3));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d3, fresh));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
 }
 
 // Confirm auto-eviction happens if space is needed, with a more complicated
 // situation
 TEST_F(SdchOwnerTest, ConfirmAutoEviction_2) {
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
   // Add dictionaries, one recent, two more than a day in the past that
   // between them add up to the space needed.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d1));
+  base::Time fresh(base::Time::Now() - base::TimeDelta::FromHours(23));
+  base::Time stale(base::Time::Now() - base::TimeDelta::FromHours(25));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d1, fresh));
 
-  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
-  sdch_owner().SetClockForTesting(clock.Pass());
-
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2, stale));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3, stale));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
 
-  // The addition of a new dictionary should succeed, evicting the old one.
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now());
-  sdch_owner().SetClockForTesting(clock.Pass());
-
   std::string server_hash_d4;
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4, fresh));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d3));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d4));
 }
 
 // Confirm if only one dictionary needs to be evicted it's the oldest.
 TEST_F(SdchOwnerTest, ConfirmAutoEviction_Oldest) {
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
   // Add dictionaries, one recent, one two days in the past, and one
   // four days in the past.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1));
+  base::Time fresh(base::Time::Now() - base::TimeDelta::FromHours(23));
+  base::Time stale_newer(base::Time::Now() - base::TimeDelta::FromHours(47));
+  base::Time stale_older(base::Time::Now() - base::TimeDelta::FromHours(71));
 
-  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
-  sdch_owner().SetClockForTesting(clock.Pass());
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1, fresh));
 
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(4));
-  sdch_owner().SetClockForTesting(clock.Pass());
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2,
+                                     stale_newer));
+
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3,
+                                     stale_older));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
 
   // The addition of a new dictionary should succeed, evicting only the
   // oldest one.
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now());
-  sdch_owner().SetClockForTesting(clock.Pass());
 
   std::string server_hash_d4;
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4, fresh));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d3));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d4));
 }
 
 // Confirm using a dictionary changes eviction behavior properly.
 TEST_F(SdchOwnerTest, UseChangesEviction) {
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
   // Add dictionaries, one recent, one two days in the past, and one
   // four days in the past.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1));
+  base::Time fresh(base::Time::Now() - base::TimeDelta::FromHours(23));
+  base::Time stale_newer(base::Time::Now() - base::TimeDelta::FromHours(47));
+  base::Time stale_older(base::Time::Now() - base::TimeDelta::FromHours(71));
 
-  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
-  sdch_owner().SetClockForTesting(clock.Pass());
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1, fresh));
 
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(4));
-  sdch_owner().SetClockForTesting(clock.Pass());
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2,
+                                     stale_newer));
+
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3,
+                                     stale_older));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
 
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now());
-  sdch_owner().SetClockForTesting(clock.Pass());
-
   // Use the oldest dictionary.
   sdch_owner().OnDictionaryUsed(&sdch_manager(), server_hash_d3);
 
   // The addition of a new dictionary should succeed, evicting only the
   // newer stale one.
   std::string server_hash_d4;
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4, fresh));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d4));
 }
 
 // Confirm using a dictionary can prevent the addition of a new dictionary.
 TEST_F(SdchOwnerTest, UsePreventsAddition) {
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
   // Add dictionaries, one recent, one two days in the past, and one
   // four days in the past.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1));
+  base::Time fresh(base::Time::Now() - base::TimeDelta::FromMinutes(30));
+  base::Time stale_newer(base::Time::Now() - base::TimeDelta::FromHours(47));
+  base::Time stale_older(base::Time::Now() - base::TimeDelta::FromHours(71));
 
-  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
-  sdch_owner().SetClockForTesting(clock.Pass());
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1, fresh));
 
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(4));
-  sdch_owner().SetClockForTesting(clock.Pass());
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2,
+                                     stale_newer));
+
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3,
+                                     stale_older));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
 
-  clock.reset(new base::SimpleTestClock);
-  clock->SetNow(base::Time::Now());
-  sdch_owner().SetClockForTesting(clock.Pass());
-
   // Use the older dictionaries.
   sdch_owner().OnDictionaryUsed(&sdch_manager(), server_hash_d2);
   sdch_owner().OnDictionaryUsed(&sdch_manager(), server_hash_d3);
 
   // The addition of a new dictionary should fail, not evicting anything.
   std::string server_hash_d4;
-  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_FALSE(
+      CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4, fresh));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d4));
 }
 
 // Confirm clear gets all the space back.
 TEST_F(SdchOwnerTest, ClearReturnsSpace) {
   std::string server_hash_d1;
   std::string server_hash_d2;
 
   // Take up all the space.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d1));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d1,
+                                     base::Time::Now()));
 
   // Addition should fail.
-  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d2));
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d2,
+                                      base::Time::Now()));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
 
   sdch_manager().ClearData();
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
 
   // Addition should now succeed.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, nullptr));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting, nullptr, base::Time::Now()));
 }
 
 // Confirm memory pressure gets all the space back.
 TEST_F(SdchOwnerTest, MemoryPressureReturnsSpace) {
   std::string server_hash_d1;
   std::string server_hash_d2;
 
   // Take up all the space.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d1));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d1,
+                                     base::Time::Now()));
 
   // Addition should fail.
-  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d2));
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d2,
+                                      base::Time::Now()));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
 
   base::MemoryPressureListener::NotifyMemoryPressure(
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
   // The notification may have (implementation note: does :-}) use a PostTask,
   // so we drain the local message queue.  This should be safe (i.e. not have
   // an inifinite number of messages) in a unit test.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
 
   // Addition should now succeed.
-  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, nullptr));
+  EXPECT_TRUE(
+      CreateAndAddDictionary(kMaxSizeForTesting, nullptr, base::Time::Now()));
 }
 
 }  // namespace net