src/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     virtual void OnLoaded() OVERRIDE {}
 197
 198    private:
 199     virtual ~ChangedDelegateDummy() {}
 200
 201     int* result_;
 202   };
 203
 204   scoped_ptr<MockDelegate> cookie_counter_delegate(new MockDelegate(this));
 205   cookie_counter_ = new EvictedDomainCookieCounter(
 206       new ChangedDelegateDummy(&result),
 207       cookie_counter_delegate.PassAs<EvictedDomainCookieCounter::Delegate>(),
 208       10,
 209       5);
 210   InitStockCookies();
 211   // Perform 6 cookie transactions.
 212   for (int i = 0; i < 6; ++i) {
 213     Add(cookies_[i]);
 214     StepTime(1);
 215     Evict(cookies_[i]);
 216     StepTime(1);
 217     Remove(cookies_[i]);
 218   }
 219   EXPECT_EQ(18, result);  // 6 cookies x 3 operations each.
 220 }
 221
 222 // Basic flow: add cookies, evict, then reinstate.
 223 TEST_F(EvictedDomainCookieCounterTest, TestBasicFlow) {
 224   InitCounter(10, 4);
 225   InitStockCookies();
 226   // Add all cookies at (relative time) t = 0.
 227   for (int i = 0; i < 6; ++i)
 228     Add(cookies_[i]);
 229   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());  // No activities on add.
 230   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 231   // Evict cookies at t = [1,3,6,10,15,21].
 232   for (int i = 0; i < 6; ++i) {
 233     StepTime(i + 1);
 234     Evict(cookies_[i]);
 235   }
 236   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());  // Storing all evictions.
 237   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 238   // Reinstate cookies at t = [22,23,24,25,26,27].
 239   for (int i = 0; i < 6; ++i) {
 240     StepTime(1);
 241     Add(cookies_[i]);
 242   }
 243   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());  // Everything is removed.
 244   // Expected reinstatement delays: [21,20,18,15,11,6].
 245   EXPECT_EQ("21,20,11;18,15,6", google_stat_ + ";" + other_stat_);
 246 }
 247
 248 // Removed cookies are ignored by EvictedDomainCookieCounter.
 249 TEST_F(EvictedDomainCookieCounterTest, TestRemove) {
 250   InitCounter(10, 4);
 251   InitStockCookies();
 252   // Add all cookies at (relative time) t = 0.
 253   for (int i = 0; i < 6; ++i)
 254     Add(cookies_[i]);
 255   // Remove cookies at t = [1,3,6,10,15,21].
 256   for (int i = 0; i < 6; ++i) {
 257     StepTime(i + 1);
 258     Remove(cookies_[i]);
 259   }
 260   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 261   // Add cookies again at t = [22,23,24,25,26,27].
 262   for (int i = 0; i < 5; ++i) {
 263     StepTime(1);
 264     Add(cookies_[i]);
 265   }
 266   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 267   // No cookies were evicted, so no reinstatement take place.
 268   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 269 }
 270
 271 // Expired cookies should not be counted by EvictedDomainCookieCounter.
 272 TEST_F(EvictedDomainCookieCounterTest, TestExpired) {
 273   InitCounter(10, 4);
 274   InitStockCookies();
 275   // Add all cookies at (relative time) t = 0.
 276   for (int i = 0; i < 6; ++i)
 277     Add(cookies_[i]);
 278   // Evict cookies at t = [1,3,6,10,15,21].
 279   for (int i = 0; i < 6; ++i) {
 280     StepTime(i + 1);
 281     Evict(cookies_[i]);
 282   }
 283   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());
 284   GotoTime(1000);  // t = 1000, so cookies_[2,4] expire.
 285
 286   // Reinstate cookies at t = [1000,1000,(1000),1000,(1000),1000].
 287   InitStockCookies();  // Refresh cookies, so new cookies expire in the future.
 288   for (int i = 0; i < 6; ++i)
 289     Add(cookies_[i]);
 290   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 291   // Reinstatement delays: [999,997,(994),990,(985),979].
 292   EXPECT_EQ("999,997;990,979", google_stat_ + ";" + other_stat_);
 293 }
 294
 295 // Garbage collection should remove the oldest evicted cookies.
 296 TEST_F(EvictedDomainCookieCounterTest, TestGarbageCollection) {
 297   InitCounter(4, 2);  // Reduced capacity.
 298   InitStockCookies();
 299   // Add all cookies at (relative time) t = 0.
 300   for (int i = 0; i < 6; ++i)
 301     Add(cookies_[i]);
 302   // Evict cookies at t = [1,3,6,10].
 303   for (int i = 0; i < 4; ++i) {
 304     StepTime(i + 1);
 305     Evict(cookies_[i]);
 306   }
 307   EXPECT_EQ(4u, cookie_counter_->GetStorageSize());  // Reached capacity.
 308   StepTime(5);
 309   Evict(cookies_[4]);  // Evict at t = 15, garbage collection takes place.
 310   EXPECT_EQ(2u, cookie_counter_->GetStorageSize());
 311   StepTime(6);
 312   Evict(cookies_[5]);  // Evict at t = 21.
 313   EXPECT_EQ(3u, cookie_counter_->GetStorageSize());
 314   EXPECT_EQ(";", google_stat_ + ";" + other_stat_);
 315   // Reinstate cookies at t = [(100),(100),(100),100,100,100].
 316   GotoTime(100);
 317   for (int i = 0; i < 6; ++i)
 318     Add(cookies_[i]);
 319   // Expected reinstatement delays: [(99),(97),(94),90,85,79]
 320   EXPECT_EQ("85;90,79", google_stat_ + ";" + other_stat_);
 321 }
 322
 323 // Garbage collection should remove the specified number of evicted cookies
 324 // even when there are ties amongst oldest evicted cookies.
 325 TEST_F(EvictedDomainCookieCounterTest, TestGarbageCollectionTie) {
 326   InitCounter(9, 3);
 327   // Add 10 cookies at time [0,1,3,6,...,45]
 328   for (int i = 0; i < 10; ++i) {
 329     StepTime(i);
 330     CreateNewCookie(google_url1, "a" + base::IntToString(i) + "=1", 3000);
 331     Add(cookies_[i]);
 332   }
 333   // Evict 6 cookies at t = [100,...,100].
 334   GotoTime(100);
 335   for (int i = 0; i < 6; ++i)
 336     Evict(cookies_[i]);
 337   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());
 338   // Evict 3 cookies at t = [210,220,230].
 339   GotoTime(200);
 340   for (int i = 6; i < 9; ++i) {
 341     StepTime(10);
 342     Evict(cookies_[i]);
 343   }
 344   EXPECT_EQ(9u, cookie_counter_->GetStorageSize());  // Reached capacity.
 345   // Evict 1 cookie at t = 300, and garbage collection takes place.
 346   GotoTime(300);
 347   Evict(cookies_[9]);
 348   // Some arbitrary 4 out of 6 cookies evicted at t = 100 are gone from storage.
 349   EXPECT_EQ(6u, cookie_counter_->GetStorageSize());  // 10 - 4.
 350   // Reinstate cookies at t = [400,...,400].
 351   GotoTime(400);
 352   for (int i = 0; i < 10; ++i)
 353     Add(cookies_[i]);
 354   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 355   // Expected reinstatement delays:
 356   // [300,300,300,300,300,300 <= keeping 2 only,190,180,170,100].
 357   EXPECT_EQ("300,300,190,180,170,100;", google_stat_ + ";" + other_stat_);
 358 }
 359
 360 // Garbage collection prioritize removal of expired cookies.
 361 TEST_F(EvictedDomainCookieCounterTest, TestGarbageCollectionWithExpiry) {
 362   InitCounter(5, 1);
 363   InitStockCookies();
 364   // Add all cookies at (relative time) t = 0.
 365   for (int i = 0; i < 6; ++i)
 366     Add(cookies_[i]);
 367   // Evict cookies at t = [1,3,6,10,15].
 368   for (int i = 0; i < 5; ++i) {
 369     StepTime(i + 1);
 370     Evict(cookies_[i]);
 371   }
 372   EXPECT_EQ(5u, cookie_counter_->GetStorageSize());  // Reached capacity.
 373   GotoTime(1200);  // t = 1200, so cookies_[2,3,4] expire.
 374   // Evict cookies_[5] (not expired) at t = 1200.
 375   Evict(cookies_[5]);
 376   // Garbage collection would have taken place, removing 3 expired cookies,
 377   // so that there's no need to remove more.
 378   EXPECT_EQ(3u, cookie_counter_->GetStorageSize());
 379   // Reinstate cookies at t = [1500,1500,(1500),(1500),(1500),1500].
 380   GotoTime(1500);
 381   InitStockCookies();  // Refresh cookies, so new cookies expire in the future.
 382   for (int i = 0; i < 6; ++i)
 383     Add(cookies_[i]);
 384   EXPECT_EQ(0u, cookie_counter_->GetStorageSize());
 385   // Reinstatement delays: [1499,1497,(1494),(1490),(1485),300].
 386   EXPECT_EQ("1499,1497;300", google_stat_ + ";" + other_stat_);
 387 }
 388
 389 }  // namespace
 390
 391 }  // namespace chrome_browser_net