| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 <algorithm> | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/message_loop/message_loop.h" | |
| 9 #include "base/strings/string_util.h" | |
| 10 #include "base/strings/stringprintf.h" | |
| 11 #include "base/test/perf_time_logger.h" | |
| 12 #include "net/cookies/canonical_cookie.h" | |
| 13 #include "net/cookies/cookie_monster.h" | |
| 14 #include "net/cookies/cookie_monster_store_test.h" | |
| 15 #include "net/cookies/parsed_cookie.h" | |
| 16 #include "testing/gtest/include/gtest/gtest.h" | |
| 17 #include "url/gurl.h" | |
| 18 | |
| 19 namespace net { | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 const int kNumCookies = 20000; | |
| 24 const char kCookieLine[] = "A = \"b=;\\\"\" ;secure;;;"; | |
| 25 const char kGoogleURL[] = "http://www.google.izzle"; | |
| 26 | |
| 27 int CountInString(const std::string& str, char c) { | |
| 28 return std::count(str.begin(), str.end(), c); | |
| 29 } | |
| 30 | |
| 31 class CookieMonsterTest : public testing::Test { | |
| 32 public: | |
| 33 CookieMonsterTest() : message_loop_(new base::MessageLoopForIO()) {} | |
| 34 | |
| 35 private: | |
| 36 scoped_ptr<base::MessageLoop> message_loop_; | |
| 37 }; | |
| 38 | |
| 39 class BaseCallback { | |
| 40 public: | |
| 41 BaseCallback() : has_run_(false) {} | |
| 42 | |
| 43 protected: | |
| 44 void WaitForCallback() { | |
| 45 // Note that the performance tests currently all operate on a loaded cookie | |
| 46 // store (or, more precisely, one that has no backing persistent store). | |
| 47 // Therefore, callbacks will actually always complete synchronously. If the | |
| 48 // tests get more advanced we need to add other means of signaling | |
| 49 // completion. | |
| 50 base::MessageLoop::current()->RunUntilIdle(); | |
| 51 EXPECT_TRUE(has_run_); | |
| 52 has_run_ = false; | |
| 53 } | |
| 54 | |
| 55 void Run() { | |
| 56 has_run_ = true; | |
| 57 } | |
| 58 | |
| 59 bool has_run_; | |
| 60 }; | |
| 61 | |
| 62 class SetCookieCallback : public BaseCallback { | |
| 63 public: | |
| 64 void SetCookie( | |
| 65 CookieMonster* cm, const GURL& gurl, const std::string& cookie) { | |
| 66 cm->SetCookieWithOptionsAsync(gurl, cookie, options_, base::Bind( | |
| 67 &SetCookieCallback::Run, base::Unretained(this))); | |
| 68 WaitForCallback(); | |
| 69 } | |
| 70 private: | |
| 71 void Run(bool success) { | |
| 72 EXPECT_TRUE(success); | |
| 73 BaseCallback::Run(); | |
| 74 } | |
| 75 net::CookieOptions options_; | |
| 76 }; | |
| 77 | |
| 78 class GetCookiesCallback : public BaseCallback { | |
| 79 public: | |
| 80 const std::string& GetCookies(CookieMonster* cm, const GURL& gurl) { | |
| 81 cm->GetCookiesWithOptionsAsync(gurl, options_, base::Bind( | |
| 82 &GetCookiesCallback::Run, base::Unretained(this))); | |
| 83 WaitForCallback(); | |
| 84 return cookies_; | |
| 85 } | |
| 86 | |
| 87 private: | |
| 88 void Run(const std::string& cookies) { | |
| 89 cookies_ = cookies; | |
| 90 BaseCallback::Run(); | |
| 91 } | |
| 92 std::string cookies_; | |
| 93 net::CookieOptions options_; | |
| 94 }; | |
| 95 | |
| 96 } // namespace | |
| 97 | |
| 98 TEST(ParsedCookieTest, TestParseCookies) { | |
| 99 std::string cookie(kCookieLine); | |
| 100 base::PerfTimeLogger timer("Parsed_cookie_parse_cookies"); | |
| 101 for (int i = 0; i < kNumCookies; ++i) { | |
| 102 ParsedCookie pc(cookie); | |
| 103 EXPECT_TRUE(pc.IsValid()); | |
| 104 } | |
| 105 timer.Done(); | |
| 106 } | |
| 107 | |
| 108 TEST(ParsedCookieTest, TestParseBigCookies) { | |
| 109 std::string cookie(3800, 'z'); | |
| 110 cookie += kCookieLine; | |
| 111 base::PerfTimeLogger timer("Parsed_cookie_parse_big_cookies"); | |
| 112 for (int i = 0; i < kNumCookies; ++i) { | |
| 113 ParsedCookie pc(cookie); | |
| 114 EXPECT_TRUE(pc.IsValid()); | |
| 115 } | |
| 116 timer.Done(); | |
| 117 } | |
| 118 | |
| 119 TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) { | |
| 120 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| 121 std::vector<std::string> cookies; | |
| 122 for (int i = 0; i < kNumCookies; i++) { | |
| 123 cookies.push_back(base::StringPrintf("a%03d=b", i)); | |
| 124 } | |
| 125 | |
| 126 SetCookieCallback setCookieCallback; | |
| 127 | |
| 128 // Add a bunch of cookies on a single host | |
| 129 base::PerfTimeLogger timer("Cookie_monster_add_single_host"); | |
| 130 | |
| 131 for (std::vector<std::string>::const_iterator it = cookies.begin(); | |
| 132 it != cookies.end(); ++it) { | |
| 133 setCookieCallback.SetCookie(cm.get(), GURL(kGoogleURL), *it); | |
| 134 } | |
| 135 timer.Done(); | |
| 136 | |
| 137 GetCookiesCallback getCookiesCallback; | |
| 138 | |
| 139 base::PerfTimeLogger timer2("Cookie_monster_query_single_host"); | |
| 140 for (std::vector<std::string>::const_iterator it = cookies.begin(); | |
| 141 it != cookies.end(); ++it) { | |
| 142 getCookiesCallback.GetCookies(cm.get(), GURL(kGoogleURL)); | |
| 143 } | |
| 144 timer2.Done(); | |
| 145 | |
| 146 base::PerfTimeLogger timer3("Cookie_monster_deleteall_single_host"); | |
| 147 cm->DeleteAllAsync(CookieMonster::DeleteCallback()); | |
| 148 base::MessageLoop::current()->RunUntilIdle(); | |
| 149 timer3.Done(); | |
| 150 } | |
| 151 | |
| 152 TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) { | |
| 153 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| 154 std::string cookie(kCookieLine); | |
| 155 std::vector<GURL> gurls; // just wanna have ffffuunnn | |
| 156 for (int i = 0; i < kNumCookies; ++i) { | |
| 157 gurls.push_back(GURL(base::StringPrintf("https://a%04d.izzle", i))); | |
| 158 } | |
| 159 | |
| 160 SetCookieCallback setCookieCallback; | |
| 161 | |
| 162 // Add a cookie on a bunch of host | |
| 163 base::PerfTimeLogger timer("Cookie_monster_add_many_hosts"); | |
| 164 for (std::vector<GURL>::const_iterator it = gurls.begin(); | |
| 165 it != gurls.end(); ++it) { | |
| 166 setCookieCallback.SetCookie(cm.get(), *it, cookie); | |
| 167 } | |
| 168 timer.Done(); | |
| 169 | |
| 170 GetCookiesCallback getCookiesCallback; | |
| 171 | |
| 172 base::PerfTimeLogger timer2("Cookie_monster_query_many_hosts"); | |
| 173 for (std::vector<GURL>::const_iterator it = gurls.begin(); | |
| 174 it != gurls.end(); ++it) { | |
| 175 getCookiesCallback.GetCookies(cm.get(), *it); | |
| 176 } | |
| 177 timer2.Done(); | |
| 178 | |
| 179 base::PerfTimeLogger timer3("Cookie_monster_deleteall_many_hosts"); | |
| 180 cm->DeleteAllAsync(CookieMonster::DeleteCallback()); | |
| 181 base::MessageLoop::current()->RunUntilIdle(); | |
| 182 timer3.Done(); | |
| 183 } | |
| 184 | |
| 185 TEST_F(CookieMonsterTest, TestDomainTree) { | |
| 186 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| 187 GetCookiesCallback getCookiesCallback; | |
| 188 SetCookieCallback setCookieCallback; | |
| 189 const char domain_cookie_format_tree[] = "a=b; domain=%s"; | |
| 190 const std::string domain_base("top.com"); | |
| 191 | |
| 192 std::vector<std::string> domain_list; | |
| 193 | |
| 194 // Create a balanced binary tree of domains on which the cookie is set. | |
| 195 domain_list.push_back(domain_base); | |
| 196 for (int i1 = 0; i1 < 2; i1++) { | |
| 197 std::string domain_base_1((i1 ? "a." : "b.") + domain_base); | |
| 198 EXPECT_EQ("top.com", cm->GetKey(domain_base_1)); | |
| 199 domain_list.push_back(domain_base_1); | |
| 200 for (int i2 = 0; i2 < 2; i2++) { | |
| 201 std::string domain_base_2((i2 ? "a." : "b.") + domain_base_1); | |
| 202 EXPECT_EQ("top.com", cm->GetKey(domain_base_2)); | |
| 203 domain_list.push_back(domain_base_2); | |
| 204 for (int i3 = 0; i3 < 2; i3++) { | |
| 205 std::string domain_base_3((i3 ? "a." : "b.") + domain_base_2); | |
| 206 EXPECT_EQ("top.com", cm->GetKey(domain_base_3)); | |
| 207 domain_list.push_back(domain_base_3); | |
| 208 for (int i4 = 0; i4 < 2; i4++) { | |
| 209 std::string domain_base_4((i4 ? "a." : "b.") + domain_base_3); | |
| 210 EXPECT_EQ("top.com", cm->GetKey(domain_base_4)); | |
| 211 domain_list.push_back(domain_base_4); | |
| 212 } | |
| 213 } | |
| 214 } | |
| 215 } | |
| 216 | |
| 217 | |
| 218 EXPECT_EQ(31u, domain_list.size()); | |
| 219 for (std::vector<std::string>::const_iterator it = domain_list.begin(); | |
| 220 it != domain_list.end(); it++) { | |
| 221 GURL gurl("https://" + *it + "/"); | |
| 222 const std::string cookie = base::StringPrintf(domain_cookie_format_tree, | |
| 223 it->c_str()); | |
| 224 setCookieCallback.SetCookie(cm.get(), gurl, cookie); | |
| 225 } | |
| 226 EXPECT_EQ(31u, cm->GetAllCookies().size()); | |
| 227 | |
| 228 GURL probe_gurl("https://b.a.b.a.top.com/"); | |
| 229 std::string cookie_line = getCookiesCallback.GetCookies(cm.get(), probe_gurl); | |
| 230 EXPECT_EQ(5, CountInString(cookie_line, '=')) | |
| 231 << "Cookie line: " << cookie_line; | |
| 232 base::PerfTimeLogger timer("Cookie_monster_query_domain_tree"); | |
| 233 for (int i = 0; i < kNumCookies; i++) { | |
| 234 getCookiesCallback.GetCookies(cm.get(), probe_gurl); | |
| 235 } | |
| 236 timer.Done(); | |
| 237 } | |
| 238 | |
| 239 TEST_F(CookieMonsterTest, TestDomainLine) { | |
| 240 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| 241 SetCookieCallback setCookieCallback; | |
| 242 GetCookiesCallback getCookiesCallback; | |
| 243 std::vector<std::string> domain_list; | |
| 244 GURL probe_gurl("https://b.a.b.a.top.com/"); | |
| 245 std::string cookie_line; | |
| 246 | |
| 247 // Create a line of 32 domain cookies such that all cookies stored | |
| 248 // by effective TLD+1 will apply to probe GURL. | |
| 249 // (TLD + 1 is the level above .com/org/net/etc, e.g. "top.com" | |
| 250 // or "google.com". "Effective" is added to include sites like | |
| 251 // bbc.co.uk, where the effetive TLD+1 is more than one level | |
| 252 // below the top level.) | |
| 253 domain_list.push_back("a.top.com"); | |
| 254 domain_list.push_back("b.a.top.com"); | |
| 255 domain_list.push_back("a.b.a.top.com"); | |
| 256 domain_list.push_back("b.a.b.a.top.com"); | |
| 257 EXPECT_EQ(4u, domain_list.size()); | |
| 258 | |
| 259 const char domain_cookie_format_line[] = "a%03d=b; domain=%s"; | |
| 260 for (int i = 0; i < 8; i++) { | |
| 261 for (std::vector<std::string>::const_iterator it = domain_list.begin(); | |
| 262 it != domain_list.end(); it++) { | |
| 263 GURL gurl("https://" + *it + "/"); | |
| 264 const std::string cookie = base::StringPrintf(domain_cookie_format_line, | |
| 265 i, it->c_str()); | |
| 266 setCookieCallback.SetCookie(cm.get(), gurl, cookie); | |
| 267 } | |
| 268 } | |
| 269 | |
| 270 cookie_line = getCookiesCallback.GetCookies(cm.get(), probe_gurl); | |
| 271 EXPECT_EQ(32, CountInString(cookie_line, '=')); | |
| 272 base::PerfTimeLogger timer2("Cookie_monster_query_domain_line"); | |
| 273 for (int i = 0; i < kNumCookies; i++) { | |
| 274 getCookiesCallback.GetCookies(cm.get(), probe_gurl); | |
| 275 } | |
| 276 timer2.Done(); | |
| 277 } | |
| 278 | |
| 279 TEST_F(CookieMonsterTest, TestImport) { | |
| 280 scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore); | |
| 281 std::vector<CanonicalCookie*> initial_cookies; | |
| 282 GetCookiesCallback getCookiesCallback; | |
| 283 | |
| 284 // We want to setup a fairly large backing store, with 300 domains of 50 | |
| 285 // cookies each. Creation times must be unique. | |
| 286 int64 time_tick(base::Time::Now().ToInternalValue()); | |
| 287 | |
| 288 for (int domain_num = 0; domain_num < 300; domain_num++) { | |
| 289 std::string domain_name(base::StringPrintf(".Domain_%d.com", domain_num)); | |
| 290 std::string gurl("www" + domain_name); | |
| 291 for (int cookie_num = 0; cookie_num < 50; cookie_num++) { | |
| 292 std::string cookie_line(base::StringPrintf("Cookie_%d=1; Path=/", | |
| 293 cookie_num)); | |
| 294 AddCookieToList(gurl, cookie_line, | |
| 295 base::Time::FromInternalValue(time_tick++), | |
| 296 &initial_cookies); | |
| 297 } | |
| 298 } | |
| 299 | |
| 300 store->SetLoadExpectation(true, initial_cookies); | |
| 301 | |
| 302 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL)); | |
| 303 | |
| 304 // Import will happen on first access. | |
| 305 GURL gurl("www.google.com"); | |
| 306 CookieOptions options; | |
| 307 base::PerfTimeLogger timer("Cookie_monster_import_from_store"); | |
| 308 getCookiesCallback.GetCookies(cm.get(), gurl); | |
| 309 timer.Done(); | |
| 310 | |
| 311 // Just confirm keys were set as expected. | |
| 312 EXPECT_EQ("domain_1.com", cm->GetKey("www.Domain_1.com")); | |
| 313 } | |
| 314 | |
| 315 TEST_F(CookieMonsterTest, TestGetKey) { | |
| 316 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| 317 base::PerfTimeLogger timer("Cookie_monster_get_key"); | |
| 318 for (int i = 0; i < kNumCookies; i++) | |
| 319 cm->GetKey("www.google.com"); | |
| 320 timer.Done(); | |
| 321 } | |
| 322 | |
| 323 // This test is probing for whether garbage collection happens when it | |
| 324 // shouldn't. This will not in general be visible functionally, since | |
| 325 // if GC runs twice in a row without any change to the store, the second | |
| 326 // GC run will not do anything the first one didn't. That's why this is | |
| 327 // a performance test. The test should be considered to pass if all the | |
| 328 // times reported are approximately the same--this indicates that no GC | |
| 329 // happened repeatedly for any case. | |
| 330 TEST_F(CookieMonsterTest, TestGCTimes) { | |
| 331 SetCookieCallback setCookieCallback; | |
| 332 | |
| 333 const struct TestCase { | |
| 334 const char* const name; | |
| 335 size_t num_cookies; | |
| 336 size_t num_old_cookies; | |
| 337 } test_cases[] = { | |
| 338 { | |
| 339 // A whole lot of recent cookies; gc shouldn't happen. | |
| 340 "all_recent", | |
| 341 CookieMonster::kMaxCookies * 2, | |
| 342 0, | |
| 343 }, { | |
| 344 // Some old cookies, but still overflowing max. | |
| 345 "mostly_recent", | |
| 346 CookieMonster::kMaxCookies * 2, | |
| 347 CookieMonster::kMaxCookies / 2, | |
| 348 }, { | |
| 349 // Old cookies enough to bring us right down to our purge line. | |
| 350 "balanced", | |
| 351 CookieMonster::kMaxCookies * 2, | |
| 352 CookieMonster::kMaxCookies + CookieMonster::kPurgeCookies + 1, | |
| 353 }, { | |
| 354 "mostly_old", | |
| 355 // Old cookies enough to bring below our purge line (which we | |
| 356 // shouldn't do). | |
| 357 CookieMonster::kMaxCookies * 2, | |
| 358 CookieMonster::kMaxCookies * 3 / 4, | |
| 359 }, { | |
| 360 "less_than_gc_thresh", | |
| 361 // Few enough cookies that gc shouldn't happen at all. | |
| 362 CookieMonster::kMaxCookies - 5, | |
| 363 0, | |
| 364 }, | |
| 365 }; | |
| 366 for (int ci = 0; ci < static_cast<int>(arraysize(test_cases)); ++ci) { | |
| 367 const TestCase& test_case(test_cases[ci]); | |
| 368 scoped_refptr<CookieMonster> cm( | |
| 369 CreateMonsterFromStoreForGC( | |
| 370 test_case.num_cookies, test_case.num_old_cookies, | |
| 371 CookieMonster::kSafeFromGlobalPurgeDays * 2)); | |
| 372 | |
| 373 GURL gurl("http://google.com"); | |
| 374 std::string cookie_line("z=3"); | |
| 375 // Trigger the Garbage collection we're allowed. | |
| 376 setCookieCallback.SetCookie(cm.get(), gurl, cookie_line); | |
| 377 | |
| 378 base::PerfTimeLogger timer((std::string("GC_") + test_case.name).c_str()); | |
| 379 for (int i = 0; i < kNumCookies; i++) | |
| 380 setCookieCallback.SetCookie(cm.get(), gurl, cookie_line); | |
| 381 timer.Done(); | |
| 382 } | |
| 383 } | |
| 384 | |
| 385 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master