OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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", ¶m)); | 335 ASSERT_TRUE(observer[0].GetValue(0)->GetInteger("params", ¶m)); |
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", ¶m)); | 338 ASSERT_TRUE(observer[1].GetValue(0)->GetInteger("params", ¶m)); |
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 |
OLD | NEW |