content/renderer/device_sensors/device_motion_event_pump_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 "device_motion_event_pump.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "content/common/device_sensors/device_motion_hardware_buffer.h"
  11 #include "content/public/test/test_utils.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/WebKit/public/platform/WebDeviceMotionListener.h"
  14
  15 namespace content {
  16
  17 class MockDeviceMotionListener : public blink::WebDeviceMotionListener {
  18  public:
  19   MockDeviceMotionListener()
  20       : did_change_device_motion_(false), number_of_events_(0) {
  21     memset(&data_, 0, sizeof(data_));
  22   }
  23   virtual ~MockDeviceMotionListener() { }
  24
  25   virtual void didChangeDeviceMotion(
  26       const blink::WebDeviceMotionData& data) override {
  27     memcpy(&data_, &data, sizeof(data));
  28     did_change_device_motion_ = true;
  29     ++number_of_events_;
  30   }
  31
  32   bool did_change_device_motion() const {
  33     return did_change_device_motion_;
  34   }
  35
  36   int number_of_events() const { return number_of_events_; }
  37
  38   const blink::WebDeviceMotionData& data() const {
  39     return data_;
  40   }
  41
  42  private:
  43   bool did_change_device_motion_;
  44   int number_of_events_;
  45   blink::WebDeviceMotionData data_;
  46
  47   DISALLOW_COPY_AND_ASSIGN(MockDeviceMotionListener);
  48 };
  49
  50 class DeviceMotionEventPumpForTesting : public DeviceMotionEventPump {
  51  public:
  52   DeviceMotionEventPumpForTesting()
  53       : DeviceMotionEventPump(0), stop_on_fire_event_(true) {}
  54   ~DeviceMotionEventPumpForTesting() override {}
  55
  56   void set_stop_on_fire_event(bool stop_on_fire_event) {
  57     stop_on_fire_event_ = stop_on_fire_event;
  58   }
  59
  60   bool stop_on_fire_event() { return stop_on_fire_event_; }
  61
  62   int pump_delay_microseconds() const { return pump_delay_microseconds_; }
  63
  64   void OnDidStart(base::SharedMemoryHandle renderer_handle) {
  65     DeviceMotionEventPump::OnDidStart(renderer_handle);
  66   }
  67   void SendStartMessage() override {}
  68   void SendStopMessage() override {}
  69   void FireEvent() override {
  70     DeviceMotionEventPump::FireEvent();
  71     if (stop_on_fire_event_) {
  72       Stop();
  73       base::MessageLoop::current()->QuitWhenIdle();
  74     }
  75   }
  76
  77  private:
  78   bool stop_on_fire_event_;
  79
  80   DISALLOW_COPY_AND_ASSIGN(DeviceMotionEventPumpForTesting);
  81 };
  82
  83 class DeviceMotionEventPumpTest : public testing::Test {
  84  public:
  85   DeviceMotionEventPumpTest() {
  86     EXPECT_TRUE(shared_memory_.CreateAndMapAnonymous(
  87         sizeof(DeviceMotionHardwareBuffer)));
  88   }
  89
  90  protected:
  91   void SetUp() override {
  92     const DeviceMotionHardwareBuffer* null_buffer = nullptr;
  93     listener_.reset(new MockDeviceMotionListener);
  94     motion_pump_.reset(new DeviceMotionEventPumpForTesting);
  95     buffer_ = static_cast<DeviceMotionHardwareBuffer*>(shared_memory_.memory());
  96     ASSERT_NE(null_buffer, buffer_);
  97     memset(buffer_, 0, sizeof(DeviceMotionHardwareBuffer));
  98     ASSERT_TRUE(shared_memory_.ShareToProcess(base::GetCurrentProcessHandle(),
  99         &handle_));
 100   }
 101
 102   void InitBuffer(bool allAvailableSensorsActive) {
 103     blink::WebDeviceMotionData& data = buffer_->data;
 104     data.accelerationX = 1;
 105     data.hasAccelerationX = true;
 106     data.accelerationY = 2;
 107     data.hasAccelerationY = true;
 108     data.accelerationZ = 3;
 109     data.hasAccelerationZ = true;
 110     data.allAvailableSensorsAreActive = allAvailableSensorsActive;
 111   }
 112
 113   MockDeviceMotionListener* listener() { return listener_.get(); }
 114   DeviceMotionEventPumpForTesting* motion_pump() { return motion_pump_.get(); }
 115   base::SharedMemoryHandle handle() { return handle_; }
 116
 117  private:
 118   scoped_ptr<MockDeviceMotionListener> listener_;
 119   scoped_ptr<DeviceMotionEventPumpForTesting> motion_pump_;
 120   base::SharedMemoryHandle handle_;
 121   base::SharedMemory shared_memory_;
 122   DeviceMotionHardwareBuffer* buffer_;
 123
 124   DISALLOW_COPY_AND_ASSIGN(DeviceMotionEventPumpTest);
 125 };
 126
 127 TEST_F(DeviceMotionEventPumpTest, DidStartPolling) {
 128   base::MessageLoopForUI loop;
 129
 130   InitBuffer(true);
 131
 132   motion_pump()->Start(listener());
 133   motion_pump()->OnDidStart(handle());
 134
 135   base::MessageLoop::current()->Run();
 136
 137   const blink::WebDeviceMotionData& received_data = listener()->data();
 138   EXPECT_TRUE(listener()->did_change_device_motion());
 139   EXPECT_TRUE(received_data.hasAccelerationX);
 140   EXPECT_EQ(1, static_cast<double>(received_data.accelerationX));
 141   EXPECT_TRUE(received_data.hasAccelerationX);
 142   EXPECT_EQ(2, static_cast<double>(received_data.accelerationY));
 143   EXPECT_TRUE(received_data.hasAccelerationY);
 144   EXPECT_EQ(3, static_cast<double>(received_data.accelerationZ));
 145   EXPECT_TRUE(received_data.hasAccelerationZ);
 146   EXPECT_FALSE(received_data.hasAccelerationIncludingGravityX);
 147   EXPECT_FALSE(received_data.hasAccelerationIncludingGravityY);
 148   EXPECT_FALSE(received_data.hasAccelerationIncludingGravityZ);
 149   EXPECT_FALSE(received_data.hasRotationRateAlpha);
 150   EXPECT_FALSE(received_data.hasRotationRateBeta);
 151   EXPECT_FALSE(received_data.hasRotationRateGamma);
 152 }
 153
 154 TEST_F(DeviceMotionEventPumpTest, DidStartPollingNotAllSensorsActive) {
 155   base::MessageLoopForUI loop;
 156
 157   InitBuffer(false);
 158
 159   motion_pump()->Start(listener());
 160   motion_pump()->OnDidStart(handle());
 161
 162   base::MessageLoop::current()->Run();
 163
 164   const blink::WebDeviceMotionData& received_data = listener()->data();
 165   // No change in device motion because allAvailableSensorsAreActive is false.
 166   EXPECT_FALSE(listener()->did_change_device_motion());
 167   EXPECT_FALSE(received_data.hasAccelerationX);
 168   EXPECT_FALSE(received_data.hasAccelerationX);
 169   EXPECT_FALSE(received_data.hasAccelerationY);
 170   EXPECT_FALSE(received_data.hasAccelerationZ);
 171   EXPECT_FALSE(received_data.hasAccelerationIncludingGravityX);
 172   EXPECT_FALSE(received_data.hasAccelerationIncludingGravityY);
 173   EXPECT_FALSE(received_data.hasAccelerationIncludingGravityZ);
 174   EXPECT_FALSE(received_data.hasRotationRateAlpha);
 175   EXPECT_FALSE(received_data.hasRotationRateBeta);
 176   EXPECT_FALSE(received_data.hasRotationRateGamma);
 177 }
 178
 179 // Confirm that the frequency of pumping events is not greater than 60Hz. A rate
 180 // above 60Hz would allow for the detection of keystrokes (crbug.com/421691)
 181 TEST_F(DeviceMotionEventPumpTest, PumpThrottlesEventRate) {
 182   // Confirm that the delay for pumping events is 60 Hz.
 183   EXPECT_GE(60, base::Time::kMicrosecondsPerSecond /
 184       motion_pump()->pump_delay_microseconds());
 185
 186   base::MessageLoopForUI loop;
 187
 188   InitBuffer(true);
 189
 190   motion_pump()->set_stop_on_fire_event(false);
 191   motion_pump()->Start(listener());
 192   motion_pump()->OnDidStart(handle());
 193
 194   base::MessageLoop::current()->PostDelayedTask(
 195       FROM_HERE, base::MessageLoop::QuitClosure(),
 196       base::TimeDelta::FromMilliseconds(100));
 197   base::MessageLoop::current()->Run();
 198   motion_pump()->Stop();
 199
 200   // Check that the blink::WebDeviceMotionListener does not receive excess
 201   // events.
 202   EXPECT_TRUE(listener()->did_change_device_motion());
 203   EXPECT_GE(6, listener()->number_of_events());
 204 }
 205
 206 }  // namespace content