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

Side by Side Diff: mojo/edk/system/core_test_base.cc

Issue 1350023003: Add a Mojo EDK for Chrome that uses one OS pipe per message pipe. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: more cleanup Created 5 years, 2 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
OLDNEW
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698