chrome/browser/net/evicted_domain_cookie_counter_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/scoped_vector.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/time/time.h"
  13 #include "chrome/browser/net/evicted_domain_cookie_counter.h"
  14 #include "net/cookies/canonical_cookie.h"
  15 #include "net/cookies/cookie_monster.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "url/gurl.h"
  18
  19 namespace chrome_browser_net {
  20
  21 using base::Time;
  22 using base::TimeDelta;
  23
  24 namespace {
  25
  26 const char* google_url1 = "http://www.google.com";
  27 const char* google_url2 = "http://mail.google.com";
  28 const char* other_url1 = "http://www.example.com";
  29 const char* other_url2 = "http://www.example.co.uk";
  30
  31 class EvictedDomainCookieCounterTest : public testing::Test {
  32  protected:
  33   class MockDelegate : public EvictedDomainCookieCounter::Delegate {
  34    public:
  35     explicit MockDelegate(EvictedDomainCookieCounterTest* tester);
  36
  37     // EvictedDomainCookieCounter::Delegate implementation.
  38     virtual void Report(
  39         const EvictedDomainCookieCounter::EvictedCookie& evicted_cookie,
  40         const Time& reinstatement_time) OVERRIDE;
  41     virtual Time CurrentTime() const OVERRIDE;
  42
  43    private:
  44     EvictedDomainCookieCounterTest* tester_;
  45   };
  46
  47   EvictedDomainCookieCounterTest();
  48   virtual ~EvictedDomainCookieCounterTest();
  49
  50   // testing::Test implementation.
  51   virtual void SetUp() OVERRIDE;
  52   virtual void TearDown() OVERRIDE;
  53
  54   // Initialization that allows parameters to be specified.
  55   void InitCounter(size_t max_size, size_t purge_count);
  56
  57   // Wrapper to allocate new cookie and store it in |cookies_|.
  58   // If |max_age| == 0, then the cookie does not expire.
  59   void CreateNewCookie(
  60       const char* url, const std::string& cookie_line, int64 max_age);
  61
  62   // Clears |cookies_| and creates common cookies for multiple tests.
  63   void InitStockCookies();
  64
  65   // Sets simulation time to |rel_time|.
  66   void GotoTime(int64 rel_time);
  67
  68   // Simulates time-passage by |delta_second|.
  69   void StepTime(int64 delta_second);
  70
  71   // Simulates cookie addition or update.
  72   void Add(net::CanonicalCookie* cookie);
  73
  74   // Simulates cookie removal.
  75   void Remove(net::CanonicalCookie* cookie);
  76
  77   // Simulates cookie eviction.
  78   void Evict(net::CanonicalCookie* cookie);
  79
  80   // For semi-realism, time considered are relative to |mock_time_base_|.
  81   Time mock_time_base_;
  82   Time mock_time_;
  83
  84   // To store allocated cookies for reuse.
  85   ScopedVector<net::CanonicalCookie> cookies_;
  86
  87   scoped_refptr<EvictedDomainCookieCounter> cookie_counter_;
  88
  89   // Statistics as comma-separated string of duration (in seconds) between
  90   // eviction and reinstatement for each cookie, in the order of eviction.
  91   std::string google_stat_;
  92   std::string other_stat_;
  93 };
  94
  95 EvictedDomainCookieCounterTest::MockDelegate::MockDelegate(
  96     EvictedDomainCookieCounterTest* tester)
  97     : tester_(tester) {}
  98
  99 void EvictedDomainCookieCounterTest::MockDelegate::Report(
 100     const EvictedDomainCookieCounter::EvictedCookie& evicted_cookie,
 101     const Time& reinstatement_time) {
 102   std::string& dest = evicted_cookie.is_google ?
 103       tester_->google_stat_ : tester_->other_stat_;
 104   if (!dest.empty())
 105     dest.append(",");
 106   TimeDelta delta(reinstatement_time - evicted_cookie.eviction_time);
 107   dest.append(base::Int64ToString(delta.InSeconds()));
 108 }
 109
 110 Time EvictedDomainCookieCounterTest::MockDelegate::CurrentTime() const {
 111   return tester_->mock_time_;
 112 }
 113
 114 EvictedDomainCookieCounterTest::EvictedDomainCookieCounterTest() {}
 115
 116 EvictedDomainCookieCounterTest::~EvictedDomainCookieCounterTest() {}
 117
 118 void EvictedDomainCookieCounterTest::SetUp() {
 119   mock_time_base_ = Time::Now() - TimeDelta::FromHours(1);
 120   mock_time_ = mock_time_base_;
 121 }
 122
 123 void EvictedDomainCookieCounterTest::TearDown() {
 124 }
 125
 126 void EvictedDomainCookieCounterTest::InitCounter(size_t max_size,
 127                                                  size_t purge_count) {
 128   scoped_ptr<MockDelegate> cookie_counter_delegate(new MockDelegate(this));
 129   cookie_counter_ = new EvictedDomainCookieCounter(
 130       NULL,
 131       cookie_counter_delegate.PassAs<EvictedDomainCookieCounter::Delegate>(),
 132       max_size,
 133       purge_count);
 134 }
 135
 136 void EvictedDomainCookieCounterTest::CreateNewCookie(
 137     const char* url, const std::string& cookie_line, int64 max_age) {
 138   std::string line(cookie_line);
 139   if (max_age)
 140     line.append(";max-age=" + base::Int64ToString(max_age));
 141   net::CanonicalCookie* cookie = net::CanonicalCookie::Create(
 142       GURL(url), line, mock_time_, net::CookieOptions());
 143   DCHECK(cookie);
 144   cookies_.push_back(cookie);
 145 }
 146
 147 void EvictedDomainCookieCounterTest::InitStockCookies() {
 148   cookies_.clear();
 149   CreateNewCookie(google_url1, "a1=1", 3000);           // cookies_[0].
 150   CreateNewCookie(google_url2, "a2=1", 2000);           // cookies_[1].
 151   CreateNewCookie(other_url1, "a1=1", 1000);            // cookies_[2].
 152   CreateNewCookie(other_url1, "a2=1", 1001);            // cookies_[3].
 153   CreateNewCookie(google_url1, "a1=1;Path=/sub", 999);  // cookies_[4].
 154   CreateNewCookie(other_url2, "a2=1", 0);               // cookies_[5].
 155 }
 156
 157 void EvictedDomainCookieCounterTest::GotoTime(int64 rel_time) {
 158   mock_time_ = mock_time_base_ + TimeDelta::FromSeconds(rel_time);
 159 }
 160
 161 void EvictedDomainCookieCounterTest::StepTime(int64 delta_second) {
 162   mock_time_ += TimeDelta::FromSeconds(delta_second);
 163 }
 164
 165 void EvictedDomainCookieCounterTest::Add(net::CanonicalCookie* cookie) {
 166   cookie_counter_->OnCookieChanged(
 167       *cookie, false, net::CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT);
 168 }
 169
 170 void EvictedDomainCookieCounterTest::Remove(net::CanonicalCookie* cookie) {
 171   cookie_counter_->OnCookieChanged(
 172       *cookie, true, net::CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT);
 173 }
 174
 175 void EvictedDomainCookieCounterTest::Evict(net::CanonicalCookie* cookie) {
 176   cookie_counter_->OnCookieChanged(
 177       *cookie, true, net::CookieMonster::Delegate::CHANGE_COOKIE_EVICTED);
 178 }
 179
 180 // EvictedDomainCookieCounter takes (and owns) a CookieMonster::Delegate for
 181 // chaining. To ensure that the chaining indeed occurs, we implement a
 182 // dummy CookieMonster::Delegate to increment an integer.
 183 TEST_F(EvictedDomainCookieCounterTest, TestChain) {
 184   int result = 0;
 185
 186   class ChangedDelegateDummy : public net::CookieMonster::Delegate {
 187    public:
 188     explicit ChangedDelegateDummy(int* result) : result_(result) {}
 189
 190     virtual void OnCookieChanged(const net::CanonicalCookie& cookie,
 191                                  bool removed,
 192                                  ChangeCause cause) OVERRIDE {
 193       ++(*result_);
 194     }
 195
 196    private:
 197     virtual ~ChangedDelegateDummy() {}
 198
 199     int* result_;
 200   };
 201
 202   scoped_ptr<MockDelegate> cookie_counter_delegate(new MockDelegate(this));
 203   cookie_counter_ = new EvictedDomainCookieCounter(
 204       new ChangedDelegateDummy(&result),
 205       cookie_counter_delegate.PassAs<EvictedDomainCookieCounter::Delegate>(),
 206       10,
 207       5);
 208   InitStockCookies();
 209   // Perform 6 cookie transactions.
 210   for (int i = 0; i < 6; ++i) {
 211     Add(cookies_[i]);
 212     StepTime(1);
 213     Evict(cookies_[i]);
 214     StepTime(1);
 215     Remove(cookies_[i]);
 216   }
 217   EXPECT_EQ(18, result);  // 6 cookies x 3 operations each.
 218 }
 219
 220 // Basic flow: add cookies, evict, then reinstate.
 221 TEST_F(EvictedDomainCookieCounterTest, TestBasicFlow) {
 222   InitCounter(10, 4);
 223   InitStockCookies();
 224   // Add all cookies at (relative time) t = 0.
 225   for (int i = 0; i < 6; ++i)
 226     Add(cookies_[i]);
 227   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());  // No activities on add.
 228   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 229   // Evict cookies at t = [1,3,6,10,15,21].
 230   for (int i = 0; i < 6; ++i) {
 231     StepTime(i + 1);
 232     Evict(cookies_[i]);
 233   }
 234   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());  // Storing all evictions.
 235   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 236   // Reinstate cookies at t = [22,23,24,25,26,27].
 237   for (int i = 0; i < 6; ++i) {
 238     StepTime(1);
 239     Add(cookies_[i]);
 240   }
 241   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());  // Everything is removed.
 242   // Expected reinstatement delays: [21,20,18,15,11,6].
 243   EXPECT_EQ("21,20,11;18,15,6", google_stat_ + ";" + other_stat_);
 244 }
 245
 246 // Removed cookies are ignored by EvictedDomainCookieCounter.
 247 TEST_F(EvictedDomainCookieCounterTest, TestRemove) {
 248   InitCounter(10, 4);
 249   InitStockCookies();
 250   // Add all cookies at (relative time) t = 0.
 251   for (int i = 0; i < 6; ++i)
 252     Add(cookies_[i]);
 253   // Remove cookies at t = [1,3,6,10,15,21].
 254   for (int i = 0; i < 6; ++i) {
 255     StepTime(i + 1);
 256     Remove(cookies_[i]);
 257   }
 258   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 259   // Add cookies again at t = [22,23,24,25,26,27].
 260   for (int i = 0; i < 5; ++i) {
 261     StepTime(1);
 262     Add(cookies_[i]);
 263   }
 264   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 265   // No cookies were evicted, so no reinstatement take place.
 266   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 267 }
 268
 269 // Expired cookies should not be counted by EvictedDomainCookieCounter.
 270 TEST_F(EvictedDomainCookieCounterTest, TestExpired) {
 271   InitCounter(10, 4);
 272   InitStockCookies();
 273   // Add all cookies at (relative time) t = 0.
 274   for (int i = 0; i < 6; ++i)
 275     Add(cookies_[i]);
 276   // Evict cookies at t = [1,3,6,10,15,21].
 277   for (int i = 0; i < 6; ++i) {
 278     StepTime(i + 1);
 279     Evict(cookies_[i]);
 280   }
 281   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());
 282   GotoTime(1000);  // t = 1000, so cookies_[2,4] expire.
 283
 284   // Reinstate cookies at t = [1000,1000,(1000),1000,(1000),1000].
 285   InitStockCookies();  // Refresh cookies, so new cookies expire in the future.
 286   for (int i = 0; i < 6; ++i)
 287     Add(cookies_[i]);
 288   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 289   // Reinstatement delays: [999,997,(994),990,(985),979].
 290   EXPECT_EQ("999,997;990,979", google_stat_ + ";" + other_stat_);
 291 }
 292
 293 // Garbage collection should remove the oldest evicted cookies.
 294 TEST_F(EvictedDomainCookieCounterTest, TestGarbageCollection) {
 295   InitCounter(4, 2);  // Reduced capacity.
 296   InitStockCookies();
 297   // Add all cookies at (relative time) t = 0.
 298   for (int i = 0; i < 6; ++i)
 299     Add(cookies_[i]);
 300   // Evict cookies at t = [1,3,6,10].
 301   for (int i = 0; i < 4; ++i) {
 302     StepTime(i + 1);
 303     Evict(cookies_[i]);
 304   }
 305   EXPECT_EQ(4u, cookie_counter_->GetStorageSize());  // Reached capacity.
 306   StepTime(5);
 307   Evict(cookies_[4]);  // Evict at t = 15, garbage collection takes place.
 308   EXPECT_EQ(2u, cookie_counter_->GetStorageSize());
 309   StepTime(6);
 310   Evict(cookies_[5]);  // Evict at t = 21.
 311   EXPECT_EQ(3u, cookie_counter_->GetStorageSize());
 312   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 313   // Reinstate cookies at t = [(100),(100),(100),100,100,100].
 314   GotoTime(100);
 315   for (int i = 0; i < 6; ++i)
 316     Add(cookies_[i]);
 317   // Expected reinstatement delays: [(99),(97),(94),90,85,79]
 318   EXPECT_EQ("85;90,79", google_stat_ + ";" + other_stat_);
 319 }
 320
 321 // Garbage collection should remove the specified number of evicted cookies
 322 // even when there are ties amongst oldest evicted cookies.
 323 TEST_F(EvictedDomainCookieCounterTest, TestGarbageCollectionTie) {
 324   InitCounter(9, 3);
 325   // Add 10 cookies at time [0,1,3,6,...,45]
 326   for (int i = 0; i < 10; ++i) {
 327     StepTime(i);
 328     CreateNewCookie(google_url1, "a" + base::IntToString(i) + "=1", 3000);
 329     Add(cookies_[i]);
 330   }
 331   // Evict 6 cookies at t = [100,...,100].
 332   GotoTime(100);
 333   for (int i = 0; i < 6; ++i)
 334     Evict(cookies_[i]);
 335   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());
 336   // Evict 3 cookies at t = [210,220,230].
 337   GotoTime(200);
 338   for (int i = 6; i < 9; ++i) {
 339     StepTime(10);
 340     Evict(cookies_[i]);
 341   }
 342   EXPECT_EQ(9u, cookie_counter_->GetStorageSize());  // Reached capacity.
 343   // Evict 1 cookie at t = 300, and garbage collection takes place.
 344   GotoTime(300);
 345   Evict(cookies_[9]);
 346   // Some arbitrary 4 out of 6 cookies evicted at t = 100 are gone from storage.
 347   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());  // 10 - 4.
 348   // Reinstate cookies at t = [400,...,400].
 349   GotoTime(400);
 350   for (int i = 0; i < 10; ++i)
 351     Add(cookies_[i]);
 352   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 353   // Expected reinstatement delays:
 354   // [300,300,300,300,300,300 <= keeping 2 only,190,180,170,100].
 355   EXPECT_EQ("300,300,190,180,170,100;", google_stat_ + ";" + other_stat_);
 356 }
 357
 358 // Garbage collection prioritize removal of expired cookies.
 359 TEST_F(EvictedDomainCookieCounterTest, TestGarbageCollectionWithExpiry) {
 360   InitCounter(5, 1);
 361   InitStockCookies();
 362   // Add all cookies at (relative time) t = 0.
 363   for (int i = 0; i < 6; ++i)
 364     Add(cookies_[i]);
 365   // Evict cookies at t = [1,3,6,10,15].
 366   for (int i = 0; i < 5; ++i) {
 367     StepTime(i + 1);
 368     Evict(cookies_[i]);
 369   }
 370   EXPECT_EQ(5u, cookie_counter_->GetStorageSize());  // Reached capacity.
 371   GotoTime(1200);  // t = 1200, so cookies_[2,3,4] expire.
 372   // Evict cookies_[5] (not expired) at t = 1200.
 373   Evict(cookies_[5]);
 374   // Garbage collection would have taken place, removing 3 expired cookies,
 375   // so that there's no need to remove more.
 376   EXPECT_EQ(3u, cookie_counter_->GetStorageSize());
 377   // Reinstate cookies at t = [1500,1500,(1500),(1500),(1500),1500].
 378   GotoTime(1500);
 379   InitStockCookies();  // Refresh cookies, so new cookies expire in the future.
 380   for (int i = 0; i < 6; ++i)
 381     Add(cookies_[i]);
 382   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 383   // Reinstatement delays: [1499,1497,(1494),(1490),(1485),300].
 384   EXPECT_EQ("1499,1497;300", google_stat_ + ";" + other_stat_);
 385 }
 386
 387 }  // namespace
 388
 389 }  // namespace chrome_browser_net