OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/ssl/default_channel_id_store.h" | 5 #include "net/ssl/default_channel_id_store.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
| 8 #include <memory> |
8 #include <string> | 9 #include <string> |
9 #include <utility> | 10 #include <utility> |
10 #include <vector> | 11 #include <vector> |
11 | 12 |
12 #include "base/bind.h" | 13 #include "base/bind.h" |
13 #include "base/compiler_specific.h" | 14 #include "base/compiler_specific.h" |
14 #include "base/location.h" | 15 #include "base/location.h" |
15 #include "base/logging.h" | 16 #include "base/logging.h" |
16 #include "base/memory/scoped_ptr.h" | 17 #include "base/memory/ptr_util.h" |
17 #include "base/message_loop/message_loop.h" | 18 #include "base/message_loop/message_loop.h" |
18 #include "base/single_thread_task_runner.h" | 19 #include "base/single_thread_task_runner.h" |
19 #include "base/thread_task_runner_handle.h" | 20 #include "base/thread_task_runner_handle.h" |
20 #include "crypto/ec_private_key.h" | 21 #include "crypto/ec_private_key.h" |
21 #include "net/base/net_errors.h" | 22 #include "net/base/net_errors.h" |
22 #include "net/test/channel_id_test_util.h" | 23 #include "net/test/channel_id_test_util.h" |
23 #include "testing/gtest/include/gtest/gtest.h" | 24 #include "testing/gtest/include/gtest/gtest.h" |
24 | 25 |
25 namespace net { | 26 namespace net { |
26 | 27 |
27 namespace { | 28 namespace { |
28 | 29 |
29 void CallCounter(int* counter) { | 30 void CallCounter(int* counter) { |
30 (*counter)++; | 31 (*counter)++; |
31 } | 32 } |
32 | 33 |
33 void GetChannelIDCallbackNotCalled( | 34 void GetChannelIDCallbackNotCalled( |
34 int err, | 35 int err, |
35 const std::string& server_identifier, | 36 const std::string& server_identifier, |
36 scoped_ptr<crypto::ECPrivateKey> key_result) { | 37 std::unique_ptr<crypto::ECPrivateKey> key_result) { |
37 ADD_FAILURE() << "Unexpected callback execution."; | 38 ADD_FAILURE() << "Unexpected callback execution."; |
38 } | 39 } |
39 | 40 |
40 class AsyncGetChannelIDHelper { | 41 class AsyncGetChannelIDHelper { |
41 public: | 42 public: |
42 AsyncGetChannelIDHelper() : called_(false) {} | 43 AsyncGetChannelIDHelper() : called_(false) {} |
43 | 44 |
44 void Callback(int err, | 45 void Callback(int err, |
45 const std::string& server_identifier, | 46 const std::string& server_identifier, |
46 scoped_ptr<crypto::ECPrivateKey> key_result) { | 47 std::unique_ptr<crypto::ECPrivateKey> key_result) { |
47 err_ = err; | 48 err_ = err; |
48 server_identifier_ = server_identifier; | 49 server_identifier_ = server_identifier; |
49 key_ = std::move(key_result); | 50 key_ = std::move(key_result); |
50 called_ = true; | 51 called_ = true; |
51 } | 52 } |
52 | 53 |
53 int err_; | 54 int err_; |
54 std::string server_identifier_; | 55 std::string server_identifier_; |
55 scoped_ptr<crypto::ECPrivateKey> key_; | 56 std::unique_ptr<crypto::ECPrivateKey> key_; |
56 bool called_; | 57 bool called_; |
57 }; | 58 }; |
58 | 59 |
59 void GetAllCallback( | 60 void GetAllCallback( |
60 ChannelIDStore::ChannelIDList* dest, | 61 ChannelIDStore::ChannelIDList* dest, |
61 const ChannelIDStore::ChannelIDList& result) { | 62 const ChannelIDStore::ChannelIDList& result) { |
62 *dest = result; | 63 *dest = result; |
63 } | 64 } |
64 | 65 |
65 class MockPersistentStore | 66 class MockPersistentStore |
(...skipping 15 matching lines...) Expand all Loading... |
81 private: | 82 private: |
82 typedef std::map<std::string, DefaultChannelIDStore::ChannelID> | 83 typedef std::map<std::string, DefaultChannelIDStore::ChannelID> |
83 ChannelIDMap; | 84 ChannelIDMap; |
84 | 85 |
85 ChannelIDMap channel_ids_; | 86 ChannelIDMap channel_ids_; |
86 }; | 87 }; |
87 | 88 |
88 MockPersistentStore::MockPersistentStore() {} | 89 MockPersistentStore::MockPersistentStore() {} |
89 | 90 |
90 void MockPersistentStore::Load(const LoadedCallback& loaded_callback) { | 91 void MockPersistentStore::Load(const LoadedCallback& loaded_callback) { |
91 scoped_ptr<std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>> | 92 std::unique_ptr< |
| 93 std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>> |
92 channel_ids( | 94 channel_ids( |
93 new std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>()); | 95 new std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>()); |
94 ChannelIDMap::iterator it; | 96 ChannelIDMap::iterator it; |
95 | 97 |
96 for (it = channel_ids_.begin(); it != channel_ids_.end(); ++it) { | 98 for (it = channel_ids_.begin(); it != channel_ids_.end(); ++it) { |
97 channel_ids->push_back( | 99 channel_ids->push_back( |
98 make_scoped_ptr(new DefaultChannelIDStore::ChannelID(it->second))); | 100 base::WrapUnique(new DefaultChannelIDStore::ChannelID(it->second))); |
99 } | 101 } |
100 | 102 |
101 base::ThreadTaskRunnerHandle::Get()->PostTask( | 103 base::ThreadTaskRunnerHandle::Get()->PostTask( |
102 FROM_HERE, base::Bind(loaded_callback, base::Passed(&channel_ids))); | 104 FROM_HERE, base::Bind(loaded_callback, base::Passed(&channel_ids))); |
103 } | 105 } |
104 | 106 |
105 void MockPersistentStore::AddChannelID( | 107 void MockPersistentStore::AddChannelID( |
106 const DefaultChannelIDStore::ChannelID& channel_id) { | 108 const DefaultChannelIDStore::ChannelID& channel_id) { |
107 channel_ids_[channel_id.server_identifier()] = channel_id; | 109 channel_ids_[channel_id.server_identifier()] = channel_id; |
108 } | 110 } |
109 | 111 |
110 void MockPersistentStore::DeleteChannelID( | 112 void MockPersistentStore::DeleteChannelID( |
111 const DefaultChannelIDStore::ChannelID& channel_id) { | 113 const DefaultChannelIDStore::ChannelID& channel_id) { |
112 channel_ids_.erase(channel_id.server_identifier()); | 114 channel_ids_.erase(channel_id.server_identifier()); |
113 } | 115 } |
114 | 116 |
115 void MockPersistentStore::SetForceKeepSessionState() {} | 117 void MockPersistentStore::SetForceKeepSessionState() {} |
116 | 118 |
117 MockPersistentStore::~MockPersistentStore() {} | 119 MockPersistentStore::~MockPersistentStore() {} |
118 | 120 |
119 } // namespace | 121 } // namespace |
120 | 122 |
121 TEST(DefaultChannelIDStoreTest, TestLoading) { | 123 TEST(DefaultChannelIDStoreTest, TestLoading) { |
122 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 124 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
123 | 125 |
124 persistent_store->AddChannelID(DefaultChannelIDStore::ChannelID( | 126 persistent_store->AddChannelID(DefaultChannelIDStore::ChannelID( |
125 "google.com", base::Time(), | 127 "google.com", base::Time(), |
126 make_scoped_ptr(crypto::ECPrivateKey::Create()))); | 128 base::WrapUnique(crypto::ECPrivateKey::Create()))); |
127 persistent_store->AddChannelID(DefaultChannelIDStore::ChannelID( | 129 persistent_store->AddChannelID(DefaultChannelIDStore::ChannelID( |
128 "verisign.com", base::Time(), | 130 "verisign.com", base::Time(), |
129 make_scoped_ptr(crypto::ECPrivateKey::Create()))); | 131 base::WrapUnique(crypto::ECPrivateKey::Create()))); |
130 | 132 |
131 // Make sure channel_ids load properly. | 133 // Make sure channel_ids load properly. |
132 DefaultChannelIDStore store(persistent_store.get()); | 134 DefaultChannelIDStore store(persistent_store.get()); |
133 // Load has not occurred yet. | 135 // Load has not occurred yet. |
134 EXPECT_EQ(0, store.GetChannelIDCount()); | 136 EXPECT_EQ(0, store.GetChannelIDCount()); |
135 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 137 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
136 "verisign.com", base::Time(), | 138 "verisign.com", base::Time(), |
137 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 139 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
138 // Wait for load & queued set task. | 140 // Wait for load & queued set task. |
139 base::MessageLoop::current()->RunUntilIdle(); | 141 base::MessageLoop::current()->RunUntilIdle(); |
140 EXPECT_EQ(2, store.GetChannelIDCount()); | 142 EXPECT_EQ(2, store.GetChannelIDCount()); |
141 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 143 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
142 "twitter.com", base::Time(), | 144 "twitter.com", base::Time(), |
143 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 145 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
144 // Set should be synchronous now that load is done. | 146 // Set should be synchronous now that load is done. |
145 EXPECT_EQ(3, store.GetChannelIDCount()); | 147 EXPECT_EQ(3, store.GetChannelIDCount()); |
146 } | 148 } |
147 | 149 |
148 //TODO(mattm): add more tests of without a persistent store? | 150 //TODO(mattm): add more tests of without a persistent store? |
149 TEST(DefaultChannelIDStoreTest, TestSettingAndGetting) { | 151 TEST(DefaultChannelIDStoreTest, TestSettingAndGetting) { |
150 // No persistent store, all calls will be synchronous. | 152 // No persistent store, all calls will be synchronous. |
151 DefaultChannelIDStore store(NULL); | 153 DefaultChannelIDStore store(NULL); |
152 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); | 154 std::unique_ptr<crypto::ECPrivateKey> expected_key( |
| 155 crypto::ECPrivateKey::Create()); |
153 | 156 |
154 scoped_ptr<crypto::ECPrivateKey> key; | 157 std::unique_ptr<crypto::ECPrivateKey> key; |
155 EXPECT_EQ(0, store.GetChannelIDCount()); | 158 EXPECT_EQ(0, store.GetChannelIDCount()); |
156 EXPECT_EQ(ERR_FILE_NOT_FOUND, | 159 EXPECT_EQ(ERR_FILE_NOT_FOUND, |
157 store.GetChannelID("verisign.com", &key, | 160 store.GetChannelID("verisign.com", &key, |
158 base::Bind(&GetChannelIDCallbackNotCalled))); | 161 base::Bind(&GetChannelIDCallbackNotCalled))); |
159 EXPECT_FALSE(key); | 162 EXPECT_FALSE(key); |
160 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 163 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
161 "verisign.com", base::Time::FromInternalValue(123), | 164 "verisign.com", base::Time::FromInternalValue(123), |
162 make_scoped_ptr(expected_key->Copy())))); | 165 base::WrapUnique(expected_key->Copy())))); |
163 EXPECT_EQ(OK, store.GetChannelID("verisign.com", &key, | 166 EXPECT_EQ(OK, store.GetChannelID("verisign.com", &key, |
164 base::Bind(&GetChannelIDCallbackNotCalled))); | 167 base::Bind(&GetChannelIDCallbackNotCalled))); |
165 EXPECT_TRUE(KeysEqual(expected_key.get(), key.get())); | 168 EXPECT_TRUE(KeysEqual(expected_key.get(), key.get())); |
166 } | 169 } |
167 | 170 |
168 TEST(DefaultChannelIDStoreTest, TestDuplicateChannelIds) { | 171 TEST(DefaultChannelIDStoreTest, TestDuplicateChannelIds) { |
169 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 172 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
170 DefaultChannelIDStore store(persistent_store.get()); | 173 DefaultChannelIDStore store(persistent_store.get()); |
171 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); | 174 std::unique_ptr<crypto::ECPrivateKey> expected_key( |
| 175 crypto::ECPrivateKey::Create()); |
172 | 176 |
173 scoped_ptr<crypto::ECPrivateKey> key; | 177 std::unique_ptr<crypto::ECPrivateKey> key; |
174 EXPECT_EQ(0, store.GetChannelIDCount()); | 178 EXPECT_EQ(0, store.GetChannelIDCount()); |
175 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 179 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
176 "verisign.com", base::Time::FromInternalValue(123), | 180 "verisign.com", base::Time::FromInternalValue(123), |
177 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 181 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
178 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 182 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
179 "verisign.com", base::Time::FromInternalValue(456), | 183 "verisign.com", base::Time::FromInternalValue(456), |
180 make_scoped_ptr(expected_key->Copy())))); | 184 base::WrapUnique(expected_key->Copy())))); |
181 | 185 |
182 // Wait for load & queued set tasks. | 186 // Wait for load & queued set tasks. |
183 base::MessageLoop::current()->RunUntilIdle(); | 187 base::MessageLoop::current()->RunUntilIdle(); |
184 EXPECT_EQ(1, store.GetChannelIDCount()); | 188 EXPECT_EQ(1, store.GetChannelIDCount()); |
185 EXPECT_EQ(OK, store.GetChannelID("verisign.com", &key, | 189 EXPECT_EQ(OK, store.GetChannelID("verisign.com", &key, |
186 base::Bind(&GetChannelIDCallbackNotCalled))); | 190 base::Bind(&GetChannelIDCallbackNotCalled))); |
187 EXPECT_TRUE(KeysEqual(expected_key.get(), key.get())); | 191 EXPECT_TRUE(KeysEqual(expected_key.get(), key.get())); |
188 } | 192 } |
189 | 193 |
190 TEST(DefaultChannelIDStoreTest, TestAsyncGet) { | 194 TEST(DefaultChannelIDStoreTest, TestAsyncGet) { |
191 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 195 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
192 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); | 196 std::unique_ptr<crypto::ECPrivateKey> expected_key( |
| 197 crypto::ECPrivateKey::Create()); |
193 persistent_store->AddChannelID(ChannelIDStore::ChannelID( | 198 persistent_store->AddChannelID(ChannelIDStore::ChannelID( |
194 "verisign.com", base::Time::FromInternalValue(123), | 199 "verisign.com", base::Time::FromInternalValue(123), |
195 make_scoped_ptr(expected_key->Copy()))); | 200 base::WrapUnique(expected_key->Copy()))); |
196 | 201 |
197 DefaultChannelIDStore store(persistent_store.get()); | 202 DefaultChannelIDStore store(persistent_store.get()); |
198 AsyncGetChannelIDHelper helper; | 203 AsyncGetChannelIDHelper helper; |
199 scoped_ptr<crypto::ECPrivateKey> key; | 204 std::unique_ptr<crypto::ECPrivateKey> key; |
200 EXPECT_EQ(0, store.GetChannelIDCount()); | 205 EXPECT_EQ(0, store.GetChannelIDCount()); |
201 EXPECT_EQ(ERR_IO_PENDING, | 206 EXPECT_EQ(ERR_IO_PENDING, |
202 store.GetChannelID("verisign.com", &key, | 207 store.GetChannelID("verisign.com", &key, |
203 base::Bind(&AsyncGetChannelIDHelper::Callback, | 208 base::Bind(&AsyncGetChannelIDHelper::Callback, |
204 base::Unretained(&helper)))); | 209 base::Unretained(&helper)))); |
205 | 210 |
206 // Wait for load & queued get tasks. | 211 // Wait for load & queued get tasks. |
207 base::MessageLoop::current()->RunUntilIdle(); | 212 base::MessageLoop::current()->RunUntilIdle(); |
208 EXPECT_EQ(1, store.GetChannelIDCount()); | 213 EXPECT_EQ(1, store.GetChannelIDCount()); |
209 EXPECT_FALSE(key); | 214 EXPECT_FALSE(key); |
210 EXPECT_TRUE(helper.called_); | 215 EXPECT_TRUE(helper.called_); |
211 EXPECT_EQ(OK, helper.err_); | 216 EXPECT_EQ(OK, helper.err_); |
212 EXPECT_EQ("verisign.com", helper.server_identifier_); | 217 EXPECT_EQ("verisign.com", helper.server_identifier_); |
213 EXPECT_TRUE(KeysEqual(expected_key.get(), helper.key_.get())); | 218 EXPECT_TRUE(KeysEqual(expected_key.get(), helper.key_.get())); |
214 } | 219 } |
215 | 220 |
216 TEST(DefaultChannelIDStoreTest, TestDeleteAll) { | 221 TEST(DefaultChannelIDStoreTest, TestDeleteAll) { |
217 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 222 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
218 DefaultChannelIDStore store(persistent_store.get()); | 223 DefaultChannelIDStore store(persistent_store.get()); |
219 | 224 |
220 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 225 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
221 "verisign.com", base::Time(), | 226 "verisign.com", base::Time(), |
222 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 227 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
223 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 228 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
224 "google.com", base::Time(), | 229 "google.com", base::Time(), |
225 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 230 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
226 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 231 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
227 "harvard.com", base::Time(), | 232 "harvard.com", base::Time(), |
228 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 233 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
229 // Wait for load & queued set tasks. | 234 // Wait for load & queued set tasks. |
230 base::MessageLoop::current()->RunUntilIdle(); | 235 base::MessageLoop::current()->RunUntilIdle(); |
231 | 236 |
232 EXPECT_EQ(3, store.GetChannelIDCount()); | 237 EXPECT_EQ(3, store.GetChannelIDCount()); |
233 int delete_finished = 0; | 238 int delete_finished = 0; |
234 store.DeleteAll(base::Bind(&CallCounter, &delete_finished)); | 239 store.DeleteAll(base::Bind(&CallCounter, &delete_finished)); |
235 ASSERT_EQ(1, delete_finished); | 240 ASSERT_EQ(1, delete_finished); |
236 EXPECT_EQ(0, store.GetChannelIDCount()); | 241 EXPECT_EQ(0, store.GetChannelIDCount()); |
237 } | 242 } |
238 | 243 |
239 TEST(DefaultChannelIDStoreTest, TestAsyncGetAndDeleteAll) { | 244 TEST(DefaultChannelIDStoreTest, TestAsyncGetAndDeleteAll) { |
240 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 245 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
241 persistent_store->AddChannelID(ChannelIDStore::ChannelID( | 246 persistent_store->AddChannelID(ChannelIDStore::ChannelID( |
242 "verisign.com", base::Time(), | 247 "verisign.com", base::Time(), |
243 make_scoped_ptr(crypto::ECPrivateKey::Create()))); | 248 base::WrapUnique(crypto::ECPrivateKey::Create()))); |
244 persistent_store->AddChannelID(ChannelIDStore::ChannelID( | 249 persistent_store->AddChannelID(ChannelIDStore::ChannelID( |
245 "google.com", base::Time(), | 250 "google.com", base::Time(), |
246 make_scoped_ptr(crypto::ECPrivateKey::Create()))); | 251 base::WrapUnique(crypto::ECPrivateKey::Create()))); |
247 | 252 |
248 ChannelIDStore::ChannelIDList pre_channel_ids; | 253 ChannelIDStore::ChannelIDList pre_channel_ids; |
249 ChannelIDStore::ChannelIDList post_channel_ids; | 254 ChannelIDStore::ChannelIDList post_channel_ids; |
250 int delete_finished = 0; | 255 int delete_finished = 0; |
251 DefaultChannelIDStore store(persistent_store.get()); | 256 DefaultChannelIDStore store(persistent_store.get()); |
252 | 257 |
253 store.GetAllChannelIDs(base::Bind(GetAllCallback, &pre_channel_ids)); | 258 store.GetAllChannelIDs(base::Bind(GetAllCallback, &pre_channel_ids)); |
254 store.DeleteAll(base::Bind(&CallCounter, &delete_finished)); | 259 store.DeleteAll(base::Bind(&CallCounter, &delete_finished)); |
255 store.GetAllChannelIDs(base::Bind(GetAllCallback, &post_channel_ids)); | 260 store.GetAllChannelIDs(base::Bind(GetAllCallback, &post_channel_ids)); |
256 // Tasks have not run yet. | 261 // Tasks have not run yet. |
257 EXPECT_EQ(0u, pre_channel_ids.size()); | 262 EXPECT_EQ(0u, pre_channel_ids.size()); |
258 // Wait for load & queued tasks. | 263 // Wait for load & queued tasks. |
259 base::MessageLoop::current()->RunUntilIdle(); | 264 base::MessageLoop::current()->RunUntilIdle(); |
260 EXPECT_EQ(0, store.GetChannelIDCount()); | 265 EXPECT_EQ(0, store.GetChannelIDCount()); |
261 EXPECT_EQ(2u, pre_channel_ids.size()); | 266 EXPECT_EQ(2u, pre_channel_ids.size()); |
262 EXPECT_EQ(0u, post_channel_ids.size()); | 267 EXPECT_EQ(0u, post_channel_ids.size()); |
263 } | 268 } |
264 | 269 |
265 TEST(DefaultChannelIDStoreTest, TestDelete) { | 270 TEST(DefaultChannelIDStoreTest, TestDelete) { |
266 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 271 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
267 DefaultChannelIDStore store(persistent_store.get()); | 272 DefaultChannelIDStore store(persistent_store.get()); |
268 | 273 |
269 scoped_ptr<crypto::ECPrivateKey> key; | 274 std::unique_ptr<crypto::ECPrivateKey> key; |
270 EXPECT_EQ(0, store.GetChannelIDCount()); | 275 EXPECT_EQ(0, store.GetChannelIDCount()); |
271 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 276 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
272 "verisign.com", base::Time(), | 277 "verisign.com", base::Time(), |
273 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 278 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
274 // Wait for load & queued set task. | 279 // Wait for load & queued set task. |
275 base::MessageLoop::current()->RunUntilIdle(); | 280 base::MessageLoop::current()->RunUntilIdle(); |
276 | 281 |
277 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 282 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
278 "google.com", base::Time(), | 283 "google.com", base::Time(), |
279 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 284 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
280 | 285 |
281 EXPECT_EQ(2, store.GetChannelIDCount()); | 286 EXPECT_EQ(2, store.GetChannelIDCount()); |
282 int delete_finished = 0; | 287 int delete_finished = 0; |
283 store.DeleteChannelID("verisign.com", | 288 store.DeleteChannelID("verisign.com", |
284 base::Bind(&CallCounter, &delete_finished)); | 289 base::Bind(&CallCounter, &delete_finished)); |
285 ASSERT_EQ(1, delete_finished); | 290 ASSERT_EQ(1, delete_finished); |
286 EXPECT_EQ(1, store.GetChannelIDCount()); | 291 EXPECT_EQ(1, store.GetChannelIDCount()); |
287 EXPECT_EQ(ERR_FILE_NOT_FOUND, | 292 EXPECT_EQ(ERR_FILE_NOT_FOUND, |
288 store.GetChannelID("verisign.com", &key, | 293 store.GetChannelID("verisign.com", &key, |
289 base::Bind(&GetChannelIDCallbackNotCalled))); | 294 base::Bind(&GetChannelIDCallbackNotCalled))); |
290 EXPECT_EQ(OK, store.GetChannelID("google.com", &key, | 295 EXPECT_EQ(OK, store.GetChannelID("google.com", &key, |
291 base::Bind(&GetChannelIDCallbackNotCalled))); | 296 base::Bind(&GetChannelIDCallbackNotCalled))); |
292 int delete2_finished = 0; | 297 int delete2_finished = 0; |
293 store.DeleteChannelID("google.com", | 298 store.DeleteChannelID("google.com", |
294 base::Bind(&CallCounter, &delete2_finished)); | 299 base::Bind(&CallCounter, &delete2_finished)); |
295 ASSERT_EQ(1, delete2_finished); | 300 ASSERT_EQ(1, delete2_finished); |
296 EXPECT_EQ(0, store.GetChannelIDCount()); | 301 EXPECT_EQ(0, store.GetChannelIDCount()); |
297 EXPECT_EQ(ERR_FILE_NOT_FOUND, | 302 EXPECT_EQ(ERR_FILE_NOT_FOUND, |
298 store.GetChannelID("google.com", &key, | 303 store.GetChannelID("google.com", &key, |
299 base::Bind(&GetChannelIDCallbackNotCalled))); | 304 base::Bind(&GetChannelIDCallbackNotCalled))); |
300 } | 305 } |
301 | 306 |
302 TEST(DefaultChannelIDStoreTest, TestAsyncDelete) { | 307 TEST(DefaultChannelIDStoreTest, TestAsyncDelete) { |
303 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 308 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
304 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); | 309 std::unique_ptr<crypto::ECPrivateKey> expected_key( |
| 310 crypto::ECPrivateKey::Create()); |
305 persistent_store->AddChannelID(ChannelIDStore::ChannelID( | 311 persistent_store->AddChannelID(ChannelIDStore::ChannelID( |
306 "a.com", base::Time::FromInternalValue(1), | 312 "a.com", base::Time::FromInternalValue(1), |
307 make_scoped_ptr(crypto::ECPrivateKey::Create()))); | 313 base::WrapUnique(crypto::ECPrivateKey::Create()))); |
308 persistent_store->AddChannelID( | 314 persistent_store->AddChannelID( |
309 ChannelIDStore::ChannelID("b.com", base::Time::FromInternalValue(3), | 315 ChannelIDStore::ChannelID("b.com", base::Time::FromInternalValue(3), |
310 make_scoped_ptr(expected_key->Copy()))); | 316 base::WrapUnique(expected_key->Copy()))); |
311 DefaultChannelIDStore store(persistent_store.get()); | 317 DefaultChannelIDStore store(persistent_store.get()); |
312 int delete_finished = 0; | 318 int delete_finished = 0; |
313 store.DeleteChannelID("a.com", | 319 store.DeleteChannelID("a.com", |
314 base::Bind(&CallCounter, &delete_finished)); | 320 base::Bind(&CallCounter, &delete_finished)); |
315 | 321 |
316 AsyncGetChannelIDHelper a_helper; | 322 AsyncGetChannelIDHelper a_helper; |
317 AsyncGetChannelIDHelper b_helper; | 323 AsyncGetChannelIDHelper b_helper; |
318 scoped_ptr<crypto::ECPrivateKey> key; | 324 std::unique_ptr<crypto::ECPrivateKey> key; |
319 EXPECT_EQ(0, store.GetChannelIDCount()); | 325 EXPECT_EQ(0, store.GetChannelIDCount()); |
320 EXPECT_EQ(ERR_IO_PENDING, | 326 EXPECT_EQ(ERR_IO_PENDING, |
321 store.GetChannelID("a.com", &key, | 327 store.GetChannelID("a.com", &key, |
322 base::Bind(&AsyncGetChannelIDHelper::Callback, | 328 base::Bind(&AsyncGetChannelIDHelper::Callback, |
323 base::Unretained(&a_helper)))); | 329 base::Unretained(&a_helper)))); |
324 EXPECT_EQ(ERR_IO_PENDING, | 330 EXPECT_EQ(ERR_IO_PENDING, |
325 store.GetChannelID("b.com", &key, | 331 store.GetChannelID("b.com", &key, |
326 base::Bind(&AsyncGetChannelIDHelper::Callback, | 332 base::Bind(&AsyncGetChannelIDHelper::Callback, |
327 base::Unretained(&b_helper)))); | 333 base::Unretained(&b_helper)))); |
328 | 334 |
(...skipping 13 matching lines...) Expand all Loading... |
342 EXPECT_EQ(OK, b_helper.err_); | 348 EXPECT_EQ(OK, b_helper.err_); |
343 EXPECT_EQ("b.com", b_helper.server_identifier_); | 349 EXPECT_EQ("b.com", b_helper.server_identifier_); |
344 EXPECT_TRUE(KeysEqual(expected_key.get(), b_helper.key_.get())); | 350 EXPECT_TRUE(KeysEqual(expected_key.get(), b_helper.key_.get())); |
345 } | 351 } |
346 | 352 |
347 TEST(DefaultChannelIDStoreTest, TestGetAll) { | 353 TEST(DefaultChannelIDStoreTest, TestGetAll) { |
348 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 354 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
349 DefaultChannelIDStore store(persistent_store.get()); | 355 DefaultChannelIDStore store(persistent_store.get()); |
350 | 356 |
351 EXPECT_EQ(0, store.GetChannelIDCount()); | 357 EXPECT_EQ(0, store.GetChannelIDCount()); |
352 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 358 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
353 "verisign.com", base::Time(), | 359 "verisign.com", base::Time(), |
354 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 360 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
355 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 361 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
356 "google.com", base::Time(), | 362 "google.com", base::Time(), |
357 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 363 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
358 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 364 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
359 "harvard.com", base::Time(), | 365 "harvard.com", base::Time(), |
360 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 366 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
361 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 367 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
362 "mit.com", base::Time(), | 368 "mit.com", base::Time(), |
363 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 369 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
364 // Wait for load & queued set tasks. | 370 // Wait for load & queued set tasks. |
365 base::MessageLoop::current()->RunUntilIdle(); | 371 base::MessageLoop::current()->RunUntilIdle(); |
366 | 372 |
367 EXPECT_EQ(4, store.GetChannelIDCount()); | 373 EXPECT_EQ(4, store.GetChannelIDCount()); |
368 ChannelIDStore::ChannelIDList channel_ids; | 374 ChannelIDStore::ChannelIDList channel_ids; |
369 store.GetAllChannelIDs(base::Bind(GetAllCallback, &channel_ids)); | 375 store.GetAllChannelIDs(base::Bind(GetAllCallback, &channel_ids)); |
370 EXPECT_EQ(4u, channel_ids.size()); | 376 EXPECT_EQ(4u, channel_ids.size()); |
371 } | 377 } |
372 | 378 |
373 TEST(DefaultChannelIDStoreTest, TestInitializeFrom) { | 379 TEST(DefaultChannelIDStoreTest, TestInitializeFrom) { |
374 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 380 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
375 DefaultChannelIDStore store(persistent_store.get()); | 381 DefaultChannelIDStore store(persistent_store.get()); |
376 scoped_ptr<crypto::ECPrivateKey> preexisting_key( | 382 std::unique_ptr<crypto::ECPrivateKey> preexisting_key( |
377 crypto::ECPrivateKey::Create()); | 383 crypto::ECPrivateKey::Create()); |
378 scoped_ptr<crypto::ECPrivateKey> both_key(crypto::ECPrivateKey::Create()); | 384 std::unique_ptr<crypto::ECPrivateKey> both_key( |
379 scoped_ptr<crypto::ECPrivateKey> copied_key(crypto::ECPrivateKey::Create()); | 385 crypto::ECPrivateKey::Create()); |
| 386 std::unique_ptr<crypto::ECPrivateKey> copied_key( |
| 387 crypto::ECPrivateKey::Create()); |
380 | 388 |
381 store.SetChannelID(make_scoped_ptr( | 389 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
382 new ChannelIDStore::ChannelID("preexisting.com", base::Time(), | 390 "preexisting.com", base::Time(), |
383 make_scoped_ptr(preexisting_key->Copy())))); | 391 base::WrapUnique(preexisting_key->Copy())))); |
384 store.SetChannelID(make_scoped_ptr(new ChannelIDStore::ChannelID( | 392 store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID( |
385 "both.com", base::Time(), | 393 "both.com", base::Time(), |
386 make_scoped_ptr(crypto::ECPrivateKey::Create())))); | 394 base::WrapUnique(crypto::ECPrivateKey::Create())))); |
387 // Wait for load & queued set tasks. | 395 // Wait for load & queued set tasks. |
388 base::MessageLoop::current()->RunUntilIdle(); | 396 base::MessageLoop::current()->RunUntilIdle(); |
389 EXPECT_EQ(2, store.GetChannelIDCount()); | 397 EXPECT_EQ(2, store.GetChannelIDCount()); |
390 | 398 |
391 ChannelIDStore::ChannelIDList source_channel_ids; | 399 ChannelIDStore::ChannelIDList source_channel_ids; |
392 source_channel_ids.push_back(ChannelIDStore::ChannelID( | 400 source_channel_ids.push_back(ChannelIDStore::ChannelID( |
393 "both.com", base::Time(), | 401 "both.com", base::Time(), |
394 // Key differs from above to test that existing entries are overwritten. | 402 // Key differs from above to test that existing entries are overwritten. |
395 make_scoped_ptr(both_key->Copy()))); | 403 base::WrapUnique(both_key->Copy()))); |
396 source_channel_ids.push_back(ChannelIDStore::ChannelID( | 404 source_channel_ids.push_back(ChannelIDStore::ChannelID( |
397 "copied.com", base::Time(), make_scoped_ptr(copied_key->Copy()))); | 405 "copied.com", base::Time(), base::WrapUnique(copied_key->Copy()))); |
398 store.InitializeFrom(source_channel_ids); | 406 store.InitializeFrom(source_channel_ids); |
399 EXPECT_EQ(3, store.GetChannelIDCount()); | 407 EXPECT_EQ(3, store.GetChannelIDCount()); |
400 | 408 |
401 ChannelIDStore::ChannelIDList channel_ids; | 409 ChannelIDStore::ChannelIDList channel_ids; |
402 store.GetAllChannelIDs(base::Bind(GetAllCallback, &channel_ids)); | 410 store.GetAllChannelIDs(base::Bind(GetAllCallback, &channel_ids)); |
403 ASSERT_EQ(3u, channel_ids.size()); | 411 ASSERT_EQ(3u, channel_ids.size()); |
404 | 412 |
405 ChannelIDStore::ChannelIDList::iterator channel_id = channel_ids.begin(); | 413 ChannelIDStore::ChannelIDList::iterator channel_id = channel_ids.begin(); |
406 EXPECT_EQ("both.com", channel_id->server_identifier()); | 414 EXPECT_EQ("both.com", channel_id->server_identifier()); |
407 EXPECT_TRUE(KeysEqual(both_key.get(), channel_id->key())); | 415 EXPECT_TRUE(KeysEqual(both_key.get(), channel_id->key())); |
408 | 416 |
409 ++channel_id; | 417 ++channel_id; |
410 EXPECT_EQ("copied.com", channel_id->server_identifier()); | 418 EXPECT_EQ("copied.com", channel_id->server_identifier()); |
411 EXPECT_TRUE(KeysEqual(copied_key.get(), channel_id->key())); | 419 EXPECT_TRUE(KeysEqual(copied_key.get(), channel_id->key())); |
412 | 420 |
413 ++channel_id; | 421 ++channel_id; |
414 EXPECT_EQ("preexisting.com", channel_id->server_identifier()); | 422 EXPECT_EQ("preexisting.com", channel_id->server_identifier()); |
415 EXPECT_TRUE(KeysEqual(preexisting_key.get(), channel_id->key())); | 423 EXPECT_TRUE(KeysEqual(preexisting_key.get(), channel_id->key())); |
416 } | 424 } |
417 | 425 |
418 TEST(DefaultChannelIDStoreTest, TestAsyncInitializeFrom) { | 426 TEST(DefaultChannelIDStoreTest, TestAsyncInitializeFrom) { |
419 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); | 427 scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore); |
420 scoped_ptr<crypto::ECPrivateKey> preexisting_key( | 428 std::unique_ptr<crypto::ECPrivateKey> preexisting_key( |
421 crypto::ECPrivateKey::Create()); | 429 crypto::ECPrivateKey::Create()); |
422 scoped_ptr<crypto::ECPrivateKey> both_key(crypto::ECPrivateKey::Create()); | 430 std::unique_ptr<crypto::ECPrivateKey> both_key( |
423 scoped_ptr<crypto::ECPrivateKey> copied_key(crypto::ECPrivateKey::Create()); | 431 crypto::ECPrivateKey::Create()); |
| 432 std::unique_ptr<crypto::ECPrivateKey> copied_key( |
| 433 crypto::ECPrivateKey::Create()); |
424 | 434 |
425 persistent_store->AddChannelID( | 435 persistent_store->AddChannelID( |
426 ChannelIDStore::ChannelID("preexisting.com", base::Time(), | 436 ChannelIDStore::ChannelID("preexisting.com", base::Time(), |
427 make_scoped_ptr(preexisting_key->Copy()))); | 437 base::WrapUnique(preexisting_key->Copy()))); |
428 persistent_store->AddChannelID(ChannelIDStore::ChannelID( | 438 persistent_store->AddChannelID(ChannelIDStore::ChannelID( |
429 "both.com", base::Time(), | 439 "both.com", base::Time(), |
430 make_scoped_ptr(crypto::ECPrivateKey::Create()))); | 440 base::WrapUnique(crypto::ECPrivateKey::Create()))); |
431 | 441 |
432 DefaultChannelIDStore store(persistent_store.get()); | 442 DefaultChannelIDStore store(persistent_store.get()); |
433 ChannelIDStore::ChannelIDList source_channel_ids; | 443 ChannelIDStore::ChannelIDList source_channel_ids; |
434 source_channel_ids.push_back(ChannelIDStore::ChannelID( | 444 source_channel_ids.push_back(ChannelIDStore::ChannelID( |
435 "both.com", base::Time(), | 445 "both.com", base::Time(), |
436 // Key differs from above to test that existing entries are overwritten. | 446 // Key differs from above to test that existing entries are overwritten. |
437 make_scoped_ptr(both_key->Copy()))); | 447 base::WrapUnique(both_key->Copy()))); |
438 source_channel_ids.push_back(ChannelIDStore::ChannelID( | 448 source_channel_ids.push_back(ChannelIDStore::ChannelID( |
439 "copied.com", base::Time(), make_scoped_ptr(copied_key->Copy()))); | 449 "copied.com", base::Time(), base::WrapUnique(copied_key->Copy()))); |
440 store.InitializeFrom(source_channel_ids); | 450 store.InitializeFrom(source_channel_ids); |
441 EXPECT_EQ(0, store.GetChannelIDCount()); | 451 EXPECT_EQ(0, store.GetChannelIDCount()); |
442 // Wait for load & queued tasks. | 452 // Wait for load & queued tasks. |
443 base::MessageLoop::current()->RunUntilIdle(); | 453 base::MessageLoop::current()->RunUntilIdle(); |
444 EXPECT_EQ(3, store.GetChannelIDCount()); | 454 EXPECT_EQ(3, store.GetChannelIDCount()); |
445 | 455 |
446 ChannelIDStore::ChannelIDList channel_ids; | 456 ChannelIDStore::ChannelIDList channel_ids; |
447 store.GetAllChannelIDs(base::Bind(GetAllCallback, &channel_ids)); | 457 store.GetAllChannelIDs(base::Bind(GetAllCallback, &channel_ids)); |
448 ASSERT_EQ(3u, channel_ids.size()); | 458 ASSERT_EQ(3u, channel_ids.size()); |
449 | 459 |
450 ChannelIDStore::ChannelIDList::iterator channel_id = channel_ids.begin(); | 460 ChannelIDStore::ChannelIDList::iterator channel_id = channel_ids.begin(); |
451 EXPECT_EQ("both.com", channel_id->server_identifier()); | 461 EXPECT_EQ("both.com", channel_id->server_identifier()); |
452 EXPECT_TRUE(KeysEqual(both_key.get(), channel_id->key())); | 462 EXPECT_TRUE(KeysEqual(both_key.get(), channel_id->key())); |
453 | 463 |
454 ++channel_id; | 464 ++channel_id; |
455 EXPECT_EQ("copied.com", channel_id->server_identifier()); | 465 EXPECT_EQ("copied.com", channel_id->server_identifier()); |
456 EXPECT_TRUE(KeysEqual(copied_key.get(), channel_id->key())); | 466 EXPECT_TRUE(KeysEqual(copied_key.get(), channel_id->key())); |
457 | 467 |
458 ++channel_id; | 468 ++channel_id; |
459 EXPECT_EQ("preexisting.com", channel_id->server_identifier()); | 469 EXPECT_EQ("preexisting.com", channel_id->server_identifier()); |
460 EXPECT_TRUE(KeysEqual(preexisting_key.get(), channel_id->key())); | 470 EXPECT_TRUE(KeysEqual(preexisting_key.get(), channel_id->key())); |
461 } | 471 } |
462 | 472 |
463 } // namespace net | 473 } // namespace net |
OLD | NEW |