src/content/browser/device_orientation/data_fetcher_shared_memory_base_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/device_orientation/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_orientation/device_motion_hardware_buffer.h"
  12 #include "content/common/device_orientation/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
 171   DISALLOW_COPY_AND_ASSIGN(FakeNonPollingDataFetcher);
 172 };
 173
 174 class FakePollingDataFetcher : public FakeDataFetcher {
 175  public:
 176   FakePollingDataFetcher() { }
 177   virtual ~FakePollingDataFetcher() { }
 178
 179   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
 180     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 181
 182     Init(consumer_type, buffer);
 183     switch (consumer_type) {
 184       case CONSUMER_TYPE_MOTION:
 185         start_motion_.Signal();
 186         break;
 187       case CONSUMER_TYPE_ORIENTATION:
 188         start_orientation_.Signal();
 189         break;
 190       default:
 191         return false;
 192     }
 193     return true;
 194   }
 195
 196   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
 197     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 198
 199     switch (consumer_type) {
 200       case CONSUMER_TYPE_MOTION:
 201         stop_motion_.Signal();
 202         break;
 203       case CONSUMER_TYPE_ORIENTATION:
 204         stop_orientation_.Signal();
 205         break;
 206       default:
 207         return false;
 208     }
 209     return true;
 210   }
 211
 212   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
 213     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 214     EXPECT_TRUE(consumer_bitmask & CONSUMER_TYPE_ORIENTATION ||
 215                 consumer_bitmask & CONSUMER_TYPE_MOTION);
 216
 217     if (consumer_bitmask & CONSUMER_TYPE_ORIENTATION)
 218       UpdateOrientation();
 219     if (consumer_bitmask & CONSUMER_TYPE_MOTION)
 220       UpdateMotion();
 221   }
 222
 223   virtual FetcherType GetType() const OVERRIDE {
 224     return FETCHER_TYPE_POLLING_CALLBACK;
 225   }
 226
 227  private:
 228
 229   DISALLOW_COPY_AND_ASSIGN(FakePollingDataFetcher);
 230 };
 231
 232 class FakeZeroDelayPollingDataFetcher : public FakeDataFetcher {
 233  public:
 234   FakeZeroDelayPollingDataFetcher() { }
 235   virtual ~FakeZeroDelayPollingDataFetcher() { }
 236
 237   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
 238     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 239
 240     Init(consumer_type, buffer);
 241     switch (consumer_type) {
 242       case CONSUMER_TYPE_MOTION:
 243         start_motion_.Signal();
 244         break;
 245       case CONSUMER_TYPE_ORIENTATION:
 246         start_orientation_.Signal();
 247         break;
 248       default:
 249         return false;
 250     }
 251     return true;
 252   }
 253
 254   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
 255     EXPECT_TRUE(base::MessageLoop::current() == GetPollingMessageLoop());
 256
 257     switch (consumer_type) {
 258       case CONSUMER_TYPE_MOTION:
 259         stop_motion_.Signal();
 260         break;
 261       case CONSUMER_TYPE_ORIENTATION:
 262         stop_orientation_.Signal();
 263         break;
 264       default:
 265         return false;
 266     }
 267     return true;
 268   }
 269
 270   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
 271     FAIL() << "fetch should not be called";
 272   }
 273
 274   virtual FetcherType GetType() const OVERRIDE {
 275     return FETCHER_TYPE_SEPARATE_THREAD;
 276   }
 277
 278   bool IsPollingTimerRunningForTesting() const {
 279     return FakeDataFetcher::IsPollingTimerRunningForTesting();
 280   }
 281
 282  private:
 283
 284   DISALLOW_COPY_AND_ASSIGN(FakeZeroDelayPollingDataFetcher);
 285 };
 286
 287
 288 TEST(DataFetcherSharedMemoryBaseTest, DoesStartMotion) {
 289   FakeNonPollingDataFetcher fake_data_fetcher;
 290   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT,
 291       fake_data_fetcher.GetType());
 292
 293   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION));
 294   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION);
 295
 296   EXPECT_EQ(kInertialSensorIntervalMillis,
 297       fake_data_fetcher.GetMotionBuffer()->data.interval);
 298
 299   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
 300   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION);
 301 }
 302
 303 TEST(DataFetcherSharedMemoryBaseTest, DoesStartOrientation) {
 304   FakeNonPollingDataFetcher fake_data_fetcher;
 305   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_DEFAULT,
 306       fake_data_fetcher.GetType());
 307
 308   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 309       CONSUMER_TYPE_ORIENTATION));
 310   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 311
 312   EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 313
 314   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 315   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 316 }
 317
 318 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotion) {
 319   FakePollingDataFetcher fake_data_fetcher;
 320   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK,
 321       fake_data_fetcher.GetType());
 322
 323   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(CONSUMER_TYPE_MOTION));
 324   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION);
 325   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION);
 326
 327   EXPECT_EQ(kInertialSensorIntervalMillis,
 328       fake_data_fetcher.GetMotionBuffer()->data.interval);
 329
 330   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
 331   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION);
 332 }
 333
 334 TEST(DataFetcherSharedMemoryBaseTest, DoesPollOrientation) {
 335   FakePollingDataFetcher fake_data_fetcher;
 336   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK,
 337       fake_data_fetcher.GetType());
 338
 339   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 340       CONSUMER_TYPE_ORIENTATION));
 341   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 342   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION);
 343
 344   EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 345
 346   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 347   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 348 }
 349
 350 TEST(DataFetcherSharedMemoryBaseTest, DoesPollMotionAndOrientation) {
 351   FakePollingDataFetcher fake_data_fetcher;
 352   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_POLLING_CALLBACK,
 353       fake_data_fetcher.GetType());
 354
 355   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 356       CONSUMER_TYPE_ORIENTATION));
 357   base::SharedMemoryHandle handle_orientation =
 358       fake_data_fetcher.GetSharedMemoryHandleForProcess(
 359           CONSUMER_TYPE_ORIENTATION, base::GetCurrentProcessHandle());
 360   EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_orientation));
 361
 362   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 363       CONSUMER_TYPE_MOTION));
 364   base::SharedMemoryHandle handle_motion =
 365       fake_data_fetcher.GetSharedMemoryHandleForProcess(
 366           CONSUMER_TYPE_MOTION, base::GetCurrentProcessHandle());
 367   EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle_motion));
 368
 369   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 370   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_MOTION);
 371
 372   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_ORIENTATION);
 373   fake_data_fetcher.WaitForUpdate(CONSUMER_TYPE_MOTION);
 374
 375   EXPECT_EQ(1, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 376   EXPECT_EQ(kInertialSensorIntervalMillis,
 377       fake_data_fetcher.GetMotionBuffer()->data.interval);
 378
 379   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 380   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
 381   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 382   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_MOTION);
 383 }
 384
 385 TEST(DataFetcherSharedMemoryBaseTest, DoesNotPollZeroDelay) {
 386   FakeZeroDelayPollingDataFetcher fake_data_fetcher;
 387   EXPECT_EQ(DataFetcherSharedMemoryBase::FETCHER_TYPE_SEPARATE_THREAD,
 388       fake_data_fetcher.GetType());
 389
 390   EXPECT_TRUE(fake_data_fetcher.StartFetchingDeviceData(
 391       CONSUMER_TYPE_ORIENTATION));
 392   fake_data_fetcher.WaitForStart(CONSUMER_TYPE_ORIENTATION);
 393
 394   EXPECT_FALSE(fake_data_fetcher.IsPollingTimerRunningForTesting());
 395   EXPECT_EQ(0, fake_data_fetcher.GetOrientationBuffer()->data.alpha);
 396
 397   fake_data_fetcher.StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
 398   fake_data_fetcher.WaitForStop(CONSUMER_TYPE_ORIENTATION);
 399 }
 400
 401
 402 }  // namespace
 403
 404 }  // namespace content