src/content/browser/device_sensors/data_fetcher_shared_memory_base_unittest.cc

   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/process/process_handle.h"
   9 #include "base/synchronization/waitable_event.h"
  10 #include "base/threading/thread.h"
  11 #include "content/common/device_sensors/device_motion_hardware_buffer.h"
  12 #include "content/common/device_sensors/device_orientation_hardware_buffer.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace content {
  16
  17 namespace {
  18
  19 class FakeDataFetcher : public DataFetcherSharedMemoryBase {
  20  public:
  21   FakeDataFetcher()
  22       : start_motion_(false, false),
  23         start_orientation_(false, false),
  24         stop_motion_(false, false),
  25         stop_orientation_(false, false),
  26         updated_motion_(false, false),
  27         updated_orientation_(false, false),
  28         motion_buffer_(NULL),
  29         orientation_buffer_(NULL) {
  30   }
  31   virtual ~FakeDataFetcher() { }
  32
  33   bool Init(ConsumerType consumer_type, void* buffer) {
  34     EXPECT_TRUE(buffer);
  35
  36     switch (consumer_type) {
  37       case CONSUMER_TYPE_MOTION:
  38         motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer);
  39         break;
  40       case CONSUMER_TYPE_ORIENTATION:
  41         orientation_buffer_ =
  42             static_cast<DeviceOrientationHardwareBuffer*>(buffer);
  43         break;
  44       default:
  45         return false;
  46     }
  47     return true;
  48   }
  49
  50   void UpdateMotion() {
  51     DeviceMotionHardwareBuffer* buffer = GetMotionBuffer();
  52     ASSERT_TRUE(buffer);
  53     buffer->seqlock.WriteBegin();
  54     buffer->data.interval = kInertialSensorIntervalMillis;
  55     buffer->seqlock.WriteEnd();
  56     updated_motion_.Signal();
  57   }
  58
  59   void UpdateOrientation() {
  60     DeviceOrientationHardwareBuffer* buffer = GetOrientationBuffer();
  61     ASSERT_TRUE(buffer);
  62     buffer->seqlock.WriteBegin();
  63     buffer->data.alpha = 1;
  64     buffer->seqlock.WriteEnd();
  65     updated_orientation_.Signal();
  66   }
  67
  68   DeviceMotionHardwareBuffer* GetMotionBuffer() const {
  69     return motion_buffer_;
  70   }
  71
  72   DeviceOrientationHardwareBuffer* GetOrientationBuffer() const {
  73     return orientation_buffer_;
  74   }
  75
  76   void WaitForStart(ConsumerType consumer_type) {
  77     switch (consumer_type) {
  78       case CONSUMER_TYPE_MOTION:
  79         start_motion_.Wait();
  80         break;
  81       case CONSUMER_TYPE_ORIENTATION:
  82         start_orientation_.Wait();
  83         break;
  84     }
  85   }
  86
  87   void WaitForStop(ConsumerType consumer_type) {
  88     switch (consumer_type) {
  89       case CONSUMER_TYPE_MOTION:
  90         stop_motion_.Wait();
  91         break;
  92       case CONSUMER_TYPE_ORIENTATION:
  93         stop_orientation_.Wait();
  94         break;
  95     }
  96   }
  97
  98   void WaitForUpdate(ConsumerType consumer_type) {
  99     switch (consumer_type) {
 100       case CONSUMER_TYPE_MOTION:
 101         updated_motion_.Wait();
 102         break;
 103       case CONSUMER_TYPE_ORIENTATION:
 104         updated_orientation_.Wait();
 105         break;
 106     }
 107   }
 108
 109  protected:
 110   base::WaitableEvent start_motion_;
 111   base::WaitableEvent start_orientation_;
 112   base::WaitableEvent stop_motion_;
 113   base::WaitableEvent stop_orientation_;
 114   base::WaitableEvent updated_motion_;
 115   base::WaitableEvent updated_orientation_;
 116
 117  private:
 118   DeviceMotionHardwareBuffer* motion_buffer_;
 119   DeviceOrientationHardwareBuffer* orientation_buffer_;
 120
 121   DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher);
 122 };
 123
 124 class FakeNonPollingDataFetcher : public FakeDataFetcher {
 125  public:
 126   FakeNonPollingDataFetcher() { }
 127   virtual ~FakeNonPollingDataFetcher() { }
 128
 129   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
 130     Init(consumer_type, buffer);
 131     switch (consumer_type) {
 132       case CONSUMER_TYPE_MOTION:
 133         UpdateMotion();
 134         start_motion_.Signal();
 135         break;
 136       case CONSUMER_TYPE_ORIENTATION:
 137         UpdateOrientation();
 138         start_orientation_.Signal();
 139         break;
 140       default:
 141         return false;
 142     }
 143     return true;
 144   }
 145
 146   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
 147     switch (consumer_type) {
 148       case CONSUMER_TYPE_MOTION:
 149         stop_motion_.Signal();
 150         break;
 151       case CONSUMER_TYPE_ORIENTATION:
 152         stop_orientation_.Signal();
 153         break;
 154       default:
 155         return false;
 156     }
 157     return true;
 158   }
 159
 160   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
 161     FAIL() << "fetch should not be called, "
 162         << "because this is a non-polling fetcher";
 163   }
 164
 165   virtual FetcherType GetType() const OVERRIDE {
 166     return FakeDataFetcher::GetType();
 167   }
 168
 169  private:
 170   DISALLOW_COPY_AND_ASSIGN(FakeNonPollingDataFetcher);
 171 };
 172
 173 class FakePollingDataFetcher : public FakeDataFetcher {
 174  public:
 175   FakePollingDataFetcher() { }
 176   virtual ~FakePollingDataFetcher() { }
 177
 178   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
 179     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 180
 181     Init(consumer_type, buffer);
 182     switch (consumer_type) {
 183       case CONSUMER_TYPE_MOTION:
 184         start_motion_.Signal();
 185         break;
 186       case CONSUMER_TYPE_ORIENTATION:
 187         start_orientation_.Signal();
 188         break;
 189       default:
 190         return false;
 191     }
 192     return true;
 193   }
 194
 195   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
 196     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 197
 198     switch (consumer_type) {
 199       case CONSUMER_TYPE_MOTION:
 200         stop_motion_.Signal();
 201         break;
 202       case CONSUMER_TYPE_ORIENTATION:
 203         stop_orientation_.Signal();
 204         break;
 205       default:
 206         return false;
 207     }
 208     return true;
 209   }
 210
 211   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
 212     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 213     EXPECT_TRUE(consumer_bitmask & CONSUMER_TYPE_ORIENTATION ||
 214                 consumer_bitmask & CONSUMER_TYPE_MOTION);
 215
 216     if (consumer_bitmask & CONSUMER_TYPE_ORIENTATION)
 217       UpdateOrientation();
 218     if (consumer_bitmask & CONSUMER_TYPE_MOTION)
 219       UpdateMotion();
 220   }
 221
 222   virtual FetcherType GetType() const OVERRIDE {
 223     return FETCHER_TYPE_POLLING_CALLBACK;
 224   }
 225
 226  private:
 227   DISALLOW_COPY_AND_ASSIGN(FakePollingDataFetcher);
 228 };
 229
 230 class FakeZeroDelayPollingDataFetcher : public FakeDataFetcher {
 231  public:
 232   FakeZeroDelayPollingDataFetcher() { }
 233   virtual ~FakeZeroDelayPollingDataFetcher() { }
 234
 235   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
 236     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 237
 238     Init(consumer_type, buffer);
 239     switch (consumer_type) {
 240       case CONSUMER_TYPE_MOTION:
 241         start_motion_.Signal();
 242         break;
 243       case CONSUMER_TYPE_ORIENTATION:
 244         start_orientation_.Signal();
 245         break;
 246       default:
 247         return false;
 248     }
 249     return true;
 250   }
 251
 252   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
 253     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 254
 255     switch (consumer_type) {
 256       case CONSUMER_TYPE_MOTION:
 257         stop_motion_.Signal();
 258         break;
 259       case CONSUMER_TYPE_ORIENTATION:
 260         stop_orientation_.Signal();
 261         break;
 262       default:
 263         return false;
 264     }
 265     return true;
 266   }
 267
 268   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
 269     FAIL() << "fetch should not be called";
 270   }
 271
 272   virtual FetcherType GetType() const OVERRIDE {
 273     return FETCHER_TYPE_SEPARATE_THREAD;
 274   }
 275
 276   bool IsPollingTimerRunningForTesting() const {
 277     return FakeDataFetcher::IsPollingTimerRunningForTesting();
 278   }
 279
 280  private:
 281   DISALLOW_COPY_AND_ASSIGN(FakeZeroDelayPollingDataFetcher);
 282 };
 283
 284
 285 TEST(DataFetcherSharedMemoryBaseTest, DoesStartMotion) {
 286   FakeNonPollingDataFetcher fake_data_fetcher;
 287   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT,
 288       fake_data_fetcher.GetType());
 289
 290   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION));
 291   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION);
 292
 293   EXPECT_EQ(kInertialSensorIntervalMillis,
 294       fake_data_fetcher.GetMotionBuffer()->data.interval);
 295
 296   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
 297   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION);
 298 }
 299
 300 TEST(DataFetcherSharedMemoryBaseTest, DoesStartOrientation) {
 301   FakeNonPollingDataFetcher fake_data_fetcher;
 302   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT,
 303       fake_data_fetcher.GetType());
 304
 305   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 306       CONSUMER_TYPE_ORIENTATION));
 307   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 308
 309   EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 310
 311   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 312   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 313 }
 314
 315 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotion) {
 316   FakePollingDataFetcher fake_data_fetcher;
 317   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK,
 318       fake_data_fetcher.GetType());
 319
 320   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION));
 321   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION);
 322   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION);
 323
 324   EXPECT_EQ(kInertialSensorIntervalMillis,
 325       fake_data_fetcher.GetMotionBuffer()->data.interval);
 326
 327   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
 328   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION);
 329 }
 330
 331 TEST(DataFetcherSharedMemoryBaseTest, DoesPollOrientation) {
 332   FakePollingDataFetcher fake_data_fetcher;
 333   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK,
 334       fake_data_fetcher.GetType());
 335
 336   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 337       CONSUMER_TYPE_ORIENTATION));
 338   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 339   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION);
 340
 341   EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 342
 343   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 344   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 345 }
 346
 347 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotionAndOrientation) {
 348   FakePollingDataFetcher fake_data_fetcher;
 349   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK,
 350       fake_data_fetcher.GetType());
 351
 352   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 353       CONSUMER_TYPE_ORIENTATION));
 354   base::SharedMemoryHandle handle_orientation =
 355       fake_data_fetcher.GetSharedMemoryHandleForProcess(
 356           CONSUMER_TYPE_ORIENTATION, base::GetCurrentProcessHandle());
 357   EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_orientation));
 358
 359   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 360       CONSUMER_TYPE_MOTION));
 361   base::SharedMemoryHandle handle_motion =
 362       fake_data_fetcher.GetSharedMemoryHandleForProcess(
 363           CONSUMER_TYPE_MOTION, base::GetCurrentProcessHandle());
 364   EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_motion));
 365
 366   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 367   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION);
 368
 369   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION);
 370   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION);
 371
 372   EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 373   EXPECT_EQ(kInertialSensorIntervalMillis,
 374       fake_data_fetcher.GetMotionBuffer()->data.interval);
 375
 376   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 377   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
 378   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 379   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION);
 380 }
 381
 382 TEST(DataFetcherSharedMemoryBaseTest, DoesNotPollZeroDelay) {
 383   FakeZeroDelayPollingDataFetcher fake_data_fetcher;
 384   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_SEPARATE_THREAD,
 385       fake_data_fetcher.GetType());
 386
 387   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 388       CONSUMER_TYPE_ORIENTATION));
 389   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 390
 391   EXPECT_FALSE(fake_data_fetcher.IsPollingTimerRunningForTesting());
 392   EXPECT_EQ(0, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 393
 394   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 395   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 396 }
 397
 398
 399 }  // namespace
 400
 401 }  // namespace content