OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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 "base/synchronization/waitable_event_watcher.h" | 5 #include "base/synchronization/waitable_event_watcher.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/callback.h" | 8 #include "base/callback.h" |
9 #include "base/macros.h" | 9 #include "base/macros.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
45 }; | 45 }; |
46 | 46 |
47 void RunTest_BasicSignal(MessageLoop::Type message_loop_type) { | 47 void RunTest_BasicSignal(MessageLoop::Type message_loop_type) { |
48 MessageLoop message_loop(message_loop_type); | 48 MessageLoop message_loop(message_loop_type); |
49 | 49 |
50 // A manual-reset event that is not yet signaled. | 50 // A manual-reset event that is not yet signaled. |
51 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, | 51 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, |
52 WaitableEvent::InitialState::NOT_SIGNALED); | 52 WaitableEvent::InitialState::NOT_SIGNALED); |
53 | 53 |
54 WaitableEventWatcher watcher; | 54 WaitableEventWatcher watcher; |
55 watcher.StartWatching(&event, Bind(&QuitWhenSignaled)); | 55 watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled)); |
56 | 56 |
57 event.Signal(); | 57 event.Signal(); |
58 | 58 |
59 RunLoop().Run(); | 59 RunLoop().Run(); |
60 } | 60 } |
61 | 61 |
62 void RunTest_BasicCancel(MessageLoop::Type message_loop_type) { | 62 void RunTest_BasicCancel(MessageLoop::Type message_loop_type) { |
63 MessageLoop message_loop(message_loop_type); | 63 MessageLoop message_loop(message_loop_type); |
64 | 64 |
65 // A manual-reset event that is not yet signaled. | 65 // A manual-reset event that is not yet signaled. |
66 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, | 66 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, |
67 WaitableEvent::InitialState::NOT_SIGNALED); | 67 WaitableEvent::InitialState::NOT_SIGNALED); |
68 | 68 |
69 WaitableEventWatcher watcher; | 69 WaitableEventWatcher watcher; |
70 | 70 |
71 watcher.StartWatching(&event, Bind(&QuitWhenSignaled)); | 71 watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled)); |
72 | 72 |
73 watcher.StopWatching(); | 73 watcher.StopWatching(); |
74 } | 74 } |
75 | 75 |
76 void RunTest_CancelAfterSet(MessageLoop::Type message_loop_type) { | 76 void RunTest_CancelAfterSet(MessageLoop::Type message_loop_type) { |
77 MessageLoop message_loop(message_loop_type); | 77 MessageLoop message_loop(message_loop_type); |
78 | 78 |
79 // A manual-reset event that is not yet signaled. | 79 // A manual-reset event that is not yet signaled. |
80 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, | 80 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, |
81 WaitableEvent::InitialState::NOT_SIGNALED); | 81 WaitableEvent::InitialState::NOT_SIGNALED); |
82 | 82 |
83 WaitableEventWatcher watcher; | 83 WaitableEventWatcher watcher; |
84 | 84 |
85 int counter = 1; | 85 int counter = 1; |
86 DecrementCountContainer delegate(&counter); | 86 DecrementCountContainer delegate(&counter); |
87 WaitableEventWatcher::EventCallback callback = | 87 WaitableEventWatcher::EventCallback callback = BindOnce( |
88 Bind(&DecrementCountContainer::OnWaitableEventSignaled, | 88 &DecrementCountContainer::OnWaitableEventSignaled, Unretained(&delegate)); |
89 Unretained(&delegate)); | 89 watcher.StartWatching(&event, std::move(callback)); |
90 watcher.StartWatching(&event, callback); | |
91 | 90 |
92 event.Signal(); | 91 event.Signal(); |
93 | 92 |
94 // Let the background thread do its business | 93 // Let the background thread do its business |
95 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30)); | 94 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30)); |
96 | 95 |
97 watcher.StopWatching(); | 96 watcher.StopWatching(); |
98 | 97 |
99 RunLoop().RunUntilIdle(); | 98 RunLoop().RunUntilIdle(); |
100 | 99 |
101 // Our delegate should not have fired. | 100 // Our delegate should not have fired. |
102 EXPECT_EQ(1, counter); | 101 EXPECT_EQ(1, counter); |
103 } | 102 } |
104 | 103 |
105 void RunTest_OutlivesMessageLoop(MessageLoop::Type message_loop_type) { | 104 void RunTest_OutlivesMessageLoop(MessageLoop::Type message_loop_type) { |
106 // Simulate a MessageLoop that dies before an WaitableEventWatcher. This | 105 // Simulate a MessageLoop that dies before an WaitableEventWatcher. This |
107 // ordinarily doesn't happen when people use the Thread class, but it can | 106 // ordinarily doesn't happen when people use the Thread class, but it can |
108 // happen when people use the Singleton pattern or atexit. | 107 // happen when people use the Singleton pattern or atexit. |
109 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, | 108 WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL, |
110 WaitableEvent::InitialState::NOT_SIGNALED); | 109 WaitableEvent::InitialState::NOT_SIGNALED); |
111 { | 110 { |
112 WaitableEventWatcher watcher; | 111 WaitableEventWatcher watcher; |
113 { | 112 { |
114 MessageLoop message_loop(message_loop_type); | 113 MessageLoop message_loop(message_loop_type); |
115 | 114 |
116 watcher.StartWatching(&event, Bind(&QuitWhenSignaled)); | 115 watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled)); |
117 } | 116 } |
118 } | 117 } |
119 } | 118 } |
120 | 119 |
121 void RunTest_DeleteUnder(MessageLoop::Type message_loop_type) { | 120 void RunTest_DeleteUnder(MessageLoop::Type message_loop_type) { |
122 // Delete the WaitableEvent out from under the Watcher. This is explictly | 121 // Delete the WaitableEvent out from under the Watcher. This is explictly |
123 // allowed by the interface. | 122 // allowed by the interface. |
124 | 123 |
125 MessageLoop message_loop(message_loop_type); | 124 MessageLoop message_loop(message_loop_type); |
126 | 125 |
127 { | 126 { |
128 WaitableEventWatcher watcher; | 127 WaitableEventWatcher watcher; |
129 | 128 |
130 WaitableEvent* event = | 129 WaitableEvent* event = |
131 new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC, | 130 new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC, |
132 WaitableEvent::InitialState::NOT_SIGNALED); | 131 WaitableEvent::InitialState::NOT_SIGNALED); |
133 | 132 |
134 watcher.StartWatching(event, Bind(&QuitWhenSignaled)); | 133 watcher.StartWatching(event, BindOnce(&QuitWhenSignaled)); |
135 delete event; | 134 delete event; |
136 } | 135 } |
137 } | 136 } |
138 | 137 |
139 } // namespace | 138 } // namespace |
140 | 139 |
141 //----------------------------------------------------------------------------- | 140 //----------------------------------------------------------------------------- |
142 | 141 |
143 TEST(WaitableEventWatcherTest, BasicSignal) { | 142 TEST(WaitableEventWatcherTest, BasicSignal) { |
144 for (int i = 0; i < kNumTestingMessageLoops; i++) { | 143 for (int i = 0; i < kNumTestingMessageLoops; i++) { |
(...skipping 19 matching lines...) Expand all Loading... |
164 } | 163 } |
165 } | 164 } |
166 | 165 |
167 TEST(WaitableEventWatcherTest, DeleteUnder) { | 166 TEST(WaitableEventWatcherTest, DeleteUnder) { |
168 for (int i = 0; i < kNumTestingMessageLoops; i++) { | 167 for (int i = 0; i < kNumTestingMessageLoops; i++) { |
169 RunTest_DeleteUnder(testing_message_loops[i]); | 168 RunTest_DeleteUnder(testing_message_loops[i]); |
170 } | 169 } |
171 } | 170 } |
172 | 171 |
173 } // namespace base | 172 } // namespace base |
OLD | NEW |