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