OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 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 "third_party/mojo/src/mojo/edk/system/core_test_base.h" | 5 #include "mojo/edk/system/core_test_base.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/memory/ref_counted.h" | 10 #include "base/memory/ref_counted.h" |
| 11 #include "mojo/edk/system/configuration.h" |
| 12 #include "mojo/edk/system/core.h" |
| 13 #include "mojo/edk/system/dispatcher.h" |
11 #include "mojo/public/cpp/system/macros.h" | 14 #include "mojo/public/cpp/system/macros.h" |
12 #include "third_party/mojo/src/mojo/edk/system/configuration.h" | |
13 #include "third_party/mojo/src/mojo/edk/system/core.h" | |
14 #include "third_party/mojo/src/mojo/edk/system/dispatcher.h" | |
15 #include "third_party/mojo/src/mojo/edk/system/memory.h" | |
16 | 15 |
17 namespace mojo { | 16 namespace mojo { |
18 namespace system { | 17 namespace edk { |
19 namespace test { | 18 namespace test { |
20 | 19 |
21 namespace { | 20 namespace { |
22 | 21 |
23 // MockDispatcher -------------------------------------------------------------- | 22 // MockDispatcher -------------------------------------------------------------- |
24 | 23 |
25 class MockDispatcher : public Dispatcher { | 24 class MockDispatcher : public Dispatcher { |
26 public: | 25 public: |
27 static scoped_refptr<MockDispatcher> Create( | 26 static scoped_refptr<MockDispatcher> Create( |
28 CoreTestBase::MockHandleInfo* info) { | 27 CoreTestBase::MockHandleInfo* info) { |
29 return make_scoped_refptr(new MockDispatcher(info)); | 28 return make_scoped_refptr(new MockDispatcher(info)); |
30 } | 29 } |
31 | 30 |
32 // |Dispatcher| private methods: | 31 // |Dispatcher| private methods: |
33 Type GetType() const override { return Type::UNKNOWN; } | 32 Type GetType() const override { return Type::UNKNOWN; } |
34 | 33 |
35 private: | 34 private: |
36 explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) { | 35 explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) { |
37 CHECK(info_); | 36 CHECK(info_); |
38 info_->IncrementCtorCallCount(); | 37 info_->IncrementCtorCallCount(); |
39 } | 38 } |
40 | 39 |
41 ~MockDispatcher() override { info_->IncrementDtorCallCount(); } | 40 ~MockDispatcher() override { info_->IncrementDtorCallCount(); } |
42 | 41 |
43 // |Dispatcher| protected methods: | 42 // |Dispatcher| protected methods: |
44 void CloseImplNoLock() override { | 43 void CloseImplNoLock() override { |
45 info_->IncrementCloseCallCount(); | 44 info_->IncrementCloseCallCount(); |
46 mutex().AssertHeld(); | 45 lock().AssertAcquired(); |
47 } | 46 } |
48 | 47 |
49 MojoResult WriteMessageImplNoLock( | 48 MojoResult WriteMessageImplNoLock( |
50 UserPointer<const void> bytes, | 49 const void* bytes, |
51 uint32_t num_bytes, | 50 uint32_t num_bytes, |
52 std::vector<DispatcherTransport>* transports, | 51 std::vector<DispatcherTransport>* transports, |
53 MojoWriteMessageFlags /*flags*/) override { | 52 MojoWriteMessageFlags /*flags*/) override { |
54 info_->IncrementWriteMessageCallCount(); | 53 info_->IncrementWriteMessageCallCount(); |
55 mutex().AssertHeld(); | 54 lock().AssertAcquired(); |
56 | 55 |
57 if (num_bytes > GetConfiguration().max_message_num_bytes) | 56 if (num_bytes > GetConfiguration().max_message_num_bytes) |
58 return MOJO_RESULT_RESOURCE_EXHAUSTED; | 57 return MOJO_RESULT_RESOURCE_EXHAUSTED; |
59 | 58 |
60 if (transports) | 59 if (transports) |
61 return MOJO_RESULT_UNIMPLEMENTED; | 60 return MOJO_RESULT_UNIMPLEMENTED; |
62 | 61 |
63 return MOJO_RESULT_OK; | 62 return MOJO_RESULT_OK; |
64 } | 63 } |
65 | 64 |
66 MojoResult ReadMessageImplNoLock(UserPointer<void> bytes, | 65 MojoResult ReadMessageImplNoLock(void* bytes, |
67 UserPointer<uint32_t> num_bytes, | 66 uint32_t* num_bytes, |
68 DispatcherVector* dispatchers, | 67 DispatcherVector* dispatchers, |
69 uint32_t* num_dispatchers, | 68 uint32_t* num_dispatchers, |
70 MojoReadMessageFlags /*flags*/) override { | 69 MojoReadMessageFlags /*flags*/) override { |
71 info_->IncrementReadMessageCallCount(); | 70 info_->IncrementReadMessageCallCount(); |
72 mutex().AssertHeld(); | 71 lock().AssertAcquired(); |
73 | 72 |
74 if (num_dispatchers) { | 73 if (num_dispatchers) { |
75 *num_dispatchers = 1; | 74 *num_dispatchers = 1; |
76 if (dispatchers) { | 75 if (dispatchers) { |
77 // Okay to leave an invalid dispatcher. | 76 // Okay to leave an invalid dispatcher. |
78 dispatchers->resize(1); | 77 dispatchers->resize(1); |
79 } | 78 } |
80 } | 79 } |
81 | 80 |
82 return MOJO_RESULT_OK; | 81 return MOJO_RESULT_OK; |
83 } | 82 } |
84 | 83 |
85 MojoResult WriteDataImplNoLock(UserPointer<const void> /*elements*/, | 84 MojoResult WriteDataImplNoLock(const void* /*elements*/, |
86 UserPointer<uint32_t> /*num_bytes*/, | 85 uint32_t* /*num_bytes*/, |
87 MojoWriteDataFlags /*flags*/) override { | 86 MojoWriteDataFlags /*flags*/) override { |
88 info_->IncrementWriteDataCallCount(); | 87 info_->IncrementWriteDataCallCount(); |
89 mutex().AssertHeld(); | 88 lock().AssertAcquired(); |
90 return MOJO_RESULT_UNIMPLEMENTED; | 89 return MOJO_RESULT_UNIMPLEMENTED; |
91 } | 90 } |
92 | 91 |
93 MojoResult BeginWriteDataImplNoLock( | 92 MojoResult BeginWriteDataImplNoLock( |
94 UserPointer<void*> /*buffer*/, | 93 void** /*buffer*/, |
95 UserPointer<uint32_t> /*buffer_num_bytes*/, | 94 uint32_t* /*buffer_num_bytes*/, |
96 MojoWriteDataFlags /*flags*/) override { | 95 MojoWriteDataFlags /*flags*/) override { |
97 info_->IncrementBeginWriteDataCallCount(); | 96 info_->IncrementBeginWriteDataCallCount(); |
98 mutex().AssertHeld(); | 97 lock().AssertAcquired(); |
99 return MOJO_RESULT_UNIMPLEMENTED; | 98 return MOJO_RESULT_UNIMPLEMENTED; |
100 } | 99 } |
101 | 100 |
102 MojoResult EndWriteDataImplNoLock(uint32_t /*num_bytes_written*/) override { | 101 MojoResult EndWriteDataImplNoLock(uint32_t /*num_bytes_written*/) override { |
103 info_->IncrementEndWriteDataCallCount(); | 102 info_->IncrementEndWriteDataCallCount(); |
104 mutex().AssertHeld(); | 103 lock().AssertAcquired(); |
105 return MOJO_RESULT_UNIMPLEMENTED; | 104 return MOJO_RESULT_UNIMPLEMENTED; |
106 } | 105 } |
107 | 106 |
108 MojoResult ReadDataImplNoLock(UserPointer<void> /*elements*/, | 107 MojoResult ReadDataImplNoLock(void* /*elements*/, |
109 UserPointer<uint32_t> /*num_bytes*/, | 108 uint32_t* /*num_bytes*/, |
110 MojoReadDataFlags /*flags*/) override { | 109 MojoReadDataFlags /*flags*/) override { |
111 info_->IncrementReadDataCallCount(); | 110 info_->IncrementReadDataCallCount(); |
112 mutex().AssertHeld(); | 111 lock().AssertAcquired(); |
113 return MOJO_RESULT_UNIMPLEMENTED; | 112 return MOJO_RESULT_UNIMPLEMENTED; |
114 } | 113 } |
115 | 114 |
116 MojoResult BeginReadDataImplNoLock(UserPointer<const void*> /*buffer*/, | 115 MojoResult BeginReadDataImplNoLock(const void** /*buffer*/, |
117 UserPointer<uint32_t> /*buffer_num_bytes*/, | 116 uint32_t* /*buffer_num_bytes*/, |
118 MojoReadDataFlags /*flags*/) override { | 117 MojoReadDataFlags /*flags*/) override { |
119 info_->IncrementBeginReadDataCallCount(); | 118 info_->IncrementBeginReadDataCallCount(); |
120 mutex().AssertHeld(); | 119 lock().AssertAcquired(); |
121 return MOJO_RESULT_UNIMPLEMENTED; | 120 return MOJO_RESULT_UNIMPLEMENTED; |
122 } | 121 } |
123 | 122 |
124 MojoResult EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) override { | 123 MojoResult EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) override { |
125 info_->IncrementEndReadDataCallCount(); | 124 info_->IncrementEndReadDataCallCount(); |
126 mutex().AssertHeld(); | 125 lock().AssertAcquired(); |
127 return MOJO_RESULT_UNIMPLEMENTED; | 126 return MOJO_RESULT_UNIMPLEMENTED; |
128 } | 127 } |
129 | 128 |
130 MojoResult AddAwakableImplNoLock(Awakable* awakable, | 129 MojoResult AddAwakableImplNoLock(Awakable* awakable, |
131 MojoHandleSignals /*signals*/, | 130 MojoHandleSignals /*signals*/, |
132 uint32_t /*context*/, | 131 uint32_t /*context*/, |
133 HandleSignalsState* signals_state) override { | 132 HandleSignalsState* signals_state) override { |
134 info_->IncrementAddAwakableCallCount(); | 133 info_->IncrementAddAwakableCallCount(); |
135 mutex().AssertHeld(); | 134 lock().AssertAcquired(); |
136 if (signals_state) | 135 if (signals_state) |
137 *signals_state = HandleSignalsState(); | 136 *signals_state = HandleSignalsState(); |
138 if (info_->IsAddAwakableAllowed()) { | 137 if (info_->IsAddAwakableAllowed()) { |
139 info_->AwakableWasAdded(awakable); | 138 info_->AwakableWasAdded(awakable); |
140 return MOJO_RESULT_OK; | 139 return MOJO_RESULT_OK; |
141 } | 140 } |
142 | 141 |
143 return MOJO_RESULT_FAILED_PRECONDITION; | 142 return MOJO_RESULT_FAILED_PRECONDITION; |
144 } | 143 } |
145 | 144 |
146 void RemoveAwakableImplNoLock(Awakable* /*awakable*/, | 145 void RemoveAwakableImplNoLock(Awakable* /*awakable*/, |
147 HandleSignalsState* signals_state) override { | 146 HandleSignalsState* signals_state) override { |
148 info_->IncrementRemoveAwakableCallCount(); | 147 info_->IncrementRemoveAwakableCallCount(); |
149 mutex().AssertHeld(); | 148 lock().AssertAcquired(); |
150 if (signals_state) | 149 if (signals_state) |
151 *signals_state = HandleSignalsState(); | 150 *signals_state = HandleSignalsState(); |
152 } | 151 } |
153 | 152 |
154 void CancelAllAwakablesNoLock() override { | 153 void CancelAllAwakablesNoLock() override { |
155 info_->IncrementCancelAllAwakablesCallCount(); | 154 info_->IncrementCancelAllAwakablesCallCount(); |
156 mutex().AssertHeld(); | 155 lock().AssertAcquired(); |
157 } | 156 } |
158 | 157 |
159 scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() | 158 scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() |
160 override { | 159 override { |
161 return Create(info_); | 160 return Create(info_); |
162 } | 161 } |
163 | 162 |
164 CoreTestBase::MockHandleInfo* const info_; | 163 CoreTestBase::MockHandleInfo* const info_; |
165 | 164 |
166 MOJO_DISALLOW_COPY_AND_ASSIGN(MockDispatcher); | 165 MOJO_DISALLOW_COPY_AND_ASSIGN(MockDispatcher); |
167 }; | 166 }; |
168 | 167 |
169 } // namespace | 168 } // namespace |
170 | 169 |
171 // CoreTestBase ---------------------------------------------------------------- | 170 // CoreTestBase ---------------------------------------------------------------- |
172 | 171 |
173 CoreTestBase::CoreTestBase() { | 172 CoreTestBase::CoreTestBase() { |
174 } | 173 } |
175 | 174 |
176 CoreTestBase::~CoreTestBase() { | 175 CoreTestBase::~CoreTestBase() { |
177 } | 176 } |
178 | 177 |
179 void CoreTestBase::SetUp() { | |
180 core_ = new Core(&platform_support_); | |
181 } | |
182 | |
183 void CoreTestBase::TearDown() { | |
184 delete core_; | |
185 core_ = nullptr; | |
186 } | |
187 | |
188 MojoHandle CoreTestBase::CreateMockHandle(CoreTestBase::MockHandleInfo* info) { | 178 MojoHandle CoreTestBase::CreateMockHandle(CoreTestBase::MockHandleInfo* info) { |
189 CHECK(core_); | |
190 scoped_refptr<MockDispatcher> dispatcher = MockDispatcher::Create(info); | 179 scoped_refptr<MockDispatcher> dispatcher = MockDispatcher::Create(info); |
191 return core_->AddDispatcher(dispatcher); | 180 return core()->AddDispatcher(dispatcher); |
192 } | 181 } |
193 | 182 |
194 // CoreTestBase_MockHandleInfo ------------------------------------------------- | 183 // CoreTestBase_MockHandleInfo ------------------------------------------------- |
195 | 184 |
196 CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo() | 185 CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo() |
197 : ctor_call_count_(0), | 186 : ctor_call_count_(0), |
198 dtor_call_count_(0), | 187 dtor_call_count_(0), |
199 close_call_count_(0), | 188 close_call_count_(0), |
200 write_message_call_count_(0), | 189 write_message_call_count_(0), |
201 read_message_call_count_(0), | 190 read_message_call_count_(0), |
202 write_data_call_count_(0), | 191 write_data_call_count_(0), |
203 begin_write_data_call_count_(0), | 192 begin_write_data_call_count_(0), |
204 end_write_data_call_count_(0), | 193 end_write_data_call_count_(0), |
205 read_data_call_count_(0), | 194 read_data_call_count_(0), |
206 begin_read_data_call_count_(0), | 195 begin_read_data_call_count_(0), |
207 end_read_data_call_count_(0), | 196 end_read_data_call_count_(0), |
208 add_awakable_call_count_(0), | 197 add_awakable_call_count_(0), |
209 remove_awakable_call_count_(0), | 198 remove_awakable_call_count_(0), |
210 cancel_all_awakables_call_count_(0), | 199 cancel_all_awakables_call_count_(0), |
211 add_awakable_allowed_(false) { | 200 add_awakable_allowed_(false) { |
212 } | 201 } |
213 | 202 |
214 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() { | 203 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() { |
215 } | 204 } |
216 | 205 |
217 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const { | 206 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const { |
218 MutexLocker locker(&mutex_); | 207 base::AutoLock locker(lock_); |
219 return ctor_call_count_; | 208 return ctor_call_count_; |
220 } | 209 } |
221 | 210 |
222 unsigned CoreTestBase_MockHandleInfo::GetDtorCallCount() const { | 211 unsigned CoreTestBase_MockHandleInfo::GetDtorCallCount() const { |
223 MutexLocker locker(&mutex_); | 212 base::AutoLock locker(lock_); |
224 return dtor_call_count_; | 213 return dtor_call_count_; |
225 } | 214 } |
226 | 215 |
227 unsigned CoreTestBase_MockHandleInfo::GetCloseCallCount() const { | 216 unsigned CoreTestBase_MockHandleInfo::GetCloseCallCount() const { |
228 MutexLocker locker(&mutex_); | 217 base::AutoLock locker(lock_); |
229 return close_call_count_; | 218 return close_call_count_; |
230 } | 219 } |
231 | 220 |
232 unsigned CoreTestBase_MockHandleInfo::GetWriteMessageCallCount() const { | 221 unsigned CoreTestBase_MockHandleInfo::GetWriteMessageCallCount() const { |
233 MutexLocker locker(&mutex_); | 222 base::AutoLock locker(lock_); |
234 return write_message_call_count_; | 223 return write_message_call_count_; |
235 } | 224 } |
236 | 225 |
237 unsigned CoreTestBase_MockHandleInfo::GetReadMessageCallCount() const { | 226 unsigned CoreTestBase_MockHandleInfo::GetReadMessageCallCount() const { |
238 MutexLocker locker(&mutex_); | 227 base::AutoLock locker(lock_); |
239 return read_message_call_count_; | 228 return read_message_call_count_; |
240 } | 229 } |
241 | 230 |
242 unsigned CoreTestBase_MockHandleInfo::GetWriteDataCallCount() const { | 231 unsigned CoreTestBase_MockHandleInfo::GetWriteDataCallCount() const { |
243 MutexLocker locker(&mutex_); | 232 base::AutoLock locker(lock_); |
244 return write_data_call_count_; | 233 return write_data_call_count_; |
245 } | 234 } |
246 | 235 |
247 unsigned CoreTestBase_MockHandleInfo::GetBeginWriteDataCallCount() const { | 236 unsigned CoreTestBase_MockHandleInfo::GetBeginWriteDataCallCount() const { |
248 MutexLocker locker(&mutex_); | 237 base::AutoLock locker(lock_); |
249 return begin_write_data_call_count_; | 238 return begin_write_data_call_count_; |
250 } | 239 } |
251 | 240 |
252 unsigned CoreTestBase_MockHandleInfo::GetEndWriteDataCallCount() const { | 241 unsigned CoreTestBase_MockHandleInfo::GetEndWriteDataCallCount() const { |
253 MutexLocker locker(&mutex_); | 242 base::AutoLock locker(lock_); |
254 return end_write_data_call_count_; | 243 return end_write_data_call_count_; |
255 } | 244 } |
256 | 245 |
257 unsigned CoreTestBase_MockHandleInfo::GetReadDataCallCount() const { | 246 unsigned CoreTestBase_MockHandleInfo::GetReadDataCallCount() const { |
258 MutexLocker locker(&mutex_); | 247 base::AutoLock locker(lock_); |
259 return read_data_call_count_; | 248 return read_data_call_count_; |
260 } | 249 } |
261 | 250 |
262 unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const { | 251 unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const { |
263 MutexLocker locker(&mutex_); | 252 base::AutoLock locker(lock_); |
264 return begin_read_data_call_count_; | 253 return begin_read_data_call_count_; |
265 } | 254 } |
266 | 255 |
267 unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const { | 256 unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const { |
268 MutexLocker locker(&mutex_); | 257 base::AutoLock locker(lock_); |
269 return end_read_data_call_count_; | 258 return end_read_data_call_count_; |
270 } | 259 } |
271 | 260 |
272 unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const { | 261 unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const { |
273 MutexLocker locker(&mutex_); | 262 base::AutoLock locker(lock_); |
274 return add_awakable_call_count_; | 263 return add_awakable_call_count_; |
275 } | 264 } |
276 | 265 |
277 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const { | 266 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const { |
278 MutexLocker locker(&mutex_); | 267 base::AutoLock locker(lock_); |
279 return remove_awakable_call_count_; | 268 return remove_awakable_call_count_; |
280 } | 269 } |
281 | 270 |
282 unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const { | 271 unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const { |
283 MutexLocker locker(&mutex_); | 272 base::AutoLock locker(lock_); |
284 return cancel_all_awakables_call_count_; | 273 return cancel_all_awakables_call_count_; |
285 } | 274 } |
286 | 275 |
287 size_t CoreTestBase_MockHandleInfo::GetAddedAwakableSize() const { | 276 size_t CoreTestBase_MockHandleInfo::GetAddedAwakableSize() const { |
288 MutexLocker locker(&mutex_); | 277 base::AutoLock locker(lock_); |
289 return added_awakables_.size(); | 278 return added_awakables_.size(); |
290 } | 279 } |
291 | 280 |
292 Awakable* CoreTestBase_MockHandleInfo::GetAddedAwakableAt(unsigned i) const { | 281 Awakable* CoreTestBase_MockHandleInfo::GetAddedAwakableAt(unsigned i) const { |
293 MutexLocker locker(&mutex_); | 282 base::AutoLock locker(lock_); |
294 return added_awakables_[i]; | 283 return added_awakables_[i]; |
295 } | 284 } |
296 | 285 |
297 void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() { | 286 void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() { |
298 MutexLocker locker(&mutex_); | 287 base::AutoLock locker(lock_); |
299 ctor_call_count_++; | 288 ctor_call_count_++; |
300 } | 289 } |
301 | 290 |
302 void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() { | 291 void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() { |
303 MutexLocker locker(&mutex_); | 292 base::AutoLock locker(lock_); |
304 dtor_call_count_++; | 293 dtor_call_count_++; |
305 } | 294 } |
306 | 295 |
307 void CoreTestBase_MockHandleInfo::IncrementCloseCallCount() { | 296 void CoreTestBase_MockHandleInfo::IncrementCloseCallCount() { |
308 MutexLocker locker(&mutex_); | 297 base::AutoLock locker(lock_); |
309 close_call_count_++; | 298 close_call_count_++; |
310 } | 299 } |
311 | 300 |
312 void CoreTestBase_MockHandleInfo::IncrementWriteMessageCallCount() { | 301 void CoreTestBase_MockHandleInfo::IncrementWriteMessageCallCount() { |
313 MutexLocker locker(&mutex_); | 302 base::AutoLock locker(lock_); |
314 write_message_call_count_++; | 303 write_message_call_count_++; |
315 } | 304 } |
316 | 305 |
317 void CoreTestBase_MockHandleInfo::IncrementReadMessageCallCount() { | 306 void CoreTestBase_MockHandleInfo::IncrementReadMessageCallCount() { |
318 MutexLocker locker(&mutex_); | 307 base::AutoLock locker(lock_); |
319 read_message_call_count_++; | 308 read_message_call_count_++; |
320 } | 309 } |
321 | 310 |
322 void CoreTestBase_MockHandleInfo::IncrementWriteDataCallCount() { | 311 void CoreTestBase_MockHandleInfo::IncrementWriteDataCallCount() { |
323 MutexLocker locker(&mutex_); | 312 base::AutoLock locker(lock_); |
324 write_data_call_count_++; | 313 write_data_call_count_++; |
325 } | 314 } |
326 | 315 |
327 void CoreTestBase_MockHandleInfo::IncrementBeginWriteDataCallCount() { | 316 void CoreTestBase_MockHandleInfo::IncrementBeginWriteDataCallCount() { |
328 MutexLocker locker(&mutex_); | 317 base::AutoLock locker(lock_); |
329 begin_write_data_call_count_++; | 318 begin_write_data_call_count_++; |
330 } | 319 } |
331 | 320 |
332 void CoreTestBase_MockHandleInfo::IncrementEndWriteDataCallCount() { | 321 void CoreTestBase_MockHandleInfo::IncrementEndWriteDataCallCount() { |
333 MutexLocker locker(&mutex_); | 322 base::AutoLock locker(lock_); |
334 end_write_data_call_count_++; | 323 end_write_data_call_count_++; |
335 } | 324 } |
336 | 325 |
337 void CoreTestBase_MockHandleInfo::IncrementReadDataCallCount() { | 326 void CoreTestBase_MockHandleInfo::IncrementReadDataCallCount() { |
338 MutexLocker locker(&mutex_); | 327 base::AutoLock locker(lock_); |
339 read_data_call_count_++; | 328 read_data_call_count_++; |
340 } | 329 } |
341 | 330 |
342 void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() { | 331 void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() { |
343 MutexLocker locker(&mutex_); | 332 base::AutoLock locker(lock_); |
344 begin_read_data_call_count_++; | 333 begin_read_data_call_count_++; |
345 } | 334 } |
346 | 335 |
347 void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() { | 336 void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() { |
348 MutexLocker locker(&mutex_); | 337 base::AutoLock locker(lock_); |
349 end_read_data_call_count_++; | 338 end_read_data_call_count_++; |
350 } | 339 } |
351 | 340 |
352 void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() { | 341 void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() { |
353 MutexLocker locker(&mutex_); | 342 base::AutoLock locker(lock_); |
354 add_awakable_call_count_++; | 343 add_awakable_call_count_++; |
355 } | 344 } |
356 | 345 |
357 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() { | 346 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() { |
358 MutexLocker locker(&mutex_); | 347 base::AutoLock locker(lock_); |
359 remove_awakable_call_count_++; | 348 remove_awakable_call_count_++; |
360 } | 349 } |
361 | 350 |
362 void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() { | 351 void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() { |
363 MutexLocker locker(&mutex_); | 352 base::AutoLock locker(lock_); |
364 cancel_all_awakables_call_count_++; | 353 cancel_all_awakables_call_count_++; |
365 } | 354 } |
366 | 355 |
367 void CoreTestBase_MockHandleInfo::AllowAddAwakable(bool alllow) { | 356 void CoreTestBase_MockHandleInfo::AllowAddAwakable(bool alllow) { |
368 MutexLocker locker(&mutex_); | 357 base::AutoLock locker(lock_); |
369 add_awakable_allowed_ = alllow; | 358 add_awakable_allowed_ = alllow; |
370 } | 359 } |
371 | 360 |
372 bool CoreTestBase_MockHandleInfo::IsAddAwakableAllowed() const { | 361 bool CoreTestBase_MockHandleInfo::IsAddAwakableAllowed() const { |
373 MutexLocker locker(&mutex_); | 362 base::AutoLock locker(lock_); |
374 return add_awakable_allowed_; | 363 return add_awakable_allowed_; |
375 } | 364 } |
376 | 365 |
377 void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) { | 366 void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) { |
378 MutexLocker locker(&mutex_); | 367 base::AutoLock locker(lock_); |
379 added_awakables_.push_back(awakable); | 368 added_awakables_.push_back(awakable); |
380 } | 369 } |
381 | 370 |
382 } // namespace test | 371 } // namespace test |
383 } // namespace system | 372 } // namespace edk |
384 } // namespace mojo | 373 } // namespace mojo |
OLD | NEW |