Device Orientation API on Chrome OS

content/browser/device_sensors/sensor_manager_chromeos_unittest.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/device_sensors/sensor_manager_chromeos.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "content/common/device_sensors/device_orientation_hardware_buffer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/accelerometer/accelerometer_types.h"
+
+namespace {
+const double kMeanGravity = 9.80665;
+}  // namespace
+
+namespace content {
+
+class SensorManagerChromeOSTest : public testing::Test {
+ public:
+  SensorManagerChromeOSTest() {
+    orientation_buffer_.reset(new DeviceOrientationHardwareBuffer);
+  }
+
+  virtual ~SensorManagerChromeOSTest() {}
+
+  void OnAccelerationIncludingGravity(double x, double y, double z) {
+    ui::AccelerometerUpdate update;
+    update.Set(ui::ACCELEROMETER_SOURCE_SCREEN, x, y, z);
+    sensor_manager_->OnAccelerometerUpdated(update);
+  }
+
+  DeviceOrientationHardwareBuffer* orientation_buffer() {
+    return orientation_buffer_.get();
+  }
+
+  SensorManagerChromeOS* sensor_manager() { return sensor_manager_.get(); }
+
+  // testing::Test:
+  void SetUp() override {
+    testing::Test::SetUp();
+    sensor_manager_.reset(new SensorManagerChromeOS);

[timvolodine, 2015/01/21 13:16:57]

you are using a real implementation here? does this actually hook into chromeOS?
I would expect a fake sensor manager but maybe I am missing something..

[jonross, 2015/01/21 16:02:11]

I am testing a real sensor manager here. However in unittests there is nothing
generating accelerometer events, so the only tie to chromeos/accelerometer is
the adding/removing of the observer.

Accelerometer events are injected via OnAccelerationIncludingGravity (line 26).
Thus bypassing the chromeos/accelerometer and letting me just test the results
of SensorManagerChromeOS handling data.

[timvolodine, 2015/01/21 19:08:21]

It seems you are relying on AccelerometerReader::Initialize not being called
during unit testing and that feels dangerous to me. Also this is a unit test not
an integration test. I think it is better to provide a fake manager where the
calls to AccelerometerReader are mocked out/replaced by something else.

+    sensor_manager_->StartFetchingDeviceOrientationData(
+        orientation_buffer_.get());
+  }
+
+  void TearDown() override {
+    sensor_manager_->StopFetchingDeviceOrientationData();
+    testing::Test::TearDown();
+  }
+
+ private:
+  scoped_ptr<SensorManagerChromeOS> sensor_manager_;
+
+  scoped_ptr<DeviceOrientationHardwareBuffer> orientation_buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(SensorManagerChromeOSTest);
+};
+
+// Tests that starting to process orientation data will update the associated
+// buffer.
+TEST_F(SensorManagerChromeOSTest, OrientationBuffer) {
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_TRUE(buffer->data.hasAbsolute);
+  EXPECT_FALSE(buffer->data.hasAlpha);
+  EXPECT_FALSE(buffer->data.hasBeta);
+  EXPECT_FALSE(buffer->data.hasGamma);
+  EXPECT_FALSE(buffer->data.allAvailableSensorsAreActive);
+
+  OnAccelerationIncludingGravity(0.0f, 0.0f, 1.0f);
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.alpha);
+  EXPECT_FALSE(buffer->data.hasAlpha);
+  EXPECT_TRUE(buffer->data.hasBeta);
+  EXPECT_TRUE(buffer->data.hasGamma);
+  EXPECT_TRUE(buffer->data.allAvailableSensorsAreActive);
+
+  sensor_manager()->StopFetchingDeviceOrientationData();
+  EXPECT_FALSE(buffer->data.allAvailableSensorsAreActive);
+}
+
+// Tests a device resting flat.
+TEST_F(SensorManagerChromeOSTest, NeutralOrientation) {
+  OnAccelerationIncludingGravity(0.0f, 0.0f, -kMeanGravity);
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.beta);
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.gamma);
+}
+
+// Tests an upside-down device, such that the W3C boundary [-180,180) causes the
+// beta value to become negative.
+TEST_F(SensorManagerChromeOSTest, UpsideDown) {
+  OnAccelerationIncludingGravity(0.0f, 0.0f, kMeanGravity);
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_FLOAT_EQ(-180.0f, buffer->data.beta);
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.gamma);
+}
+
+// Tests for positive beta value before the device is completely upside-down
+TEST_F(SensorManagerChromeOSTest, BeforeUpsideDownBoundary) {
+  OnAccelerationIncludingGravity(0.0f, -kMeanGravity / 2.0f,
+                                 kMeanGravity / 2.0f);
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_FLOAT_EQ(135.0f, buffer->data.beta);
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.gamma);
+}
+
+// Tests a device lying on its left-edge.
+TEST_F(SensorManagerChromeOSTest, LeftEdge) {
+  OnAccelerationIncludingGravity(-kMeanGravity, 0.0f, 0.0f);
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.beta);
+  EXPECT_FLOAT_EQ(-90.0f, buffer->data.gamma);
+}
+
+// Tests a device lying on its right-edge, such that the W3C boundary [-90,90)
+// causes the gamma value to become negative.
+TEST_F(SensorManagerChromeOSTest, RightEdge) {
+  OnAccelerationIncludingGravity(kMeanGravity, 0.0f, 0.0f);
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.beta);
+  EXPECT_FLOAT_EQ(-90.0f, buffer->data.gamma);
+}
+
+// Tests for positive gamma value before the device is completely on its right
+// side.
+TEST_F(SensorManagerChromeOSTest, BeforeRightEdgeBoundary) {
+  OnAccelerationIncludingGravity(kMeanGravity / 2.0f, 0.0f,
+                                 -kMeanGravity / 2.0f);
+  DeviceOrientationHardwareBuffer* buffer = orientation_buffer();
+  EXPECT_FLOAT_EQ(0.0f, buffer->data.beta);
+  EXPECT_FLOAT_EQ(45.0f, buffer->data.gamma);
+}
+
+}  // namespace content