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 "content/browser/net/sqlite_persistent_cookie_store.h" 6 7 #include "base/bind.h" 8 #include "base/compiler_specific.h" 9 #include "base/files/scoped_temp_dir.h" 10 #include "base/perftimer.h" 11 #include "base/sequenced_task_runner.h" 12 #include "base/strings/stringprintf.h" 13 #include "base/synchronization/waitable_event.h" 14 #include "base/test/sequenced_worker_pool_owner.h" 15 #include "base/threading/sequenced_worker_pool.h" 16 #include "net/cookies/canonical_cookie.h" 17 #include "net/cookies/cookie_constants.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 #include "url/gurl.h" 20 21 namespace content { 22 23 namespace { 24 25 const base::FilePath::CharType cookie_filename[] = FILE_PATH_LITERAL("Cookies"); 26 27 } // namespace 28 29 class SQLitePersistentCookieStorePerfTest : public testing::Test { 30 public: 31 SQLitePersistentCookieStorePerfTest() 32 : pool_owner_(new base::SequencedWorkerPoolOwner(1, "Background Pool")), 33 loaded_event_(false, false), 34 key_loaded_event_(false, false) { 35 } 36 37 void OnLoaded(const std::vector<net::CanonicalCookie*>& cookies) { 38 cookies_ = cookies; 39 loaded_event_.Signal(); 40 } 41 42 void OnKeyLoaded(const std::vector<net::CanonicalCookie*>& cookies) { 43 cookies_ = cookies; 44 key_loaded_event_.Signal(); 45 } 46 47 void Load() { 48 store_->Load(base::Bind(&SQLitePersistentCookieStorePerfTest::OnLoaded, 49 base::Unretained(this))); 50 loaded_event_.Wait(); 51 } 52 53 scoped_refptr<base::SequencedTaskRunner> background_task_runner() { 54 return pool_owner_->pool()->GetSequencedTaskRunner( 55 pool_owner_->pool()->GetNamedSequenceToken("background")); 56 } 57 58 scoped_refptr<base::SequencedTaskRunner> client_task_runner() { 59 return pool_owner_->pool()->GetSequencedTaskRunner( 60 pool_owner_->pool()->GetNamedSequenceToken("client")); 61 } 62 63 virtual void SetUp() OVERRIDE { 64 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 65 store_ = new SQLitePersistentCookieStore( 66 temp_dir_.path().Append(cookie_filename), 67 client_task_runner(), 68 background_task_runner(), 69 false, NULL); 70 std::vector<net::CanonicalCookie*> cookies; 71 Load(); 72 ASSERT_EQ(0u, cookies_.size()); 73 // Creates 15000 cookies from 300 eTLD+1s. 74 base::Time t = base::Time::Now(); 75 for (int domain_num = 0; domain_num < 300; domain_num++) { 76 std::string domain_name(base::StringPrintf(".domain_%d.com", domain_num)); 77 GURL gurl("www" + domain_name); 78 for (int cookie_num = 0; cookie_num < 50; ++cookie_num) { 79 t += base::TimeDelta::FromInternalValue(10); 80 store_->AddCookie( 81 net::CanonicalCookie(gurl, 82 base::StringPrintf("Cookie_%d", cookie_num), "1", 83 domain_name, "/", t, t, t, false, false, 84 net::COOKIE_PRIORITY_DEFAULT)); 85 } 86 } 87 // Replace the store effectively destroying the current one and forcing it 88 // to write its data to disk. 89 store_ = NULL; 90 91 // Shut down the pool, causing deferred (no-op) commits to be discarded. 92 pool_owner_->pool()->Shutdown(); 93 // ~SequencedWorkerPoolOwner blocks on pool shutdown. 94 pool_owner_.reset(new base::SequencedWorkerPoolOwner(1, "pool")); 95 96 store_ = new SQLitePersistentCookieStore( 97 temp_dir_.path().Append(cookie_filename), 98 client_task_runner(), 99 background_task_runner(), 100 false, NULL); 101 } 102 103 virtual void TearDown() OVERRIDE { 104 store_ = NULL; 105 pool_owner_->pool()->Shutdown(); 106 } 107 108 protected: 109 scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_; 110 base::WaitableEvent loaded_event_; 111 base::WaitableEvent key_loaded_event_; 112 std::vector<net::CanonicalCookie*> cookies_; 113 base::ScopedTempDir temp_dir_; 114 scoped_refptr<SQLitePersistentCookieStore> store_; 115 }; 116 117 // Test the performance of priority load of cookies for a specfic domain key 118 TEST_F(SQLitePersistentCookieStorePerfTest, TestLoadForKeyPerformance) { 119 for (int domain_num = 0; domain_num < 3; ++domain_num) { 120 std::string domain_name(base::StringPrintf("domain_%d.com", domain_num)); 121 PerfTimeLogger timer( 122 ("Load cookies for the eTLD+1 " + domain_name).c_str()); 123 store_->LoadCookiesForKey(domain_name, 124 base::Bind(&SQLitePersistentCookieStorePerfTest::OnKeyLoaded, 125 base::Unretained(this))); 126 key_loaded_event_.Wait(); 127 timer.Done(); 128 129 ASSERT_EQ(50U, cookies_.size()); 130 } 131 } 132 133 // Test the performance of load 134 TEST_F(SQLitePersistentCookieStorePerfTest, TestLoadPerformance) { 135 PerfTimeLogger timer("Load all cookies"); 136 Load(); 137 timer.Done(); 138 139 ASSERT_EQ(15000U, cookies_.size()); 140 } 141 142 } // namespace content 143