evicted_domain_cookie_counter.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
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 "chrome/browser/net/evicted_domain_cookie_counter.h" 6 7#include <algorithm> 8#include <vector> 9 10#include "base/metrics/histogram.h" 11#include "base/stl_util.h" 12#include "base/string_util.h" 13#include "chrome/browser/google/google_util.h" 14#include "net/cookies/canonical_cookie.h" 15 16namespace chrome_browser_net { 17 18using base::Time; 19using base::TimeDelta; 20 21namespace { 22 23const size_t kMaxEvictedDomainCookies = 500; 24const size_t kPurgeEvictedDomainCookies = 100; 25 26class DelegateImpl : public EvictedDomainCookieCounter::Delegate { 27 public: 28 DelegateImpl(); 29 30 // EvictedDomainCookieCounter::Delegate implementation. 31 virtual void Report( 32 const EvictedDomainCookieCounter::EvictedCookie& evicted_cookie, 33 const Time& reinstatement_time) OVERRIDE; 34 virtual Time CurrentTime() const OVERRIDE; 35}; 36 37DelegateImpl::DelegateImpl() {} 38 39void DelegateImpl::Report( 40 const EvictedDomainCookieCounter::EvictedCookie& evicted_cookie, 41 const Time& reinstatement_time) { 42 TimeDelta reinstatement_delay( 43 reinstatement_time - evicted_cookie.eviction_time); 44 // Need to duplicate HISTOGRAM_CUSTOM_TIMES(), since it is a macro that 45 // defines a static variable. 46 if (evicted_cookie.is_google) { 47 UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.ReinstatedCookiesGoogle", 48 reinstatement_delay, 49 TimeDelta::FromSeconds(1), 50 TimeDelta::FromDays(7), 51 50); 52 } else { 53 UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.ReinstatedCookiesOther", 54 reinstatement_delay, 55 TimeDelta::FromSeconds(1), 56 TimeDelta::FromDays(7), 57 50); 58 } 59} 60 61Time DelegateImpl::CurrentTime() const { 62 return Time::Now(); 63} 64 65} // namespace 66 67EvictedDomainCookieCounter::EvictedDomainCookieCounter( 68 scoped_refptr<net::CookieMonster::Delegate> next_cookie_monster_delegate) 69 : next_cookie_monster_delegate_(next_cookie_monster_delegate), 70 cookie_counter_delegate_(new DelegateImpl), 71 max_size_(kMaxEvictedDomainCookies), 72 purge_count_(kPurgeEvictedDomainCookies) { 73} 74 75EvictedDomainCookieCounter::EvictedDomainCookieCounter( 76 scoped_refptr<net::CookieMonster::Delegate> next_cookie_monster_delegate, 77 scoped_ptr<Delegate> cookie_counter_delegate, 78 size_t max_size, 79 size_t purge_count) 80 : next_cookie_monster_delegate_(next_cookie_monster_delegate), 81 cookie_counter_delegate_(cookie_counter_delegate.Pass()), 82 max_size_(max_size), 83 purge_count_(purge_count) { 84 DCHECK(cookie_counter_delegate_); 85 DCHECK_LT(purge_count, max_size_); 86} 87 88EvictedDomainCookieCounter::~EvictedDomainCookieCounter() { 89 STLDeleteContainerPairSecondPointers(evicted_cookies_.begin(), 90 evicted_cookies_.end()); 91} 92 93size_t EvictedDomainCookieCounter::GetStorageSize() const { 94 return evicted_cookies_.size(); 95} 96 97void EvictedDomainCookieCounter::OnCookieChanged( 98 const net::CanonicalCookie& cookie, 99 bool removed, 100 ChangeCause cause) { 101 EvictedDomainCookieCounter::EvictedCookieKey key(GetKey(cookie)); 102 Time current_time(cookie_counter_delegate_->CurrentTime()); 103 if (removed) { 104 if (cause == net::CookieMonster::Delegate::CHANGE_COOKIE_EVICTED) 105 StoreEvictedCookie(key, cookie, current_time); 106 } else { // Includes adds or updates. 107 ProcessNewCookie(key, cookie, current_time); 108 } 109 110 if (next_cookie_monster_delegate_) 111 next_cookie_monster_delegate_->OnCookieChanged(cookie, removed, cause); 112} 113 114// static 115EvictedDomainCookieCounter::EvictedCookieKey 116 EvictedDomainCookieCounter::GetKey(const net::CanonicalCookie& cookie) { 117 return cookie.Domain() + ";" + cookie.Path() + ";" + cookie.Name(); 118} 119 120// static 121bool EvictedDomainCookieCounter::CompareEvictedCookie( 122 const EvictedCookieMap::iterator evicted_cookie1, 123 const EvictedCookieMap::iterator evicted_cookie2) { 124 return evicted_cookie1->second->eviction_time 125 < evicted_cookie2->second->eviction_time; 126} 127 128void EvictedDomainCookieCounter::GarbageCollect(const Time& current_time) { 129 if (evicted_cookies_.size() <= max_size_) 130 return; 131 132 // From |evicted_cookies_|, removed all expired cookies, and remove cookies 133 // with the oldest |eviction_time| so that |size_goal| is attained. 134 size_t size_goal = max_size_ - purge_count_; 135 // Bound on number of non-expired cookies to remove. 136 size_t remove_quota = evicted_cookies_.size() - size_goal; 137 DCHECK_GT(remove_quota, 0u); 138 139 std::vector<EvictedCookieMap::iterator> remove_list; 140 remove_list.reserve(evicted_cookies_.size()); 141 142 EvictedCookieMap::iterator it = evicted_cookies_.begin(); 143 while (it != evicted_cookies_.end()) { 144 if (it->second->is_expired(current_time)) { 145 delete it->second; 146 evicted_cookies_.erase(it++); // Post-increment idiom for in-loop removal. 147 if (remove_quota) 148 --remove_quota; 149 } else { 150 if (remove_quota) // Don't bother storing if quota met. 151 remove_list.push_back(it); 152 ++it; 153 } 154 } 155 156 // Free the oldest |remove_quota| non-expired cookies. 157 std::partial_sort(remove_list.begin(), remove_list.begin() + remove_quota, 158 remove_list.end(), CompareEvictedCookie); 159 for (size_t i = 0; i < remove_quota; ++i) { 160 delete remove_list[i]->second; 161 evicted_cookies_.erase(remove_list[i]); 162 } 163 164 // Apply stricter check if non-expired cookies were deleted. 165 DCHECK(remove_quota ? evicted_cookies_.size() == size_goal : 166 evicted_cookies_.size() <= size_goal); 167} 168 169void EvictedDomainCookieCounter::StoreEvictedCookie( 170 const EvictedCookieKey& key, 171 const net::CanonicalCookie& cookie, 172 const Time& current_time) { 173 bool is_google = google_util::IsGoogleHostname( 174 cookie.Domain(), google_util::ALLOW_SUBDOMAIN); 175 EvictedCookie* evicted_cookie = 176 new EvictedCookie(current_time, cookie.ExpiryDate(), is_google); 177 std::pair<EvictedCookieMap::iterator, bool> prev_entry = 178 evicted_cookies_.insert( 179 EvictedCookieMap::value_type(key, evicted_cookie)); 180 if (!prev_entry.second) { 181 NOTREACHED(); 182 delete prev_entry.first->second; 183 prev_entry.first->second = evicted_cookie; 184 } 185 186 GarbageCollect(current_time); 187} 188 189void EvictedDomainCookieCounter::ProcessNewCookie( 190 const EvictedCookieKey& key, 191 const net::CanonicalCookie& cc, 192 const Time& current_time) { 193 EvictedCookieMap::iterator it = evicted_cookies_.find(key); 194 if (it != evicted_cookies_.end()) { 195 if (!it->second->is_expired(current_time)) // Reinstatement. 196 cookie_counter_delegate_->Report(*it->second, current_time); 197 delete it->second; 198 evicted_cookies_.erase(it); 199 } 200} 201 202} // namespace chrome_browser_net 203