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/process/process_info.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 379 matching lines @@
                                       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;
 
+  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_dict_lifetime = synthetic_delta;
+  base::TimeDelta expected_proc_lifetime = synthetic_delta +
+    base::Time::Now() -  base::CurrentProcessInfo::CreationTime();
+  size_t expected_value = ((kMaxSizeForTesting / 2) *
+                           expected_dict_lifetime.InMilliseconds()) /
+                          expected_proc_lifetime.InMilliseconds();
+
+  tester.ExpectTotalCount("Sdch3.TimeWeightedMemoryUse", 1);
+  tester.ExpectUniqueSample("Sdch3.TimeWeightedMemoryUse", expected_value, 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