SDCH: add TimeWeightedMemoryUse

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/prefs/testing_pref_store.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "net/base/net_log.h"
 #include "net/base/sdch_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
@@ skipping 228 matching lines @@
 //        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),
         pref_store_(new TestingPrefStore),
-        sdch_owner_(&sdch_manager_, &url_request_context_) {
+        sdch_owner_(new SdchOwner(&sdch_manager_, &url_request_context_)) {
     // Any jobs created on this context will immediately error,
     // which leaves the test in control of signals to SdchOwner.
     url_request_context_.set_job_factory(&job_factory_);
 
     // Reduce sizes to reduce time for string operations.
-    sdch_owner_.SetMaxTotalDictionarySize(kMaxSizeForTesting);
-    sdch_owner_.SetMinSpaceForDictionaryFetch(kMinFetchSpaceForTesting);
+    sdch_owner_->SetMaxTotalDictionarySize(kMaxSizeForTesting);
+    sdch_owner_->SetMinSpaceForDictionaryFetch(kMinFetchSpaceForTesting);
   }
 
   SdchManager& sdch_manager() { return sdch_manager_; }
-  SdchOwner& sdch_owner() { return sdch_owner_; }
+  SdchOwner& sdch_owner() { return *(sdch_owner_.get()); }
   BoundNetLog& bound_net_log() { return net_log_; }
   TestingPrefStore& pref_store() { return *(pref_store_.get()); }
 
   int JobsRecentlyCreated() {
     int result = error_jobs_created - last_jobs_created_;
     last_jobs_created_ = error_jobs_created;
     return result;
   }
 
   bool DictionaryPresentInManager(const std::string& server_hash) {
@@ skipping 39 matching lines @@
 
     if (DictionaryPresentInManager(server_hash))
       return false;
     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);
   }
 
+  void ResetOwner() {
+    sdch_owner_.reset(new SdchOwner(&sdch_manager_, &url_request_context_));
+  }
+
  private:
   int last_jobs_created_;
   BoundNetLog net_log_;
   int dictionary_creation_index_;
 
   // The dependencies of these objects (sdch_owner_ -> {sdch_manager_,
   // url_request_context_}, url_request_context_->job_factory_) require
   // this order for correct destruction semantics.
   MockURLRequestJobFactory job_factory_;
   URLRequestContext url_request_context_;
   SdchManager sdch_manager_;
   scoped_refptr<TestingPrefStore> pref_store_;
-  SdchOwner sdch_owner_;
+  scoped_ptr<SdchOwner> sdch_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchOwnerTest);
 };
 
 // Does OnGetDictionary result in a fetch when there's enough space, and not
 // when there's not?
 TEST_F(SdchOwnerTest, OnGetDictionary_Fetching) {
   GURL request_url(std::string(generic_url) + "/r1");
 
   // Fetch generated when empty.
@@ skipping 43 matching lines @@
   EXPECT_EQ(0, JobsRecentlyCreated());
 
   // Add unsuccessful when full.
   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) {
+  base::Time start_time = base::Time::Now();
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
+  base::SimpleTestClock* test_clock = new base::SimpleTestClock();
+  sdch_owner().SetClockForTesting(make_scoped_ptr(test_clock));
+  test_clock->SetNow(base::Time::Now());
+
   // Add two dictionaries, one recent, one more than a day in the past.
   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));
   EXPECT_TRUE(
       CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d2, stale));
 
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
 
+  base::HistogramTester tester;
+  const base::TimeDelta synthetic_delta = base::TimeDelta::FromSeconds(5);
+
+  test_clock->Advance(synthetic_delta);
+
   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));
+
+  base::TimeDelta expected_proc_lifetime = synthetic_delta * 3 +
+    base::Time::Now() -  start_time;
+  size_t expected_value_base = ((kMaxSizeForTesting / 2) *
+                                synthetic_delta.InMilliseconds()) /
+                                expected_proc_lifetime.InMilliseconds();
+
+  const char *kHistogram = "Sdch3.TimeWeightedMemoryUse";
+  tester.ExpectTotalCount(kHistogram, 0);
+
+  // Dictionary insertions and deletions:
+  // T = 0: insert d1 and d2
+  // T = 5: insert d3, which evicts d2
+  // T = 15: destroy SdchOwner, which evicts d1 and d3
+  // Therefore, d2's lifetime is synthetic_delta, d1's is synthetic_delta * 3,
+  // and d3's is synthetic_delta * 2. The expected_value_base variable is the
+  // base factor for d2's memory consumption, of which d1's and d3's are
+  // multiples.
+  test_clock->Advance(synthetic_delta * 2);
+  ResetOwner();
+
+  tester.ExpectTotalCount(kHistogram, 3);
+  tester.ExpectBucketCount(kHistogram, expected_value_base, 1);
+  tester.ExpectBucketCount(kHistogram, expected_value_base * 2, 1);
+  tester.ExpectBucketCount(kHistogram, expected_value_base * 3, 1);
 }
 
 // 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
@@ skipping 412 matching lines @@
 
   ResetOwner(true);
   InsertDictionaryForURL(url0, "0");
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
   owner_->EnablePersistentStorage(pref_store_.get());
   ASSERT_TRUE(CompleteLoadFromURL(url1, "1"));
   EXPECT_EQ(2, owner_->GetDictionaryCountForTesting());
 }
 
 }  // namespace net