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 "mojo/edk/system/core_test_base.h" | 5 #include "mojo/edk/system/core_test_base.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <vector> | 10 #include <vector> |
(...skipping 13 matching lines...) Expand all Loading... |
24 | 24 |
25 // MockDispatcher -------------------------------------------------------------- | 25 // MockDispatcher -------------------------------------------------------------- |
26 | 26 |
27 class MockDispatcher : public Dispatcher { | 27 class MockDispatcher : public Dispatcher { |
28 public: | 28 public: |
29 static scoped_refptr<MockDispatcher> Create( | 29 static scoped_refptr<MockDispatcher> Create( |
30 CoreTestBase::MockHandleInfo* info) { | 30 CoreTestBase::MockHandleInfo* info) { |
31 return make_scoped_refptr(new MockDispatcher(info)); | 31 return make_scoped_refptr(new MockDispatcher(info)); |
32 } | 32 } |
33 | 33 |
34 // |Dispatcher| private methods: | 34 // Dispatcher: |
35 Type GetType() const override { return Type::UNKNOWN; } | 35 Type GetType() const override { return Type::UNKNOWN; } |
36 | 36 |
37 private: | 37 MojoResult Close() override { |
38 explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) { | 38 info_->IncrementCloseCallCount(); |
39 CHECK(info_); | 39 return MOJO_RESULT_OK; |
40 info_->IncrementCtorCallCount(); | |
41 } | 40 } |
42 | 41 |
43 ~MockDispatcher() override { info_->IncrementDtorCallCount(); } | 42 MojoResult WriteMessage( |
44 | |
45 // |Dispatcher| protected methods: | |
46 void CloseImplNoLock() override { | |
47 info_->IncrementCloseCallCount(); | |
48 lock().AssertAcquired(); | |
49 } | |
50 | |
51 MojoResult WriteMessageImplNoLock( | |
52 const void* bytes, | 43 const void* bytes, |
53 uint32_t num_bytes, | 44 uint32_t num_bytes, |
54 std::vector<DispatcherTransport>* transports, | 45 const DispatcherInTransit* dispatchers, |
| 46 uint32_t num_dispatchers, |
55 MojoWriteMessageFlags /*flags*/) override { | 47 MojoWriteMessageFlags /*flags*/) override { |
56 info_->IncrementWriteMessageCallCount(); | 48 info_->IncrementWriteMessageCallCount(); |
57 lock().AssertAcquired(); | |
58 | 49 |
59 if (num_bytes > GetConfiguration().max_message_num_bytes) | 50 if (num_bytes > GetConfiguration().max_message_num_bytes) |
60 return MOJO_RESULT_RESOURCE_EXHAUSTED; | 51 return MOJO_RESULT_RESOURCE_EXHAUSTED; |
61 | 52 |
62 if (transports) | 53 if (dispatchers) |
63 return MOJO_RESULT_UNIMPLEMENTED; | 54 return MOJO_RESULT_UNIMPLEMENTED; |
64 | 55 |
65 return MOJO_RESULT_OK; | 56 return MOJO_RESULT_OK; |
66 } | 57 } |
67 | 58 |
68 MojoResult ReadMessageImplNoLock(void* bytes, | 59 MojoResult ReadMessage(void* bytes, |
69 uint32_t* num_bytes, | 60 uint32_t* num_bytes, |
70 DispatcherVector* dispatchers, | 61 MojoHandle* handle, |
71 uint32_t* num_dispatchers, | 62 uint32_t* num_handles, |
72 MojoReadMessageFlags /*flags*/) override { | 63 MojoReadMessageFlags /*flags*/) override { |
73 info_->IncrementReadMessageCallCount(); | 64 info_->IncrementReadMessageCallCount(); |
74 lock().AssertAcquired(); | |
75 | 65 |
76 if (num_dispatchers) { | 66 if (num_handles) |
77 *num_dispatchers = 1; | 67 *num_handles = 1; |
78 if (dispatchers) { | |
79 // Okay to leave an invalid dispatcher. | |
80 dispatchers->resize(1); | |
81 } | |
82 } | |
83 | 68 |
84 return MOJO_RESULT_OK; | 69 return MOJO_RESULT_OK; |
85 } | 70 } |
86 | 71 |
87 MojoResult WriteDataImplNoLock(const void* /*elements*/, | 72 MojoResult WriteData(const void* elements, |
88 uint32_t* /*num_bytes*/, | 73 uint32_t* num_bytes, |
89 MojoWriteDataFlags /*flags*/) override { | 74 MojoWriteDataFlags flags) override { |
90 info_->IncrementWriteDataCallCount(); | 75 info_->IncrementWriteDataCallCount(); |
91 lock().AssertAcquired(); | |
92 return MOJO_RESULT_UNIMPLEMENTED; | 76 return MOJO_RESULT_UNIMPLEMENTED; |
93 } | 77 } |
94 | 78 |
95 MojoResult BeginWriteDataImplNoLock( | 79 MojoResult BeginWriteData(void** buffer, |
96 void** /*buffer*/, | 80 uint32_t* buffer_num_bytes, |
97 uint32_t* /*buffer_num_bytes*/, | 81 MojoWriteDataFlags flags) override { |
98 MojoWriteDataFlags /*flags*/) override { | |
99 info_->IncrementBeginWriteDataCallCount(); | 82 info_->IncrementBeginWriteDataCallCount(); |
100 lock().AssertAcquired(); | |
101 return MOJO_RESULT_UNIMPLEMENTED; | 83 return MOJO_RESULT_UNIMPLEMENTED; |
102 } | 84 } |
103 | 85 |
104 MojoResult EndWriteDataImplNoLock(uint32_t /*num_bytes_written*/) override { | 86 MojoResult EndWriteData(uint32_t num_bytes_written) override { |
105 info_->IncrementEndWriteDataCallCount(); | 87 info_->IncrementEndWriteDataCallCount(); |
106 lock().AssertAcquired(); | |
107 return MOJO_RESULT_UNIMPLEMENTED; | 88 return MOJO_RESULT_UNIMPLEMENTED; |
108 } | 89 } |
109 | 90 |
110 MojoResult ReadDataImplNoLock(void* /*elements*/, | 91 MojoResult ReadData(void* elements, |
111 uint32_t* /*num_bytes*/, | 92 uint32_t* num_bytes, |
112 MojoReadDataFlags /*flags*/) override { | 93 MojoReadDataFlags flags) override { |
113 info_->IncrementReadDataCallCount(); | 94 info_->IncrementReadDataCallCount(); |
114 lock().AssertAcquired(); | |
115 return MOJO_RESULT_UNIMPLEMENTED; | 95 return MOJO_RESULT_UNIMPLEMENTED; |
116 } | 96 } |
117 | 97 |
118 MojoResult BeginReadDataImplNoLock(const void** /*buffer*/, | 98 MojoResult BeginReadData(const void** buffer, |
119 uint32_t* /*buffer_num_bytes*/, | 99 uint32_t* buffer_num_bytes, |
120 MojoReadDataFlags /*flags*/) override { | 100 MojoReadDataFlags flags) override { |
121 info_->IncrementBeginReadDataCallCount(); | 101 info_->IncrementBeginReadDataCallCount(); |
122 lock().AssertAcquired(); | |
123 return MOJO_RESULT_UNIMPLEMENTED; | 102 return MOJO_RESULT_UNIMPLEMENTED; |
124 } | 103 } |
125 | 104 |
126 MojoResult EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) override { | 105 MojoResult EndReadData(uint32_t num_bytes_read) override { |
127 info_->IncrementEndReadDataCallCount(); | 106 info_->IncrementEndReadDataCallCount(); |
128 lock().AssertAcquired(); | |
129 return MOJO_RESULT_UNIMPLEMENTED; | 107 return MOJO_RESULT_UNIMPLEMENTED; |
130 } | 108 } |
131 | 109 |
132 MojoResult AddAwakableImplNoLock(Awakable* awakable, | 110 MojoResult AddAwakable(Awakable* awakable, |
133 MojoHandleSignals /*signals*/, | 111 MojoHandleSignals /*signals*/, |
134 uintptr_t /*context*/, | 112 uintptr_t /*context*/, |
135 HandleSignalsState* signals_state) override { | 113 HandleSignalsState* signals_state) override { |
136 info_->IncrementAddAwakableCallCount(); | 114 info_->IncrementAddAwakableCallCount(); |
137 lock().AssertAcquired(); | |
138 if (signals_state) | 115 if (signals_state) |
139 *signals_state = HandleSignalsState(); | 116 *signals_state = HandleSignalsState(); |
140 if (info_->IsAddAwakableAllowed()) { | 117 if (info_->IsAddAwakableAllowed()) { |
141 info_->AwakableWasAdded(awakable); | 118 info_->AwakableWasAdded(awakable); |
142 return MOJO_RESULT_OK; | 119 return MOJO_RESULT_OK; |
143 } | 120 } |
144 | 121 |
145 return MOJO_RESULT_FAILED_PRECONDITION; | 122 return MOJO_RESULT_FAILED_PRECONDITION; |
146 } | 123 } |
147 | 124 |
148 void RemoveAwakableImplNoLock(Awakable* /*awakable*/, | 125 void RemoveAwakable(Awakable* /*awakable*/, |
149 HandleSignalsState* signals_state) override { | 126 HandleSignalsState* signals_state) override { |
150 info_->IncrementRemoveAwakableCallCount(); | 127 info_->IncrementRemoveAwakableCallCount(); |
151 lock().AssertAcquired(); | |
152 if (signals_state) | 128 if (signals_state) |
153 *signals_state = HandleSignalsState(); | 129 *signals_state = HandleSignalsState(); |
154 } | 130 } |
155 | 131 |
156 void CancelAllAwakablesNoLock() override { | 132 private: |
157 info_->IncrementCancelAllAwakablesCallCount(); | 133 explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) { |
158 lock().AssertAcquired(); | 134 CHECK(info_); |
| 135 info_->IncrementCtorCallCount(); |
159 } | 136 } |
160 | 137 |
161 scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() | 138 ~MockDispatcher() override { info_->IncrementDtorCallCount(); } |
162 override { | |
163 return Create(info_); | |
164 } | |
165 | 139 |
166 CoreTestBase::MockHandleInfo* const info_; | 140 CoreTestBase::MockHandleInfo* const info_; |
167 | 141 |
168 MOJO_DISALLOW_COPY_AND_ASSIGN(MockDispatcher); | 142 MOJO_DISALLOW_COPY_AND_ASSIGN(MockDispatcher); |
169 }; | 143 }; |
170 | 144 |
171 } // namespace | 145 } // namespace |
172 | 146 |
173 // CoreTestBase ---------------------------------------------------------------- | 147 // CoreTestBase ---------------------------------------------------------------- |
174 | 148 |
(...skipping 21 matching lines...) Expand all Loading... |
196 write_message_call_count_(0), | 170 write_message_call_count_(0), |
197 read_message_call_count_(0), | 171 read_message_call_count_(0), |
198 write_data_call_count_(0), | 172 write_data_call_count_(0), |
199 begin_write_data_call_count_(0), | 173 begin_write_data_call_count_(0), |
200 end_write_data_call_count_(0), | 174 end_write_data_call_count_(0), |
201 read_data_call_count_(0), | 175 read_data_call_count_(0), |
202 begin_read_data_call_count_(0), | 176 begin_read_data_call_count_(0), |
203 end_read_data_call_count_(0), | 177 end_read_data_call_count_(0), |
204 add_awakable_call_count_(0), | 178 add_awakable_call_count_(0), |
205 remove_awakable_call_count_(0), | 179 remove_awakable_call_count_(0), |
206 cancel_all_awakables_call_count_(0), | |
207 add_awakable_allowed_(false) { | 180 add_awakable_allowed_(false) { |
208 } | 181 } |
209 | 182 |
210 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() { | 183 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() { |
211 } | 184 } |
212 | 185 |
213 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const { | 186 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const { |
214 base::AutoLock locker(lock_); | 187 base::AutoLock locker(lock_); |
215 return ctor_call_count_; | 188 return ctor_call_count_; |
216 } | 189 } |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
268 unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const { | 241 unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const { |
269 base::AutoLock locker(lock_); | 242 base::AutoLock locker(lock_); |
270 return add_awakable_call_count_; | 243 return add_awakable_call_count_; |
271 } | 244 } |
272 | 245 |
273 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const { | 246 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const { |
274 base::AutoLock locker(lock_); | 247 base::AutoLock locker(lock_); |
275 return remove_awakable_call_count_; | 248 return remove_awakable_call_count_; |
276 } | 249 } |
277 | 250 |
278 unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const { | |
279 base::AutoLock locker(lock_); | |
280 return cancel_all_awakables_call_count_; | |
281 } | |
282 | |
283 size_t CoreTestBase_MockHandleInfo::GetAddedAwakableSize() const { | 251 size_t CoreTestBase_MockHandleInfo::GetAddedAwakableSize() const { |
284 base::AutoLock locker(lock_); | 252 base::AutoLock locker(lock_); |
285 return added_awakables_.size(); | 253 return added_awakables_.size(); |
286 } | 254 } |
287 | 255 |
288 Awakable* CoreTestBase_MockHandleInfo::GetAddedAwakableAt(unsigned i) const { | 256 Awakable* CoreTestBase_MockHandleInfo::GetAddedAwakableAt(unsigned i) const { |
289 base::AutoLock locker(lock_); | 257 base::AutoLock locker(lock_); |
290 return added_awakables_[i]; | 258 return added_awakables_[i]; |
291 } | 259 } |
292 | 260 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
348 void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() { | 316 void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() { |
349 base::AutoLock locker(lock_); | 317 base::AutoLock locker(lock_); |
350 add_awakable_call_count_++; | 318 add_awakable_call_count_++; |
351 } | 319 } |
352 | 320 |
353 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() { | 321 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() { |
354 base::AutoLock locker(lock_); | 322 base::AutoLock locker(lock_); |
355 remove_awakable_call_count_++; | 323 remove_awakable_call_count_++; |
356 } | 324 } |
357 | 325 |
358 void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() { | |
359 base::AutoLock locker(lock_); | |
360 cancel_all_awakables_call_count_++; | |
361 } | |
362 | |
363 void CoreTestBase_MockHandleInfo::AllowAddAwakable(bool alllow) { | 326 void CoreTestBase_MockHandleInfo::AllowAddAwakable(bool alllow) { |
364 base::AutoLock locker(lock_); | 327 base::AutoLock locker(lock_); |
365 add_awakable_allowed_ = alllow; | 328 add_awakable_allowed_ = alllow; |
366 } | 329 } |
367 | 330 |
368 bool CoreTestBase_MockHandleInfo::IsAddAwakableAllowed() const { | 331 bool CoreTestBase_MockHandleInfo::IsAddAwakableAllowed() const { |
369 base::AutoLock locker(lock_); | 332 base::AutoLock locker(lock_); |
370 return add_awakable_allowed_; | 333 return add_awakable_allowed_; |
371 } | 334 } |
372 | 335 |
373 void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) { | 336 void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) { |
374 base::AutoLock locker(lock_); | 337 base::AutoLock locker(lock_); |
375 added_awakables_.push_back(awakable); | 338 added_awakables_.push_back(awakable); |
376 } | 339 } |
377 | 340 |
378 } // namespace test | 341 } // namespace test |
379 } // namespace edk | 342 } // namespace edk |
380 } // namespace mojo | 343 } // namespace mojo |
OLD | NEW |