OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/browser/device_sensors/data_fetcher_shared_memory_base.h" | |
6 | |
7 #include "base/logging.h" | |
8 #include "base/macros.h" | |
9 #include "base/process/process_handle.h" | |
10 #include "base/single_thread_task_runner.h" | |
11 #include "base/synchronization/waitable_event.h" | |
12 #include "base/threading/thread.h" | |
13 #include "device/sensors/public/cpp/device_light_hardware_buffer.h" | |
14 #include "device/sensors/public/cpp/device_motion_hardware_buffer.h" | |
15 #include "device/sensors/public/cpp/device_orientation_hardware_buffer.h" | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 | |
18 namespace content { | |
19 | |
20 namespace { | |
21 | |
22 class FakeDataFetcher : public DataFetcherSharedMemoryBase { | |
23 public: | |
24 FakeDataFetcher() | |
25 : start_light_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
26 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
27 start_motion_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
28 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
29 start_orientation_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
30 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
31 start_orientation_absolute_( | |
32 base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
33 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
34 stop_light_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
35 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
36 stop_motion_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
37 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
38 stop_orientation_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
39 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
40 stop_orientation_absolute_( | |
41 base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
42 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
43 updated_light_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
44 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
45 updated_motion_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
46 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
47 updated_orientation_(base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
48 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
49 updated_orientation_absolute_( | |
50 base::WaitableEvent::ResetPolicy::AUTOMATIC, | |
51 base::WaitableEvent::InitialState::NOT_SIGNALED), | |
52 light_buffer_(nullptr), | |
53 motion_buffer_(nullptr), | |
54 orientation_buffer_(nullptr), | |
55 orientation_absolute_buffer_(nullptr) {} | |
56 ~FakeDataFetcher() override {} | |
57 | |
58 bool Init(ConsumerType consumer_type, void* buffer) { | |
59 EXPECT_TRUE(buffer); | |
60 | |
61 switch (consumer_type) { | |
62 case CONSUMER_TYPE_MOTION: | |
63 motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer); | |
64 break; | |
65 case CONSUMER_TYPE_ORIENTATION: | |
66 orientation_buffer_ = | |
67 static_cast<DeviceOrientationHardwareBuffer*>(buffer); | |
68 break; | |
69 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
70 orientation_absolute_buffer_ = | |
71 static_cast<DeviceOrientationHardwareBuffer*>(buffer); | |
72 break; | |
73 case CONSUMER_TYPE_LIGHT: | |
74 light_buffer_ = static_cast<DeviceLightHardwareBuffer*>(buffer); | |
75 break; | |
76 default: | |
77 return false; | |
78 } | |
79 return true; | |
80 } | |
81 | |
82 void UpdateLight() { | |
83 DeviceLightHardwareBuffer* buffer = GetLightBuffer(); | |
84 ASSERT_TRUE(buffer); | |
85 buffer->seqlock.WriteBegin(); | |
86 buffer->data.value = 100; | |
87 buffer->seqlock.WriteEnd(); | |
88 updated_light_.Signal(); | |
89 } | |
90 | |
91 void UpdateMotion() { | |
92 DeviceMotionHardwareBuffer* buffer = GetMotionBuffer(); | |
93 ASSERT_TRUE(buffer); | |
94 buffer->seqlock.WriteBegin(); | |
95 buffer->data.interval = kDeviceSensorIntervalMicroseconds / 1000.; | |
96 buffer->seqlock.WriteEnd(); | |
97 updated_motion_.Signal(); | |
98 } | |
99 | |
100 void UpdateOrientation() { | |
101 DeviceOrientationHardwareBuffer* buffer = GetOrientationBuffer(); | |
102 ASSERT_TRUE(buffer); | |
103 buffer->seqlock.WriteBegin(); | |
104 buffer->data.alpha = 1; | |
105 buffer->seqlock.WriteEnd(); | |
106 updated_orientation_.Signal(); | |
107 } | |
108 | |
109 void UpdateOrientationAbsolute() { | |
110 DeviceOrientationHardwareBuffer* buffer = GetOrientationAbsoluteBuffer(); | |
111 ASSERT_TRUE(buffer); | |
112 buffer->seqlock.WriteBegin(); | |
113 buffer->data.alpha = 1; | |
114 buffer->data.absolute = true; | |
115 buffer->seqlock.WriteEnd(); | |
116 updated_orientation_absolute_.Signal(); | |
117 } | |
118 | |
119 DeviceLightHardwareBuffer* GetLightBuffer() const { return light_buffer_; } | |
120 | |
121 DeviceMotionHardwareBuffer* GetMotionBuffer() const { | |
122 return motion_buffer_; | |
123 } | |
124 | |
125 DeviceOrientationHardwareBuffer* GetOrientationBuffer() const { | |
126 return orientation_buffer_; | |
127 } | |
128 | |
129 DeviceOrientationHardwareBuffer* GetOrientationAbsoluteBuffer() const { | |
130 return orientation_absolute_buffer_; | |
131 } | |
132 | |
133 void WaitForStart(ConsumerType consumer_type) { | |
134 switch (consumer_type) { | |
135 case CONSUMER_TYPE_MOTION: | |
136 start_motion_.Wait(); | |
137 break; | |
138 case CONSUMER_TYPE_ORIENTATION: | |
139 start_orientation_.Wait(); | |
140 break; | |
141 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
142 start_orientation_absolute_.Wait(); | |
143 break; | |
144 case CONSUMER_TYPE_LIGHT: | |
145 start_light_.Wait(); | |
146 break; | |
147 } | |
148 } | |
149 | |
150 void WaitForStop(ConsumerType consumer_type) { | |
151 switch (consumer_type) { | |
152 case CONSUMER_TYPE_MOTION: | |
153 stop_motion_.Wait(); | |
154 break; | |
155 case CONSUMER_TYPE_ORIENTATION: | |
156 stop_orientation_.Wait(); | |
157 break; | |
158 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
159 stop_orientation_absolute_.Wait(); | |
160 break; | |
161 case CONSUMER_TYPE_LIGHT: | |
162 stop_light_.Wait(); | |
163 break; | |
164 } | |
165 } | |
166 | |
167 void WaitForUpdate(ConsumerType consumer_type) { | |
168 switch (consumer_type) { | |
169 case CONSUMER_TYPE_MOTION: | |
170 updated_motion_.Wait(); | |
171 break; | |
172 case CONSUMER_TYPE_ORIENTATION: | |
173 updated_orientation_.Wait(); | |
174 break; | |
175 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
176 updated_orientation_absolute_.Wait(); | |
177 break; | |
178 case CONSUMER_TYPE_LIGHT: | |
179 updated_light_.Wait(); | |
180 break; | |
181 } | |
182 } | |
183 | |
184 protected: | |
185 base::WaitableEvent start_light_; | |
186 base::WaitableEvent start_motion_; | |
187 base::WaitableEvent start_orientation_; | |
188 base::WaitableEvent start_orientation_absolute_; | |
189 base::WaitableEvent stop_light_; | |
190 base::WaitableEvent stop_motion_; | |
191 base::WaitableEvent stop_orientation_; | |
192 base::WaitableEvent stop_orientation_absolute_; | |
193 base::WaitableEvent updated_light_; | |
194 base::WaitableEvent updated_motion_; | |
195 base::WaitableEvent updated_orientation_; | |
196 base::WaitableEvent updated_orientation_absolute_; | |
197 | |
198 private: | |
199 DeviceLightHardwareBuffer* light_buffer_; | |
200 DeviceMotionHardwareBuffer* motion_buffer_; | |
201 DeviceOrientationHardwareBuffer* orientation_buffer_; | |
202 DeviceOrientationHardwareBuffer* orientation_absolute_buffer_; | |
203 | |
204 DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher); | |
205 }; | |
206 | |
207 class FakeNonPollingDataFetcher : public FakeDataFetcher { | |
208 public: | |
209 FakeNonPollingDataFetcher() : update_(true) {} | |
210 ~FakeNonPollingDataFetcher() override {} | |
211 | |
212 bool Start(ConsumerType consumer_type, void* buffer) override { | |
213 Init(consumer_type, buffer); | |
214 switch (consumer_type) { | |
215 case CONSUMER_TYPE_MOTION: | |
216 if (update_) UpdateMotion(); | |
217 start_motion_.Signal(); | |
218 break; | |
219 case CONSUMER_TYPE_ORIENTATION: | |
220 if (update_) UpdateOrientation(); | |
221 start_orientation_.Signal(); | |
222 break; | |
223 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
224 if (update_) UpdateOrientationAbsolute(); | |
225 start_orientation_absolute_.Signal(); | |
226 break; | |
227 case CONSUMER_TYPE_LIGHT: | |
228 if (update_) UpdateLight(); | |
229 start_light_.Signal(); | |
230 break; | |
231 default: | |
232 return false; | |
233 } | |
234 return true; | |
235 } | |
236 | |
237 bool Stop(ConsumerType consumer_type) override { | |
238 switch (consumer_type) { | |
239 case CONSUMER_TYPE_MOTION: | |
240 stop_motion_.Signal(); | |
241 break; | |
242 case CONSUMER_TYPE_ORIENTATION: | |
243 stop_orientation_.Signal(); | |
244 break; | |
245 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
246 stop_orientation_absolute_.Signal(); | |
247 break; | |
248 case CONSUMER_TYPE_LIGHT: | |
249 stop_light_.Signal(); | |
250 break; | |
251 default: | |
252 return false; | |
253 } | |
254 return true; | |
255 } | |
256 | |
257 void Fetch(unsigned consumer_bitmask) override { | |
258 FAIL() << "fetch should not be called, " | |
259 << "because this is a non-polling fetcher"; | |
260 } | |
261 | |
262 FetcherType GetType() const override { return FakeDataFetcher::GetType(); } | |
263 void set_update(bool update) { update_ = update; } | |
264 | |
265 private: | |
266 bool update_; | |
267 | |
268 DISALLOW_COPY_AND_ASSIGN(FakeNonPollingDataFetcher); | |
269 }; | |
270 | |
271 class FakePollingDataFetcher : public FakeDataFetcher { | |
272 public: | |
273 FakePollingDataFetcher() { } | |
274 ~FakePollingDataFetcher() override {} | |
275 | |
276 bool Start(ConsumerType consumer_type, void* buffer) override { | |
277 EXPECT_TRUE( | |
278 GetPollingMessageLoop()->task_runner()->BelongsToCurrentThread()); | |
279 | |
280 Init(consumer_type, buffer); | |
281 switch (consumer_type) { | |
282 case CONSUMER_TYPE_MOTION: | |
283 start_motion_.Signal(); | |
284 break; | |
285 case CONSUMER_TYPE_ORIENTATION: | |
286 start_orientation_.Signal(); | |
287 break; | |
288 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
289 start_orientation_absolute_.Signal(); | |
290 break; | |
291 case CONSUMER_TYPE_LIGHT: | |
292 start_light_.Signal(); | |
293 break; | |
294 default: | |
295 return false; | |
296 } | |
297 return true; | |
298 } | |
299 | |
300 bool Stop(ConsumerType consumer_type) override { | |
301 EXPECT_TRUE( | |
302 GetPollingMessageLoop()->task_runner()->BelongsToCurrentThread()); | |
303 | |
304 switch (consumer_type) { | |
305 case CONSUMER_TYPE_MOTION: | |
306 stop_motion_.Signal(); | |
307 break; | |
308 case CONSUMER_TYPE_ORIENTATION: | |
309 stop_orientation_.Signal(); | |
310 break; | |
311 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
312 stop_orientation_absolute_.Signal(); | |
313 break; | |
314 case CONSUMER_TYPE_LIGHT: | |
315 stop_light_.Signal(); | |
316 break; | |
317 default: | |
318 return false; | |
319 } | |
320 return true; | |
321 } | |
322 | |
323 void Fetch(unsigned consumer_bitmask) override { | |
324 EXPECT_TRUE( | |
325 GetPollingMessageLoop()->task_runner()->BelongsToCurrentThread()); | |
326 EXPECT_TRUE(consumer_bitmask & CONSUMER_TYPE_ORIENTATION || | |
327 consumer_bitmask & CONSUMER_TYPE_ORIENTATION_ABSOLUTE || | |
328 consumer_bitmask & CONSUMER_TYPE_MOTION || | |
329 consumer_bitmask & CONSUMER_TYPE_LIGHT); | |
330 | |
331 if (consumer_bitmask & CONSUMER_TYPE_ORIENTATION) | |
332 UpdateOrientation(); | |
333 if (consumer_bitmask & CONSUMER_TYPE_ORIENTATION_ABSOLUTE) | |
334 UpdateOrientationAbsolute(); | |
335 if (consumer_bitmask & CONSUMER_TYPE_MOTION) | |
336 UpdateMotion(); | |
337 if (consumer_bitmask & CONSUMER_TYPE_LIGHT) | |
338 UpdateLight(); | |
339 } | |
340 | |
341 FetcherType GetType() const override { return FETCHER_TYPE_POLLING_CALLBACK; } | |
342 | |
343 private: | |
344 DISALLOW_COPY_AND_ASSIGN(FakePollingDataFetcher); | |
345 }; | |
346 | |
347 class FakeZeroDelayPollingDataFetcher : public FakeDataFetcher { | |
348 public: | |
349 FakeZeroDelayPollingDataFetcher() { } | |
350 ~FakeZeroDelayPollingDataFetcher() override {} | |
351 | |
352 bool Start(ConsumerType consumer_type, void* buffer) override { | |
353 EXPECT_TRUE( | |
354 GetPollingMessageLoop()->task_runner()->BelongsToCurrentThread()); | |
355 | |
356 Init(consumer_type, buffer); | |
357 switch (consumer_type) { | |
358 case CONSUMER_TYPE_MOTION: | |
359 start_motion_.Signal(); | |
360 break; | |
361 case CONSUMER_TYPE_ORIENTATION: | |
362 start_orientation_.Signal(); | |
363 break; | |
364 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
365 start_orientation_absolute_.Signal(); | |
366 break; | |
367 case CONSUMER_TYPE_LIGHT: | |
368 start_light_.Signal(); | |
369 break; | |
370 default: | |
371 return false; | |
372 } | |
373 return true; | |
374 } | |
375 | |
376 bool Stop(ConsumerType consumer_type) override { | |
377 EXPECT_TRUE( | |
378 GetPollingMessageLoop()->task_runner()->BelongsToCurrentThread()); | |
379 | |
380 switch (consumer_type) { | |
381 case CONSUMER_TYPE_MOTION: | |
382 stop_motion_.Signal(); | |
383 break; | |
384 case CONSUMER_TYPE_ORIENTATION: | |
385 stop_orientation_.Signal(); | |
386 break; | |
387 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | |
388 stop_orientation_absolute_.Signal(); | |
389 break; | |
390 case CONSUMER_TYPE_LIGHT: | |
391 stop_light_.Signal(); | |
392 break; | |
393 default: | |
394 return false; | |
395 } | |
396 return true; | |
397 } | |
398 | |
399 void Fetch(unsigned consumer_bitmask) override { | |
400 FAIL() << "fetch should not be called"; | |
401 } | |
402 | |
403 FetcherType GetType() const override { return FETCHER_TYPE_SEPARATE_THREAD; } | |
404 | |
405 bool IsPollingTimerRunningForTesting() const { | |
406 return FakeDataFetcher::IsPollingTimerRunningForTesting(); | |
407 } | |
408 | |
409 private: | |
410 DISALLOW_COPY_AND_ASSIGN(FakeZeroDelayPollingDataFetcher); | |
411 }; | |
412 | |
413 | |
414 TEST(DataFetcherSharedMemoryBaseTest, DoesStartMotion) { | |
415 FakeNonPollingDataFetcher fake_data_fetcher; | |
416 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | |
417 fake_data_fetcher.GetType()); | |
418 | |
419 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); | |
420 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); | |
421 | |
422 EXPECT_EQ(kDeviceSensorIntervalMicroseconds / 1000., | |
423 fake_data_fetcher.GetMotionBuffer()->data.interval); | |
424 | |
425 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); | |
426 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); | |
427 } | |
428 | |
429 TEST(DataFetcherSharedMemoryBaseTest, DoesStartOrientation) { | |
430 FakeNonPollingDataFetcher fake_data_fetcher; | |
431 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | |
432 fake_data_fetcher.GetType()); | |
433 | |
434 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
435 CONSUMER_TYPE_ORIENTATION)); | |
436 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | |
437 | |
438 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | |
439 | |
440 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | |
441 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | |
442 } | |
443 | |
444 TEST(DataFetcherSharedMemoryBaseTest, DoesStartOrientationAbsolute) { | |
445 FakeNonPollingDataFetcher fake_data_fetcher; | |
446 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | |
447 fake_data_fetcher.GetType()); | |
448 | |
449 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
450 CONSUMER_TYPE_ORIENTATION_ABSOLUTE)); | |
451 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
452 | |
453 EXPECT_EQ(1, fake_data_fetcher.GetOrientationAbsoluteBuffer()->data.alpha); | |
454 EXPECT_TRUE(fake_data_fetcher.GetOrientationAbsoluteBuffer()->data.absolute); | |
455 | |
456 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
457 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
458 } | |
459 | |
460 TEST(DataFetcherSharedMemoryBaseTest, DoesStartLight) { | |
461 FakeNonPollingDataFetcher fake_data_fetcher; | |
462 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | |
463 fake_data_fetcher.GetType()); | |
464 | |
465 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_LIGHT)); | |
466 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_LIGHT); | |
467 | |
468 EXPECT_EQ(100, fake_data_fetcher.GetLightBuffer()->data.value); | |
469 | |
470 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_LIGHT); | |
471 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_LIGHT); | |
472 } | |
473 | |
474 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotion) { | |
475 FakePollingDataFetcher fake_data_fetcher; | |
476 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | |
477 fake_data_fetcher.GetType()); | |
478 | |
479 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); | |
480 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); | |
481 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION); | |
482 | |
483 EXPECT_EQ(kDeviceSensorIntervalMicroseconds / 1000., | |
484 fake_data_fetcher.GetMotionBuffer()->data.interval); | |
485 | |
486 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); | |
487 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); | |
488 } | |
489 | |
490 TEST(DataFetcherSharedMemoryBaseTest, DoesPollOrientation) { | |
491 FakePollingDataFetcher fake_data_fetcher; | |
492 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | |
493 fake_data_fetcher.GetType()); | |
494 | |
495 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
496 CONSUMER_TYPE_ORIENTATION)); | |
497 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | |
498 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION); | |
499 | |
500 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | |
501 | |
502 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | |
503 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | |
504 } | |
505 | |
506 TEST(DataFetcherSharedMemoryBaseTest, DoesPollOrientationAbsolute) { | |
507 FakePollingDataFetcher fake_data_fetcher; | |
508 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | |
509 fake_data_fetcher.GetType()); | |
510 | |
511 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
512 CONSUMER_TYPE_ORIENTATION_ABSOLUTE)); | |
513 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
514 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
515 | |
516 EXPECT_EQ(1, fake_data_fetcher.GetOrientationAbsoluteBuffer()->data.alpha); | |
517 EXPECT_TRUE(fake_data_fetcher.GetOrientationAbsoluteBuffer()->data.absolute); | |
518 | |
519 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
520 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION_ABSOLUTE); | |
521 } | |
522 | |
523 TEST(DataFetcherSharedMemoryBaseTest, DoesPollLight) { | |
524 FakePollingDataFetcher fake_data_fetcher; | |
525 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | |
526 fake_data_fetcher.GetType()); | |
527 | |
528 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_LIGHT)); | |
529 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_LIGHT); | |
530 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_LIGHT); | |
531 | |
532 EXPECT_EQ(100, fake_data_fetcher.GetLightBuffer()->data.value); | |
533 | |
534 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_LIGHT); | |
535 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_LIGHT); | |
536 } | |
537 | |
538 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotionAndOrientation) { | |
539 FakePollingDataFetcher fake_data_fetcher; | |
540 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | |
541 fake_data_fetcher.GetType()); | |
542 | |
543 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
544 CONSUMER_TYPE_ORIENTATION)); | |
545 mojo::ScopedSharedBufferHandle handle_orientation = | |
546 fake_data_fetcher.GetSharedMemoryHandle(CONSUMER_TYPE_ORIENTATION); | |
547 EXPECT_TRUE(handle_orientation.is_valid()); | |
548 | |
549 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
550 CONSUMER_TYPE_MOTION)); | |
551 mojo::ScopedSharedBufferHandle handle_motion = | |
552 fake_data_fetcher.GetSharedMemoryHandle(CONSUMER_TYPE_MOTION); | |
553 EXPECT_TRUE(handle_motion.is_valid()); | |
554 | |
555 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | |
556 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); | |
557 | |
558 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION); | |
559 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION); | |
560 | |
561 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | |
562 EXPECT_EQ(kDeviceSensorIntervalMicroseconds / 1000., | |
563 fake_data_fetcher.GetMotionBuffer()->data.interval); | |
564 | |
565 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | |
566 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); | |
567 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | |
568 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); | |
569 } | |
570 | |
571 TEST(DataFetcherSharedMemoryBaseTest, DoesNotPollZeroDelay) { | |
572 FakeZeroDelayPollingDataFetcher fake_data_fetcher; | |
573 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_SEPARATE_THREAD, | |
574 fake_data_fetcher.GetType()); | |
575 | |
576 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
577 CONSUMER_TYPE_ORIENTATION)); | |
578 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | |
579 | |
580 EXPECT_FALSE(fake_data_fetcher.IsPollingTimerRunningForTesting()); | |
581 EXPECT_EQ(0, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | |
582 | |
583 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | |
584 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | |
585 } | |
586 | |
587 TEST(DataFetcherSharedMemoryBaseTest, DoesClearBufferOnStart) { | |
588 FakeNonPollingDataFetcher fake_data_fetcher; | |
589 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
590 CONSUMER_TYPE_ORIENTATION)); | |
591 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | |
592 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | |
593 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | |
594 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | |
595 | |
596 // Restart orientation without updating the memory buffer and check that | |
597 // it has been cleared to its initial state. | |
598 fake_data_fetcher.set_update(false); | |
599 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | |
600 CONSUMER_TYPE_ORIENTATION)); | |
601 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | |
602 EXPECT_EQ(0, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | |
603 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | |
604 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | |
605 } | |
606 | |
607 } // namespace | |
608 | |
609 } // namespace content | |
OLD | NEW |