OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "content/browser/device_sensors/data_fetcher_shared_memory_base.h" | 5 #include "device/device_sensors/data_fetcher_shared_memory_base.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/process/process_handle.h" | 8 #include "base/process/process_handle.h" |
9 #include "base/synchronization/waitable_event.h" | 9 #include "base/synchronization/waitable_event.h" |
10 #include "base/threading/thread.h" | 10 #include "base/threading/thread.h" |
11 #include "content/common/device_sensors/device_light_hardware_buffer.h" | 11 #include "device/device_sensors/device_light_hardware_buffer.h" |
12 #include "content/common/device_sensors/device_motion_hardware_buffer.h" | 12 #include "device/device_sensors/device_motion_hardware_buffer.h" |
13 #include "content/common/device_sensors/device_orientation_hardware_buffer.h" | 13 #include "device/device_sensors/device_orientation_hardware_buffer.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
15 | 15 |
16 namespace content { | 16 namespace content { |
17 | 17 |
18 namespace { | 18 namespace { |
19 | 19 |
20 class FakeDataFetcher : public DataFetcherSharedMemoryBase { | 20 class FakeDataFetcher : public DataFetcherSharedMemoryBase { |
21 public: | 21 public: |
22 FakeDataFetcher() | 22 FakeDataFetcher() |
23 : start_light_(false, false), | 23 : start_light_(false, false), |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
76 DeviceOrientationHardwareBuffer* buffer = GetOrientationBuffer(); | 76 DeviceOrientationHardwareBuffer* buffer = GetOrientationBuffer(); |
77 ASSERT_TRUE(buffer); | 77 ASSERT_TRUE(buffer); |
78 buffer->seqlock.WriteBegin(); | 78 buffer->seqlock.WriteBegin(); |
79 buffer->data.alpha = 1; | 79 buffer->data.alpha = 1; |
80 buffer->seqlock.WriteEnd(); | 80 buffer->seqlock.WriteEnd(); |
81 updated_orientation_.Signal(); | 81 updated_orientation_.Signal(); |
82 } | 82 } |
83 | 83 |
84 DeviceLightHardwareBuffer* GetLightBuffer() const { return light_buffer_; } | 84 DeviceLightHardwareBuffer* GetLightBuffer() const { return light_buffer_; } |
85 | 85 |
86 DeviceMotionHardwareBuffer* GetMotionBuffer() const { | 86 DeviceMotionHardwareBuffer* GetMotionBuffer() const { return motion_buffer_; } |
87 return motion_buffer_; | |
88 } | |
89 | 87 |
90 DeviceOrientationHardwareBuffer* GetOrientationBuffer() const { | 88 DeviceOrientationHardwareBuffer* GetOrientationBuffer() const { |
91 return orientation_buffer_; | 89 return orientation_buffer_; |
92 } | 90 } |
93 | 91 |
94 void WaitForStart(ConsumerType consumer_type) { | 92 void WaitForStart(ConsumerType consumer_type) { |
95 switch (consumer_type) { | 93 switch (consumer_type) { |
96 case CONSUMER_TYPE_MOTION: | 94 case CONSUMER_TYPE_MOTION: |
97 start_motion_.Wait(); | 95 start_motion_.Wait(); |
98 break; | 96 break; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
147 private: | 145 private: |
148 DeviceLightHardwareBuffer* light_buffer_; | 146 DeviceLightHardwareBuffer* light_buffer_; |
149 DeviceMotionHardwareBuffer* motion_buffer_; | 147 DeviceMotionHardwareBuffer* motion_buffer_; |
150 DeviceOrientationHardwareBuffer* orientation_buffer_; | 148 DeviceOrientationHardwareBuffer* orientation_buffer_; |
151 | 149 |
152 DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher); | 150 DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher); |
153 }; | 151 }; |
154 | 152 |
155 class FakeNonPollingDataFetcher : public FakeDataFetcher { | 153 class FakeNonPollingDataFetcher : public FakeDataFetcher { |
156 public: | 154 public: |
157 FakeNonPollingDataFetcher() { } | 155 FakeNonPollingDataFetcher() {} |
158 ~FakeNonPollingDataFetcher() override {} | 156 ~FakeNonPollingDataFetcher() override {} |
159 | 157 |
160 bool Start(ConsumerType consumer_type, void* buffer) override { | 158 bool Start(ConsumerType consumer_type, void* buffer) override { |
161 Init(consumer_type, buffer); | 159 Init(consumer_type, buffer); |
162 switch (consumer_type) { | 160 switch (consumer_type) { |
163 case CONSUMER_TYPE_MOTION: | 161 case CONSUMER_TYPE_MOTION: |
164 UpdateMotion(); | 162 UpdateMotion(); |
165 start_motion_.Signal(); | 163 start_motion_.Signal(); |
166 break; | 164 break; |
167 case CONSUMER_TYPE_ORIENTATION: | 165 case CONSUMER_TYPE_ORIENTATION: |
(...skipping 22 matching lines...) Expand all Loading... |
190 stop_light_.Signal(); | 188 stop_light_.Signal(); |
191 break; | 189 break; |
192 default: | 190 default: |
193 return false; | 191 return false; |
194 } | 192 } |
195 return true; | 193 return true; |
196 } | 194 } |
197 | 195 |
198 void Fetch(unsigned consumer_bitmask) override { | 196 void Fetch(unsigned consumer_bitmask) override { |
199 FAIL() << "fetch should not be called, " | 197 FAIL() << "fetch should not be called, " |
200 << "because this is a non-polling fetcher"; | 198 << "because this is a non-polling fetcher"; |
201 } | 199 } |
202 | 200 |
203 FetcherType GetType() const override { return FakeDataFetcher::GetType(); } | 201 FetcherType GetType() const override { return FakeDataFetcher::GetType(); } |
204 | 202 |
205 private: | 203 private: |
206 DISALLOW_COPY_AND_ASSIGN(FakeNonPollingDataFetcher); | 204 DISALLOW_COPY_AND_ASSIGN(FakeNonPollingDataFetcher); |
207 }; | 205 }; |
208 | 206 |
209 class FakePollingDataFetcher : public FakeDataFetcher { | 207 class FakePollingDataFetcher : public FakeDataFetcher { |
210 public: | 208 public: |
211 FakePollingDataFetcher() { } | 209 FakePollingDataFetcher() {} |
212 ~FakePollingDataFetcher() override {} | 210 ~FakePollingDataFetcher() override {} |
213 | 211 |
214 bool Start(ConsumerType consumer_type, void* buffer) override { | 212 bool Start(ConsumerType consumer_type, void* buffer) override { |
215 EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop()); | 213 EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop()); |
216 | 214 |
217 Init(consumer_type, buffer); | 215 Init(consumer_type, buffer); |
218 switch (consumer_type) { | 216 switch (consumer_type) { |
219 case CONSUMER_TYPE_MOTION: | 217 case CONSUMER_TYPE_MOTION: |
220 start_motion_.Signal(); | 218 start_motion_.Signal(); |
221 break; | 219 break; |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
265 } | 263 } |
266 | 264 |
267 FetcherType GetType() const override { return FETCHER_TYPE_POLLING_CALLBACK; } | 265 FetcherType GetType() const override { return FETCHER_TYPE_POLLING_CALLBACK; } |
268 | 266 |
269 private: | 267 private: |
270 DISALLOW_COPY_AND_ASSIGN(FakePollingDataFetcher); | 268 DISALLOW_COPY_AND_ASSIGN(FakePollingDataFetcher); |
271 }; | 269 }; |
272 | 270 |
273 class FakeZeroDelayPollingDataFetcher : public FakeDataFetcher { | 271 class FakeZeroDelayPollingDataFetcher : public FakeDataFetcher { |
274 public: | 272 public: |
275 FakeZeroDelayPollingDataFetcher() { } | 273 FakeZeroDelayPollingDataFetcher() {} |
276 ~FakeZeroDelayPollingDataFetcher() override {} | 274 ~FakeZeroDelayPollingDataFetcher() override {} |
277 | 275 |
278 bool Start(ConsumerType consumer_type, void* buffer) override { | 276 bool Start(ConsumerType consumer_type, void* buffer) override { |
279 EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop()); | 277 EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop()); |
280 | 278 |
281 Init(consumer_type, buffer); | 279 Init(consumer_type, buffer); |
282 switch (consumer_type) { | 280 switch (consumer_type) { |
283 case CONSUMER_TYPE_MOTION: | 281 case CONSUMER_TYPE_MOTION: |
284 start_motion_.Signal(); | 282 start_motion_.Signal(); |
285 break; | 283 break; |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
321 FetcherType GetType() const override { return FETCHER_TYPE_SEPARATE_THREAD; } | 319 FetcherType GetType() const override { return FETCHER_TYPE_SEPARATE_THREAD; } |
322 | 320 |
323 bool IsPollingTimerRunningForTesting() const { | 321 bool IsPollingTimerRunningForTesting() const { |
324 return FakeDataFetcher::IsPollingTimerRunningForTesting(); | 322 return FakeDataFetcher::IsPollingTimerRunningForTesting(); |
325 } | 323 } |
326 | 324 |
327 private: | 325 private: |
328 DISALLOW_COPY_AND_ASSIGN(FakeZeroDelayPollingDataFetcher); | 326 DISALLOW_COPY_AND_ASSIGN(FakeZeroDelayPollingDataFetcher); |
329 }; | 327 }; |
330 | 328 |
331 | |
332 TEST(DataFetcherSharedMemoryBaseTest, DoesStartMotion) { | 329 TEST(DataFetcherSharedMemoryBaseTest, DoesStartMotion) { |
333 FakeNonPollingDataFetcher fake_data_fetcher; | 330 FakeNonPollingDataFetcher fake_data_fetcher; |
334 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | 331 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, |
335 fake_data_fetcher.GetType()); | 332 fake_data_fetcher.GetType()); |
336 | 333 |
337 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); | 334 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); |
338 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); | 335 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); |
339 | 336 |
340 EXPECT_EQ(kInertialSensorIntervalMicroseconds / 1000., | 337 EXPECT_EQ(kInertialSensorIntervalMicroseconds / 1000., |
341 fake_data_fetcher.GetMotionBuffer()->data.interval); | 338 fake_data_fetcher.GetMotionBuffer()->data.interval); |
342 | 339 |
343 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); | 340 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); |
344 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); | 341 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); |
345 } | 342 } |
346 | 343 |
347 TEST(DataFetcherSharedMemoryBaseTest, DoesStartOrientation) { | 344 TEST(DataFetcherSharedMemoryBaseTest, DoesStartOrientation) { |
348 FakeNonPollingDataFetcher fake_data_fetcher; | 345 FakeNonPollingDataFetcher fake_data_fetcher; |
349 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | 346 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, |
350 fake_data_fetcher.GetType()); | 347 fake_data_fetcher.GetType()); |
351 | 348 |
352 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | 349 EXPECT_TRUE( |
353 CONSUMER_TYPE_ORIENTATION)); | 350 fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_ORIENTATION)); |
354 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | 351 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); |
355 | 352 |
356 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | 353 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); |
357 | 354 |
358 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | 355 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); |
359 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | 356 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); |
360 } | 357 } |
361 | 358 |
362 TEST(DataFetcherSharedMemoryBaseTest, DoesStartLight) { | 359 TEST(DataFetcherSharedMemoryBaseTest, DoesStartLight) { |
363 FakeNonPollingDataFetcher fake_data_fetcher; | 360 FakeNonPollingDataFetcher fake_data_fetcher; |
364 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, | 361 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT, |
365 fake_data_fetcher.GetType()); | 362 fake_data_fetcher.GetType()); |
366 | 363 |
367 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_LIGHT)); | 364 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_LIGHT)); |
368 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_LIGHT); | 365 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_LIGHT); |
369 | 366 |
370 EXPECT_EQ(100, fake_data_fetcher.GetLightBuffer()->data.value); | 367 EXPECT_EQ(100, fake_data_fetcher.GetLightBuffer()->data.value); |
371 | 368 |
372 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_LIGHT); | 369 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_LIGHT); |
373 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_LIGHT); | 370 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_LIGHT); |
374 } | 371 } |
375 | 372 |
376 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotion) { | 373 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotion) { |
377 FakePollingDataFetcher fake_data_fetcher; | 374 FakePollingDataFetcher fake_data_fetcher; |
378 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | 375 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, |
379 fake_data_fetcher.GetType()); | 376 fake_data_fetcher.GetType()); |
380 | 377 |
381 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); | 378 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); |
382 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); | 379 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); |
383 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION); | 380 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION); |
384 | 381 |
385 EXPECT_EQ(kInertialSensorIntervalMicroseconds / 1000., | 382 EXPECT_EQ(kInertialSensorIntervalMicroseconds / 1000., |
386 fake_data_fetcher.GetMotionBuffer()->data.interval); | 383 fake_data_fetcher.GetMotionBuffer()->data.interval); |
387 | 384 |
388 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); | 385 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); |
389 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); | 386 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); |
390 } | 387 } |
391 | 388 |
392 TEST(DataFetcherSharedMemoryBaseTest, DoesPollOrientation) { | 389 TEST(DataFetcherSharedMemoryBaseTest, DoesPollOrientation) { |
393 FakePollingDataFetcher fake_data_fetcher; | 390 FakePollingDataFetcher fake_data_fetcher; |
394 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | 391 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, |
395 fake_data_fetcher.GetType()); | 392 fake_data_fetcher.GetType()); |
396 | 393 |
397 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | 394 EXPECT_TRUE( |
398 CONSUMER_TYPE_ORIENTATION)); | 395 fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_ORIENTATION)); |
399 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | 396 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); |
400 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION); | 397 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION); |
401 | 398 |
402 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | 399 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); |
403 | 400 |
404 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | 401 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); |
405 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | 402 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); |
406 } | 403 } |
407 | 404 |
408 TEST(DataFetcherSharedMemoryBaseTest, DoesPollLight) { | 405 TEST(DataFetcherSharedMemoryBaseTest, DoesPollLight) { |
409 FakePollingDataFetcher fake_data_fetcher; | 406 FakePollingDataFetcher fake_data_fetcher; |
410 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | 407 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, |
411 fake_data_fetcher.GetType()); | 408 fake_data_fetcher.GetType()); |
412 | 409 |
413 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_LIGHT)); | 410 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_LIGHT)); |
414 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_LIGHT); | 411 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_LIGHT); |
415 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_LIGHT); | 412 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_LIGHT); |
416 | 413 |
417 EXPECT_EQ(100, fake_data_fetcher.GetLightBuffer()->data.value); | 414 EXPECT_EQ(100, fake_data_fetcher.GetLightBuffer()->data.value); |
418 | 415 |
419 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_LIGHT); | 416 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_LIGHT); |
420 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_LIGHT); | 417 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_LIGHT); |
421 } | 418 } |
422 | 419 |
423 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotionAndOrientation) { | 420 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotionAndOrientation) { |
424 FakePollingDataFetcher fake_data_fetcher; | 421 FakePollingDataFetcher fake_data_fetcher; |
425 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, | 422 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK, |
426 fake_data_fetcher.GetType()); | 423 fake_data_fetcher.GetType()); |
427 | 424 |
428 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | 425 EXPECT_TRUE( |
429 CONSUMER_TYPE_ORIENTATION)); | 426 fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_ORIENTATION)); |
430 base::SharedMemoryHandle handle_orientation = | 427 base::SharedMemoryHandle handle_orientation = |
431 fake_data_fetcher.GetSharedMemoryHandleForProcess( | 428 fake_data_fetcher.GetSharedMemoryHandleForProcess( |
432 CONSUMER_TYPE_ORIENTATION, base::GetCurrentProcessHandle()); | 429 CONSUMER_TYPE_ORIENTATION, base::GetCurrentProcessHandle()); |
433 EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_orientation)); | 430 EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_orientation)); |
434 | 431 |
435 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | 432 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION)); |
436 CONSUMER_TYPE_MOTION)); | |
437 base::SharedMemoryHandle handle_motion = | 433 base::SharedMemoryHandle handle_motion = |
438 fake_data_fetcher.GetSharedMemoryHandleForProcess( | 434 fake_data_fetcher.GetSharedMemoryHandleForProcess( |
439 CONSUMER_TYPE_MOTION, base::GetCurrentProcessHandle()); | 435 CONSUMER_TYPE_MOTION, base::GetCurrentProcessHandle()); |
440 EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_motion)); | 436 EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_motion)); |
441 | 437 |
442 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | 438 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); |
443 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); | 439 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION); |
444 | 440 |
445 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION); | 441 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION); |
446 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION); | 442 fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION); |
447 | 443 |
448 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | 444 EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha); |
449 EXPECT_EQ(kInertialSensorIntervalMicroseconds / 1000., | 445 EXPECT_EQ(kInertialSensorIntervalMicroseconds / 1000., |
450 fake_data_fetcher.GetMotionBuffer()->data.interval); | 446 fake_data_fetcher.GetMotionBuffer()->data.interval); |
451 | 447 |
452 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | 448 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); |
453 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); | 449 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION); |
454 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | 450 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); |
455 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); | 451 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION); |
456 } | 452 } |
457 | 453 |
458 TEST(DataFetcherSharedMemoryBaseTest, DoesNotPollZeroDelay) { | 454 TEST(DataFetcherSharedMemoryBaseTest, DoesNotPollZeroDelay) { |
459 FakeZeroDelayPollingDataFetcher fake_data_fetcher; | 455 FakeZeroDelayPollingDataFetcher fake_data_fetcher; |
460 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_SEPARATE_THREAD, | 456 EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_SEPARATE_THREAD, |
461 fake_data_fetcher.GetType()); | 457 fake_data_fetcher.GetType()); |
462 | 458 |
463 EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData( | 459 EXPECT_TRUE( |
464 CONSUMER_TYPE_ORIENTATION)); | 460 fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_ORIENTATION)); |
465 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); | 461 fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION); |
466 | 462 |
467 EXPECT_FALSE(fake_data_fetcher.IsPollingTimerRunningForTesting()); | 463 EXPECT_FALSE(fake_data_fetcher.IsPollingTimerRunningForTesting()); |
468 EXPECT_EQ(0, fake_data_fetcher.GetOrientationBuffer()->data.alpha); | 464 EXPECT_EQ(0, fake_data_fetcher.GetOrientationBuffer()->data.alpha); |
469 | 465 |
470 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); | 466 fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION); |
471 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); | 467 fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION); |
472 } | 468 } |
473 | 469 |
474 | |
475 } // namespace | 470 } // namespace |
476 | 471 |
477 } // namespace content | 472 } // namespace content |
OLD | NEW |