Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(139)

Side by Side Diff: net/log/net_log_unittest.cc

Issue 1059843002: Refactor NetLog::LogLevel --> NetLogCaptureMode. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebase again to fix a merge conflict Created 5 years, 8 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
« no previous file with comments | « net/log/net_log_capture_mode_unittest.cc ('k') | net/log/net_log_util.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2013 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/log/net_log_unittest.h" 5 #include "net/log/net_log_unittest.h"
6 6
7 #include "base/bind.h" 7 #include "base/bind.h"
8 #include "base/memory/scoped_vector.h" 8 #include "base/memory/scoped_vector.h"
9 #include "base/synchronization/waitable_event.h" 9 #include "base/synchronization/waitable_event.h"
10 #include "base/threading/simple_thread.h" 10 #include "base/threading/simple_thread.h"
11 #include "base/values.h" 11 #include "base/values.h"
12 #include "net/base/net_errors.h" 12 #include "net/base/net_errors.h"
13 13
14 namespace net { 14 namespace net {
15 15
16 namespace { 16 namespace {
17 17
18 const int kThreads = 10; 18 const int kThreads = 10;
19 const int kEvents = 100; 19 const int kEvents = 100;
20 20
21 base::Value* NetLogLevelCallback(NetLog::LogLevel log_level) { 21 base::Value* CaptureModeToValue(NetLogCaptureMode capture_mode) {
22 return new base::FundamentalValue(capture_mode.ToInternalValueForTesting());
23 }
24
25 base::Value* NetCaptureModeCallback(NetLogCaptureMode capture_mode) {
22 base::DictionaryValue* dict = new base::DictionaryValue(); 26 base::DictionaryValue* dict = new base::DictionaryValue();
23 dict->SetInteger("log_level", log_level); 27 dict->Set("capture_mode", CaptureModeToValue(capture_mode));
24 return dict; 28 return dict;
25 } 29 }
26 30
27 TEST(NetLogTest, Basic) { 31 TEST(NetLogTest, Basic) {
28 TestNetLog net_log; 32 TestNetLog net_log;
29 TestNetLog::CapturedEntryList entries; 33 TestNetLog::CapturedEntryList entries;
30 net_log.GetEntries(&entries); 34 net_log.GetEntries(&entries);
31 EXPECT_EQ(0u, entries.size()); 35 EXPECT_EQ(0u, entries.size());
32 36
33 net_log.AddGlobalEntry(NetLog::TYPE_CANCELLED); 37 net_log.AddGlobalEntry(NetLog::TYPE_CANCELLED);
34 38
35 net_log.GetEntries(&entries); 39 net_log.GetEntries(&entries);
36 ASSERT_EQ(1u, entries.size()); 40 ASSERT_EQ(1u, entries.size());
37 EXPECT_EQ(NetLog::TYPE_CANCELLED, entries[0].type); 41 EXPECT_EQ(NetLog::TYPE_CANCELLED, entries[0].type);
38 EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type); 42 EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
39 EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id); 43 EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
40 EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase); 44 EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
41 EXPECT_GE(base::TimeTicks::Now(), entries[0].time); 45 EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
42 EXPECT_FALSE(entries[0].params); 46 EXPECT_FALSE(entries[0].params);
43 } 47 }
44 48
45 // Check that the correct LogLevel is sent to NetLog Value callbacks. 49 // Check that the correct CaptureMode is sent to NetLog Value callbacks.
46 TEST(NetLogTest, LogLevels) { 50 TEST(NetLogTest, CaptureModes) {
51 NetLogCaptureMode kModes[] = {
52 NetLogCaptureMode::Default(),
53 NetLogCaptureMode::IncludeCookiesAndCredentials(),
54 NetLogCaptureMode::IncludeSocketBytes(),
55 };
56
47 TestNetLog net_log; 57 TestNetLog net_log;
48 for (int log_level = NetLog::LOG_ALL; log_level < NetLog::LOG_NONE; 58
49 ++log_level) { 59 for (NetLogCaptureMode mode : kModes) {
50 net_log.SetLogLevel(static_cast<NetLog::LogLevel>(log_level)); 60 net_log.SetCaptureMode(mode);
51 EXPECT_EQ(log_level, net_log.GetLogLevel()); 61 EXPECT_EQ(mode, net_log.GetCaptureMode());
52 62
53 net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE, 63 net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE,
54 base::Bind(NetLogLevelCallback)); 64 base::Bind(NetCaptureModeCallback));
55 65
56 TestNetLog::CapturedEntryList entries; 66 TestNetLog::CapturedEntryList entries;
57 net_log.GetEntries(&entries); 67 net_log.GetEntries(&entries);
58 68
59 ASSERT_EQ(1u, entries.size()); 69 ASSERT_EQ(1u, entries.size());
60 EXPECT_EQ(NetLog::TYPE_SOCKET_ALIVE, entries[0].type); 70 EXPECT_EQ(NetLog::TYPE_SOCKET_ALIVE, entries[0].type);
61 EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type); 71 EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
62 EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id); 72 EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
63 EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase); 73 EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
64 EXPECT_GE(base::TimeTicks::Now(), entries[0].time); 74 EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
65 75
66 int logged_log_level; 76 int logged_capture_mode;
67 ASSERT_TRUE(entries[0].GetIntegerValue("log_level", &logged_log_level)); 77 ASSERT_TRUE(
68 EXPECT_EQ(log_level, logged_log_level); 78 entries[0].GetIntegerValue("capture_mode", &logged_capture_mode));
79 EXPECT_EQ(mode.ToInternalValueForTesting(), logged_capture_mode);
69 80
70 net_log.Clear(); 81 net_log.Clear();
71 } 82 }
72 } 83 }
73 84
74 class CountingObserver : public NetLog::ThreadSafeObserver { 85 class CountingObserver : public NetLog::ThreadSafeObserver {
75 public: 86 public:
76 CountingObserver() : count_(0) {} 87 CountingObserver() : count_(0) {}
77 88
78 ~CountingObserver() override { 89 ~CountingObserver() override {
(...skipping 25 matching lines...) Expand all
104 values_.push_back(dict); 115 values_.push_back(dict);
105 } 116 }
106 117
107 size_t GetNumValues() const { return values_.size(); } 118 size_t GetNumValues() const { return values_.size(); }
108 base::DictionaryValue* GetValue(size_t index) const { return values_[index]; } 119 base::DictionaryValue* GetValue(size_t index) const { return values_[index]; }
109 120
110 private: 121 private:
111 ScopedVector<base::DictionaryValue> values_; 122 ScopedVector<base::DictionaryValue> values_;
112 }; 123 };
113 124
114 base::Value* LogLevelToValue(NetLog::LogLevel log_level) {
115 return new base::FundamentalValue(log_level);
116 }
117
118 void AddEvent(NetLog* net_log) { 125 void AddEvent(NetLog* net_log) {
119 net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED, base::Bind(LogLevelToValue)); 126 net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED,
127 base::Bind(CaptureModeToValue));
120 } 128 }
121 129
122 // A thread that waits until an event has been signalled before calling 130 // A thread that waits until an event has been signalled before calling
123 // RunTestThread. 131 // RunTestThread.
124 class NetLogTestThread : public base::SimpleThread { 132 class NetLogTestThread : public base::SimpleThread {
125 public: 133 public:
126 NetLogTestThread() 134 NetLogTestThread()
127 : base::SimpleThread("NetLogTest"), net_log_(NULL), start_event_(NULL) {} 135 : base::SimpleThread("NetLogTest"), net_log_(NULL), start_event_(NULL) {}
128 136
129 // We'll wait for |start_event| to be triggered before calling a subclass's 137 // We'll wait for |start_event| to be triggered before calling a subclass's
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
173 public: 181 public:
174 AddRemoveObserverTestThread() {} 182 AddRemoveObserverTestThread() {}
175 183
176 ~AddRemoveObserverTestThread() override { EXPECT_TRUE(!observer_.net_log()); } 184 ~AddRemoveObserverTestThread() override { EXPECT_TRUE(!observer_.net_log()); }
177 185
178 private: 186 private:
179 void RunTestThread() override { 187 void RunTestThread() override {
180 for (int i = 0; i < kEvents; ++i) { 188 for (int i = 0; i < kEvents; ++i) {
181 ASSERT_FALSE(observer_.net_log()); 189 ASSERT_FALSE(observer_.net_log());
182 190
183 net_log_->DeprecatedAddObserver(&observer_, NetLog::LOG_ALL_BUT_BYTES); 191 net_log_->DeprecatedAddObserver(
192 &observer_, NetLogCaptureMode::IncludeCookiesAndCredentials());
184 ASSERT_EQ(net_log_, observer_.net_log()); 193 ASSERT_EQ(net_log_, observer_.net_log());
185 ASSERT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer_.log_level()); 194 ASSERT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
186 ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL_BUT_BYTES); 195 observer_.capture_mode());
187 196
188 net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL); 197 net_log_->SetObserverCaptureMode(&observer_,
198 NetLogCaptureMode::IncludeSocketBytes());
189 ASSERT_EQ(net_log_, observer_.net_log()); 199 ASSERT_EQ(net_log_, observer_.net_log());
190 ASSERT_EQ(NetLog::LOG_ALL, observer_.log_level()); 200 ASSERT_EQ(NetLogCaptureMode::IncludeSocketBytes(),
191 ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL); 201 observer_.capture_mode());
192 202
193 net_log_->DeprecatedRemoveObserver(&observer_); 203 net_log_->DeprecatedRemoveObserver(&observer_);
194 ASSERT_TRUE(!observer_.net_log()); 204 ASSERT_TRUE(!observer_.net_log());
195 } 205 }
196 } 206 }
197 207
198 CountingObserver observer_; 208 CountingObserver observer_;
199 209
200 DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread); 210 DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread);
201 }; 211 };
(...skipping 16 matching lines...) Expand all
218 threads[i].Join(); 228 threads[i].Join();
219 } 229 }
220 230
221 // Makes sure that events on multiple threads are dispatched to all observers. 231 // Makes sure that events on multiple threads are dispatched to all observers.
222 TEST(NetLogTest, NetLogEventThreads) { 232 TEST(NetLogTest, NetLogEventThreads) {
223 NetLog net_log; 233 NetLog net_log;
224 234
225 // Attach some observers. Since they're created after |net_log|, they'll 235 // Attach some observers. Since they're created after |net_log|, they'll
226 // safely detach themselves on destruction. 236 // safely detach themselves on destruction.
227 CountingObserver observers[3]; 237 CountingObserver observers[3];
228 for (size_t i = 0; i < arraysize(observers); ++i) 238 for (size_t i = 0; i < arraysize(observers); ++i) {
229 net_log.DeprecatedAddObserver(&observers[i], NetLog::LOG_ALL); 239 net_log.DeprecatedAddObserver(&observers[i],
240 NetLogCaptureMode::IncludeSocketBytes());
241 }
230 242
231 // Run a bunch of threads to completion, each of which will emit events to 243 // Run a bunch of threads to completion, each of which will emit events to
232 // |net_log|. 244 // |net_log|.
233 RunTestThreads<AddEventsTestThread>(&net_log); 245 RunTestThreads<AddEventsTestThread>(&net_log);
234 246
235 // Check that each observer saw the emitted events. 247 // Check that each observer saw the emitted events.
236 const int kTotalEvents = kThreads * kEvents; 248 const int kTotalEvents = kThreads * kEvents;
237 for (size_t i = 0; i < arraysize(observers); ++i) 249 for (size_t i = 0; i < arraysize(observers); ++i)
238 EXPECT_EQ(kTotalEvents, observers[i].count()); 250 EXPECT_EQ(kTotalEvents, observers[i].count());
239 } 251 }
240 252
241 // Test adding and removing a single observer. 253 // Test adding and removing a single observer.
242 TEST(NetLogTest, NetLogAddRemoveObserver) { 254 TEST(NetLogTest, NetLogAddRemoveObserver) {
243 NetLog net_log; 255 NetLog net_log;
244 CountingObserver observer; 256 CountingObserver observer;
245 257
246 AddEvent(&net_log); 258 AddEvent(&net_log);
247 EXPECT_EQ(0, observer.count()); 259 EXPECT_EQ(0, observer.count());
248 EXPECT_EQ(NULL, observer.net_log()); 260 EXPECT_EQ(NULL, observer.net_log());
249 EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel()); 261 EXPECT_FALSE(net_log.GetCaptureMode().enabled());
250 262
251 // Add the observer and add an event. 263 // Add the observer and add an event.
252 net_log.DeprecatedAddObserver(&observer, NetLog::LOG_ALL_BUT_BYTES); 264 net_log.DeprecatedAddObserver(
265 &observer, NetLogCaptureMode::IncludeCookiesAndCredentials());
253 EXPECT_EQ(&net_log, observer.net_log()); 266 EXPECT_EQ(&net_log, observer.net_log());
254 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer.log_level()); 267 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
255 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel()); 268 observer.capture_mode());
269 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
270 net_log.GetCaptureMode());
256 271
257 AddEvent(&net_log); 272 AddEvent(&net_log);
258 EXPECT_EQ(1, observer.count()); 273 EXPECT_EQ(1, observer.count());
259 274
260 // Change the observer's logging level and add an event. 275 // Change the observer's logging level and add an event.
261 net_log.SetObserverLogLevel(&observer, NetLog::LOG_ALL); 276 net_log.SetObserverCaptureMode(&observer,
277 NetLogCaptureMode::IncludeSocketBytes());
262 EXPECT_EQ(&net_log, observer.net_log()); 278 EXPECT_EQ(&net_log, observer.net_log());
263 EXPECT_EQ(NetLog::LOG_ALL, observer.log_level()); 279 EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), observer.capture_mode());
264 EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel()); 280 EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), net_log.GetCaptureMode());
265 281
266 AddEvent(&net_log); 282 AddEvent(&net_log);
267 EXPECT_EQ(2, observer.count()); 283 EXPECT_EQ(2, observer.count());
268 284
269 // Remove observer and add an event. 285 // Remove observer and add an event.
270 net_log.DeprecatedRemoveObserver(&observer); 286 net_log.DeprecatedRemoveObserver(&observer);
271 EXPECT_EQ(NULL, observer.net_log()); 287 EXPECT_EQ(NULL, observer.net_log());
272 EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel()); 288 EXPECT_FALSE(net_log.GetCaptureMode().enabled());
273 289
274 AddEvent(&net_log); 290 AddEvent(&net_log);
275 EXPECT_EQ(2, observer.count()); 291 EXPECT_EQ(2, observer.count());
276 292
277 // Add the observer a final time, and add an event. 293 // Add the observer a final time, and add an event.
278 net_log.DeprecatedAddObserver(&observer, NetLog::LOG_ALL); 294 net_log.DeprecatedAddObserver(&observer,
295 NetLogCaptureMode::IncludeSocketBytes());
279 EXPECT_EQ(&net_log, observer.net_log()); 296 EXPECT_EQ(&net_log, observer.net_log());
280 EXPECT_EQ(NetLog::LOG_ALL, observer.log_level()); 297 EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), observer.capture_mode());
281 EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel()); 298 EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), net_log.GetCaptureMode());
282 299
283 AddEvent(&net_log); 300 AddEvent(&net_log);
284 EXPECT_EQ(3, observer.count()); 301 EXPECT_EQ(3, observer.count());
285 } 302 }
286 303
287 // Test adding and removing two observers at different log levels. 304 // Test adding and removing two observers at different log levels.
288 TEST(NetLogTest, NetLogTwoObservers) { 305 TEST(NetLogTest, NetLogTwoObservers) {
289 NetLog net_log; 306 NetLog net_log;
290 LoggingObserver observer[2]; 307 LoggingObserver observer[2];
291 308
292 // Add first observer. 309 // Add first observer.
293 net_log.DeprecatedAddObserver(&observer[0], NetLog::LOG_ALL_BUT_BYTES); 310 net_log.DeprecatedAddObserver(
311 &observer[0], NetLogCaptureMode::IncludeCookiesAndCredentials());
294 EXPECT_EQ(&net_log, observer[0].net_log()); 312 EXPECT_EQ(&net_log, observer[0].net_log());
295 EXPECT_EQ(NULL, observer[1].net_log()); 313 EXPECT_EQ(NULL, observer[1].net_log());
296 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level()); 314 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
297 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel()); 315 observer[0].capture_mode());
316 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
317 net_log.GetCaptureMode());
298 318
299 // Add second observer observer. 319 // Add second observer observer.
300 net_log.DeprecatedAddObserver(&observer[1], NetLog::LOG_ALL); 320 net_log.DeprecatedAddObserver(&observer[1],
321 NetLogCaptureMode::IncludeSocketBytes());
301 EXPECT_EQ(&net_log, observer[0].net_log()); 322 EXPECT_EQ(&net_log, observer[0].net_log());
302 EXPECT_EQ(&net_log, observer[1].net_log()); 323 EXPECT_EQ(&net_log, observer[1].net_log());
303 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level()); 324 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
304 EXPECT_EQ(NetLog::LOG_ALL, observer[1].log_level()); 325 observer[0].capture_mode());
305 EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel()); 326 EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(),
327 observer[1].capture_mode());
328 EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), net_log.GetCaptureMode());
306 329
307 // Add event and make sure both observers receive it at their respective log 330 // Add event and make sure both observers receive it at their respective log
308 // levels. 331 // levels.
309 int param; 332 int param;
310 AddEvent(&net_log); 333 AddEvent(&net_log);
311 ASSERT_EQ(1U, observer[0].GetNumValues()); 334 ASSERT_EQ(1U, observer[0].GetNumValues());
312 ASSERT_TRUE(observer[0].GetValue(0)->GetInteger("params", &param)); 335 ASSERT_TRUE(observer[0].GetValue(0)->GetInteger("params", &param));
313 EXPECT_EQ(observer[0].log_level(), param); 336 EXPECT_EQ(observer[0].capture_mode().ToInternalValueForTesting(), param);
314 ASSERT_EQ(1U, observer[1].GetNumValues()); 337 ASSERT_EQ(1U, observer[1].GetNumValues());
315 ASSERT_TRUE(observer[1].GetValue(0)->GetInteger("params", &param)); 338 ASSERT_TRUE(observer[1].GetValue(0)->GetInteger("params", &param));
316 EXPECT_EQ(observer[1].log_level(), param); 339 EXPECT_EQ(observer[1].capture_mode().ToInternalValueForTesting(), param);
317 340
318 // Remove second observer. 341 // Remove second observer.
319 net_log.DeprecatedRemoveObserver(&observer[1]); 342 net_log.DeprecatedRemoveObserver(&observer[1]);
320 EXPECT_EQ(&net_log, observer[0].net_log()); 343 EXPECT_EQ(&net_log, observer[0].net_log());
321 EXPECT_EQ(NULL, observer[1].net_log()); 344 EXPECT_EQ(NULL, observer[1].net_log());
322 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level()); 345 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
323 EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel()); 346 observer[0].capture_mode());
347 EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
348 net_log.GetCaptureMode());
324 349
325 // Add event and make sure only second observer gets it. 350 // Add event and make sure only second observer gets it.
326 AddEvent(&net_log); 351 AddEvent(&net_log);
327 EXPECT_EQ(2U, observer[0].GetNumValues()); 352 EXPECT_EQ(2U, observer[0].GetNumValues());
328 EXPECT_EQ(1U, observer[1].GetNumValues()); 353 EXPECT_EQ(1U, observer[1].GetNumValues());
329 354
330 // Remove first observer. 355 // Remove first observer.
331 net_log.DeprecatedRemoveObserver(&observer[0]); 356 net_log.DeprecatedRemoveObserver(&observer[0]);
332 EXPECT_EQ(NULL, observer[0].net_log()); 357 EXPECT_EQ(NULL, observer[0].net_log());
333 EXPECT_EQ(NULL, observer[1].net_log()); 358 EXPECT_EQ(NULL, observer[1].net_log());
334 EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel()); 359 EXPECT_FALSE(net_log.GetCaptureMode().enabled());
335 360
336 // Add event and make sure neither observer gets it. 361 // Add event and make sure neither observer gets it.
337 AddEvent(&net_log); 362 AddEvent(&net_log);
338 EXPECT_EQ(2U, observer[0].GetNumValues()); 363 EXPECT_EQ(2U, observer[0].GetNumValues());
339 EXPECT_EQ(1U, observer[1].GetNumValues()); 364 EXPECT_EQ(1U, observer[1].GetNumValues());
340 } 365 }
341 366
342 // Makes sure that adding and removing observers simultaneously on different 367 // Makes sure that adding and removing observers simultaneously on different
343 // threads works. 368 // threads works.
344 TEST(NetLogTest, NetLogAddRemoveObserverThreads) { 369 TEST(NetLogTest, NetLogAddRemoveObserverThreads) {
345 NetLog net_log; 370 NetLog net_log;
346 371
347 // Run a bunch of threads to completion, each of which will repeatedly add 372 // Run a bunch of threads to completion, each of which will repeatedly add
348 // and remove an observer, and set its logging level. 373 // and remove an observer, and set its logging level.
349 RunTestThreads<AddRemoveObserverTestThread>(&net_log); 374 RunTestThreads<AddRemoveObserverTestThread>(&net_log);
350 } 375 }
351 376
352 } // namespace 377 } // namespace
353 378
354 } // namespace net 379 } // namespace net
OLDNEW
« no previous file with comments | « net/log/net_log_capture_mode_unittest.cc ('k') | net/log/net_log_util.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698