content/browser/net/sqlite_persistent_cookie_store_perftest.cc - Issue 1016643004: Moves SQLitePersistentCookieStore to net/extras/sqlite.

Side by Side Diff: content/browser/net/sqlite_persistent_cookie_store_perftest.cc

Issue 1016643004: Moves SQLitePersistentCookieStore to net/extras/sqlite. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@cookies

Patch Set: Review. Created 5 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

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 "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 "net/cookies/canonical_cookie.h"

17 #include "net/cookies/cookie_constants.h"

18 #include "net/extras/sqlite/cookie_crypto_delegate.h"

19 #include "testing/gtest/include/gtest/gtest.h"

20 #include "url/gurl.h"

21

22 namespace content {

23

24 namespace {

25

26 const base::FilePath::CharType cookie_filename[] = FILE_PATH_LITERAL("Cookies");

27

28 } // namespace

29

30 class 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 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(net::CanonicalCookie(

82 gurl, base::StringPrintf("Cookie_%d", cookie_num), "1", domain_name,

83 "/", t, t, t, false, false, false, net::COOKIE_PRIORITY_DEFAULT));

84 }

85 }

86 // Replace the store effectively destroying the current one and forcing it

87 // to write its data to disk.

88 store_ = NULL;

89

90 // Shut down the pool, causing deferred (no-op) commits to be discarded.

91 pool_owner_->pool()->Shutdown();

92 // ~SequencedWorkerPoolOwner blocks on pool shutdown.

93 pool_owner_.reset(new base::SequencedWorkerPoolOwner(1, "pool"));

94

95 store_ = new SQLitePersistentCookieStore(

96 temp_dir_.path().Append(cookie_filename),

97 client_task_runner(),

98 background_task_runner(),

99 false, NULL, NULL);

100 }

101

102 void TearDown() override {

103 store_ = NULL;

104 pool_owner_->pool()->Shutdown();

105 }

106

107 protected:

108 scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_;

109 base::WaitableEvent loaded_event_;

110 base::WaitableEvent key_loaded_event_;

111 std::vector<net::CanonicalCookie*> cookies_;

112 base::ScopedTempDir temp_dir_;

113 scoped_refptr<SQLitePersistentCookieStore> store_;

114 };

115

116 // Test the performance of priority load of cookies for a specfic domain key

117 TEST_F(SQLitePersistentCookieStorePerfTest, TestLoadForKeyPerformance) {

118 for (int domain_num = 0; domain_num < 3; ++domain_num) {

119 std::string domain_name(base::StringPrintf("domain_%d.com", domain_num));

120 base::PerfTimeLogger timer(

121 ("Load cookies for the eTLD+1 " + domain_name).c_str());

122 store_->LoadCookiesForKey(domain_name,

123 base::Bind(&SQLitePersistentCookieStorePerfTest::OnKeyLoaded,

124 base::Unretained(this)));

125 key_loaded_event_.Wait();

126 timer.Done();

127

128 ASSERT_EQ(50U, cookies_.size());

129 }

130 }

131

132 // Test the performance of load

133 TEST_F(SQLitePersistentCookieStorePerfTest, TestLoadPerformance) {

134 base::PerfTimeLogger timer("Load all cookies");

135 Load();

136 timer.Done();

137

138 ASSERT_EQ(15000U, cookies_.size());

139 }

140

141 } // namespace content

OLD	NEW