Replace usages of device::OrientationData with DeviceOrientationData

Since DeviceOrientationData class has all the information from
device::OrientationData, and DeviceOrientationEventPump is now in blink,
DeviceOrientationData is now passed to DeviceOrientationDispatcher.
device::OrientationData will be removed in a subsequent change.

Bug: 861923
Change-Id: If1cb812502f85dd46011398a54f45bba2353044d
Reviewed-on: https://chromium-review.googlesource.com/1142459Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Tim Volodine <timvolodine@chromium.org>
Commit-Queue: Oksana Zhuravlova <oksamyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#577985}

third_party/blink/public/platform/modules/device_orientation/web_device_orientation_listener.h

@@ -33,16 +33,14 @@
 
 #include "third_party/blink/public/platform/web_platform_event_listener.h"
 
-namespace device {
-class OrientationData;
-}
-
 namespace blink {
 
+class DeviceOrientationData;
+
 class WebDeviceOrientationListener : public WebPlatformEventListener {
  public:
   // This method is called every time new device orientation data is available.
-  virtual void DidChangeDeviceOrientation(const device::OrientationData&) = 0;
+  virtual void DidChangeDeviceOrientation(DeviceOrientationData*) = 0;
 
   ~WebDeviceOrientationListener() override = default;
 };

third_party/blink/renderer/modules/device_orientation/DEPS

 include_rules = [
     "+base/run_loop.h",
     "+mojo/public/cpp/bindings/binding.h",
-
-    # NOTE: These files are POD structs used to interpret shared memory across
-    # the Device Sensors implementation and the Blink client.
-    "+services/device/public/cpp/generic_sensor/orientation_data.h",
-
     "+services/device/public/mojom/sensor.mojom-blink.h",
     "+services/device/public/mojom/sensor_provider.mojom-blink.h",
     "+services/device/public/cpp/test/fake_sensor_and_provider.h",

third_party/blink/renderer/modules/device_orientation/device_orientation_data.cc

@@ -25,7 +25,6 @@
 
 #include "third_party/blink/renderer/modules/device_orientation/device_orientation_data.h"
 
-#include "services/device/public/cpp/generic_sensor/orientation_data.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_orientation_event_init.h"
 
 namespace blink {
@@ -56,20 +55,6 @@ DeviceOrientationData* DeviceOrientationData::Create(
   return DeviceOrientationData::Create(alpha, beta, gamma, init.absolute());
 }
 
-DeviceOrientationData* DeviceOrientationData::Create(
-    const device::OrientationData& data) {
-  base::Optional<double> alpha;
-  base::Optional<double> beta;
-  base::Optional<double> gamma;
-  if (data.has_alpha)
-    alpha = data.alpha;
-  if (data.has_beta)
-    beta = data.beta;
-  if (data.has_gamma)
-    gamma = data.gamma;
-  return DeviceOrientationData::Create(alpha, beta, gamma, data.absolute);
-}
-
 DeviceOrientationData::DeviceOrientationData() : absolute_(false) {}
 
 DeviceOrientationData::DeviceOrientationData(

third_party/blink/renderer/modules/device_orientation/device_orientation_data.h

@@ -30,10 +30,6 @@
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
-namespace device {
-class OrientationData;
-}
-
 namespace blink {
 
 class DeviceOrientationEventInit;
@@ -47,7 +43,6 @@ class MODULES_EXPORT DeviceOrientationData final
                                        const base::Optional<double>& gamma,
                                        bool absolute);
   static DeviceOrientationData* Create(const DeviceOrientationEventInit&);
-  static DeviceOrientationData* Create(const device::OrientationData&);
   void Trace(blink::Visitor* visitor) {}
 
   double Alpha() const;

third_party/blink/renderer/modules/device_orientation/device_orientation_dispatcher.cc

@@ -78,8 +78,8 @@ void DeviceOrientationDispatcher::StopListening() {
 }
 
 void DeviceOrientationDispatcher::DidChangeDeviceOrientation(
-    const device::OrientationData& motion) {
-  last_device_orientation_data_ = DeviceOrientationData::Create(motion);
+    DeviceOrientationData* orientation) {
+  last_device_orientation_data_ = orientation;
   NotifyControllers();
 }
 

third_party/blink/renderer/modules/device_orientation/device_orientation_dispatcher.h

@@ -36,10 +36,6 @@
 #include "third_party/blink/renderer/core/frame/platform_event_dispatcher.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
-namespace device {
-class OrientationData;
-}
-
 namespace blink {
 
 class DeviceOrientationData;
@@ -62,7 +58,7 @@ class DeviceOrientationDispatcher final
   DeviceOrientationData* LatestDeviceOrientationData();
 
   // Inherited from WebDeviceOrientationListener.
-  void DidChangeDeviceOrientation(const device::OrientationData&) override;
+  void DidChangeDeviceOrientation(DeviceOrientationData*) override;
 
   void Trace(blink::Visitor*) override;
 

third_party/blink/renderer/modules/device_orientation/device_orientation_event_pump.cc

@@ -7,30 +7,28 @@
 #include "services/device/public/mojom/sensor.mojom-blink.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_orientation_data.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_orientation_event_pump.h"
 
 namespace {
 
-bool IsAngleDifferentThreshold(bool has_angle1,
-                               double angle1,
-                               bool has_angle2,
-                               double angle2) {
-  if (has_angle1 != has_angle2)
-    return true;
-
-  return (has_angle1 &&
-          std::fabs(angle1 - angle2) >=
-              blink::DeviceOrientationEventPump::kOrientationThreshold);
+bool IsAngleDifferentThreshold(double angle1, double angle2) {
+  return (std::fabs(angle1 - angle2) >=
+          blink::DeviceOrientationEventPump::kOrientationThreshold);
 }
 
-bool IsSignificantlyDifferent(const device::OrientationData& data1,
-                              const device::OrientationData& data2) {
-  return IsAngleDifferentThreshold(data1.has_alpha, data1.alpha,
-                                   data2.has_alpha, data2.alpha) ||
-         IsAngleDifferentThreshold(data1.has_beta, data1.beta, data2.has_beta,
-                                   data2.beta) ||
-         IsAngleDifferentThreshold(data1.has_gamma, data1.gamma,
-                                   data2.has_gamma, data2.gamma);
+bool IsSignificantlyDifferent(const blink::DeviceOrientationData* data1,
+                              const blink::DeviceOrientationData* data2) {
+  if (data1->CanProvideAlpha() != data2->CanProvideAlpha() ||
+      data1->CanProvideBeta() != data2->CanProvideBeta() ||
+      data1->CanProvideGamma() != data2->CanProvideGamma())
+    return true;
+  return (data1->CanProvideAlpha() &&
+          IsAngleDifferentThreshold(data1->Alpha(), data2->Alpha())) ||
+         (data1->CanProvideBeta() &&
+          IsAngleDifferentThreshold(data1->Beta(), data2->Beta())) ||
+         (data1->CanProvideGamma() &&
+          IsAngleDifferentThreshold(data1->Gamma(), data2->Gamma()));
 }
 
 }  // namespace
@@ -105,15 +103,13 @@ void DeviceOrientationEventPump::SendStopMessage() {
   // data when stopping. If we don't reset here as well, then when starting back
   // up we won't notify DeviceOrientationDispatcher of the orientation, since
   // we think it hasn't changed.
-  data_ = device::OrientationData();
+  data_ = nullptr;
 }
 
 void DeviceOrientationEventPump::FireEvent(TimerBase*) {
-  device::OrientationData data;
-
   DCHECK(listener());
 
-  GetDataFromSharedMemory(&data);
+  DeviceOrientationData* data = GetDataFromSharedMemory();
 
   if (ShouldFireEvent(data)) {
     data_ = data;
@@ -152,60 +148,67 @@ bool DeviceOrientationEventPump::SensorsReadyOrErrored() const {
   return true;
 }
 
-void DeviceOrientationEventPump::GetDataFromSharedMemory(
-    device::OrientationData* data) {
-  data->all_available_sensors_are_active = true;
+DeviceOrientationData* DeviceOrientationEventPump::GetDataFromSharedMemory() {
+  base::Optional<double> alpha;
+  base::Optional<double> beta;
+  base::Optional<double> gamma;
+  bool absolute = false;
 
   if (!absolute_ && relative_orientation_sensor_.SensorReadingCouldBeRead()) {
     // For DeviceOrientation Event, this provides relative orientation data.
-    data->all_available_sensors_are_active =
-        relative_orientation_sensor_.reading.timestamp() != 0.0;
-    if (!data->all_available_sensors_are_active)
-      return;
-    data->alpha = relative_orientation_sensor_.reading.orientation_euler.z;
-    data->beta = relative_orientation_sensor_.reading.orientation_euler.x;
-    data->gamma = relative_orientation_sensor_.reading.orientation_euler.y;
-    data->has_alpha = !std::isnan(
-        relative_orientation_sensor_.reading.orientation_euler.z.value());
-    data->has_beta = !std::isnan(
-        relative_orientation_sensor_.reading.orientation_euler.x.value());
-    data->has_gamma = !std::isnan(
-        relative_orientation_sensor_.reading.orientation_euler.y.value());
-    data->absolute = false;
+    if (relative_orientation_sensor_.reading.timestamp() == 0.0)
+      return nullptr;
+
+    if (!std::isnan(
+            relative_orientation_sensor_.reading.orientation_euler.z.value()))
+      alpha = relative_orientation_sensor_.reading.orientation_euler.z;
+
+    if (!std::isnan(
+            relative_orientation_sensor_.reading.orientation_euler.x.value()))
+      beta = relative_orientation_sensor_.reading.orientation_euler.x;
+
+    if (!std::isnan(
+            relative_orientation_sensor_.reading.orientation_euler.y.value()))
+      gamma = relative_orientation_sensor_.reading.orientation_euler.y;
   } else if (absolute_orientation_sensor_.SensorReadingCouldBeRead()) {
     // For DeviceOrientationAbsolute Event, this provides absolute orientation
     // data.
     //
     // For DeviceOrientation Event, this provides absolute orientation data if
     // relative orientation data is not available.
-    data->all_available_sensors_are_active =
-        absolute_orientation_sensor_.reading.timestamp() != 0.0;
-    if (!data->all_available_sensors_are_active)
-      return;
-    data->alpha = absolute_orientation_sensor_.reading.orientation_euler.z;
-    data->beta = absolute_orientation_sensor_.reading.orientation_euler.x;
-    data->gamma = absolute_orientation_sensor_.reading.orientation_euler.y;
-    data->has_alpha = !std::isnan(
-        absolute_orientation_sensor_.reading.orientation_euler.z.value());
-    data->has_beta = !std::isnan(
-        absolute_orientation_sensor_.reading.orientation_euler.x.value());
-    data->has_gamma = !std::isnan(
-        absolute_orientation_sensor_.reading.orientation_euler.y.value());
-    data->absolute = true;
+    if (absolute_orientation_sensor_.reading.timestamp() == 0.0)
+      return nullptr;
+
+    if (!std::isnan(
+            absolute_orientation_sensor_.reading.orientation_euler.z.value()))
+      alpha = absolute_orientation_sensor_.reading.orientation_euler.z;
+
+    if (!std::isnan(
+            absolute_orientation_sensor_.reading.orientation_euler.x.value()))
+      beta = absolute_orientation_sensor_.reading.orientation_euler.x;
+
+    if (!std::isnan(
+            absolute_orientation_sensor_.reading.orientation_euler.y.value()))
+      gamma = absolute_orientation_sensor_.reading.orientation_euler.y;
+
+    absolute = true;
   } else {
-    data->absolute = absolute_;
+    absolute = absolute_;
   }
+
+  return DeviceOrientationData::Create(alpha, beta, gamma, absolute);
 }
 
 bool DeviceOrientationEventPump::ShouldFireEvent(
-    const device::OrientationData& data) const {
-  if (!data.all_available_sensors_are_active)
+    const DeviceOrientationData* data) const {
+  // |data| is null if not all sensors are active
+  if (!data)
     return false;
 
-  if (!data.has_alpha && !data.has_beta && !data.has_gamma) {
-    // no data can be provided, this is an all-null event.
+  // when the state changes from not having data to having data,
+  // the event should be fired
+  if (!data_)
     return true;
-  }
 
   return IsSignificantlyDifferent(data_, data);
 }

third_party/blink/renderer/modules/device_orientation/device_orientation_event_pump.h

@@ -6,7 +6,6 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_DEVICE_ORIENTATION_DEVICE_ORIENTATION_EVENT_PUMP_H_
 
 #include "base/macros.h"
-#include "services/device/public/cpp/generic_sensor/orientation_data.h"
 #include "third_party/blink/public/platform/modules/device_orientation/web_device_orientation_listener.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_sensor_event_pump.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
@@ -44,14 +43,14 @@ class MODULES_EXPORT DeviceOrientationEventPump
   // DeviceSensorEventPump:
   bool SensorsReadyOrErrored() const override;
 
-  void GetDataFromSharedMemory(device::OrientationData* data);
+  DeviceOrientationData* GetDataFromSharedMemory();
 
-  bool ShouldFireEvent(const device::OrientationData& data) const;
+  bool ShouldFireEvent(const DeviceOrientationData* data) const;
 
   bool absolute_;
   bool fall_back_to_absolute_orientation_sensor_;
   bool should_suspend_absolute_orientation_sensor_ = false;
-  device::OrientationData data_;
+  Persistent<DeviceOrientationData> data_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceOrientationEventPump);
 };

third_party/blink/renderer/modules/device_orientation/device_orientation_event_pump_unittest.cc

@@ -7,12 +7,13 @@
 #include <memory>
 
 #include "base/run_loop.h"
-#include "services/device/public/cpp/generic_sensor/orientation_data.h"
 #include "services/device/public/cpp/test/fake_sensor_and_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/modules/device_orientation/web_device_orientation_listener.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_orientation_data.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_orientation_event_pump.h"
+#include "third_party/blink/renderer/platform/heap/persistent.h"
 
 namespace {
 
@@ -28,13 +29,12 @@ class MockDeviceOrientationListener
     : public blink::WebDeviceOrientationListener {
  public:
   MockDeviceOrientationListener() : did_change_device_orientation_(false) {
-    memset(&data_, 0, sizeof(data_));
+    data_ = DeviceOrientationData::Create();
   }
   ~MockDeviceOrientationListener() override {}
 
-  void DidChangeDeviceOrientation(
-      const device::OrientationData& data) override {
-    memcpy(&data_, &data, sizeof(data));
+  void DidChangeDeviceOrientation(DeviceOrientationData* data) override {
+    data_ = data;
     did_change_device_orientation_ = true;
   }
 
@@ -44,11 +44,11 @@ class MockDeviceOrientationListener
   void set_did_change_device_orientation(bool value) {
     did_change_device_orientation_ = value;
   }
-  const device::OrientationData& data() const { return data_; }
+  const DeviceOrientationData* data() const { return data_.Get(); }
 
  private:
   bool did_change_device_orientation_;
-  device::OrientationData data_;
+  Persistent<DeviceOrientationData> data_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDeviceOrientationListener);
 };
@@ -343,18 +343,18 @@ TEST_F(DeviceOrientationEventPumpTest, SensorIsActive) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
   // DeviceOrientation Event provides relative orientation data when it is
   // available.
-  EXPECT_DOUBLE_EQ(1, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(2, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(3, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_FALSE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(1, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(2, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(3, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_FALSE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -378,21 +378,22 @@ TEST_F(DeviceOrientationEventPumpTest, SensorIsActiveWithSensorFallback) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
   // DeviceOrientation Event provides absolute orientation data when relative
   // orientation data is not available but absolute orientation data is
   // available.
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(5, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(5, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+
   // Since no relative orientation data is available, DeviceOrientationEvent
   // fallback to provide absolute orientation data.
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_TRUE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -414,15 +415,15 @@ TEST_F(DeviceOrientationEventPumpTest, SomeSensorDataFieldsNotAvailable) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_FALSE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(2, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(3, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_FALSE(received_data.absolute);
+  EXPECT_FALSE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(2, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(3, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_FALSE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -447,20 +448,20 @@ TEST_F(DeviceOrientationEventPumpTest,
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
   // DeviceOrientation Event provides absolute orientation data when relative
   // orientation data is not available but absolute orientation data is
   // available.
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_FALSE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_FALSE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
   // Since no relative orientation data is available, DeviceOrientationEvent
   // fallback to provide absolute orientation data.
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_TRUE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -485,13 +486,13 @@ TEST_F(DeviceOrientationEventPumpTest, FireAllNullEvent) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_FALSE(received_data.has_alpha);
-  EXPECT_FALSE(received_data.has_beta);
-  EXPECT_FALSE(received_data.has_gamma);
-  EXPECT_FALSE(received_data.absolute);
+  EXPECT_FALSE(received_data->CanProvideAlpha());
+  EXPECT_FALSE(received_data->CanProvideBeta());
+  EXPECT_FALSE(received_data->CanProvideGamma());
+  EXPECT_FALSE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -555,18 +556,18 @@ TEST_F(DeviceOrientationEventPumpTest, UpdateRespectsOrientationThreshold) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
   // DeviceOrientation Event provides relative orientation data when it is
   // available.
-  EXPECT_DOUBLE_EQ(1, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(2, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(3, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_FALSE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(1, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(2, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(3, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_FALSE(received_data->Absolute());
 
   listener()->set_did_change_device_orientation(false);
 
@@ -579,13 +580,13 @@ TEST_F(DeviceOrientationEventPumpTest, UpdateRespectsOrientationThreshold) {
   received_data = listener()->data();
   EXPECT_FALSE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(1, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(2, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(3, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_FALSE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(1, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(2, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(3, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_FALSE(received_data->Absolute());
 
   listener()->set_did_change_device_orientation(false);
 
@@ -599,13 +600,13 @@ TEST_F(DeviceOrientationEventPumpTest, UpdateRespectsOrientationThreshold) {
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
   EXPECT_DOUBLE_EQ(1 + DeviceOrientationEventPump::kOrientationThreshold,
-                   received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(2, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(3, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_FALSE(received_data.absolute);
+                   received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(2, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(3, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_FALSE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -630,21 +631,21 @@ TEST_F(DeviceOrientationEventPumpTest,
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
   // DeviceOrientation Event provides absolute orientation data when relative
   // orientation data is not available but absolute orientation data is
   // available.
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(5, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(5, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
   // Since no relative orientation data is available, DeviceOrientationEvent
   // fallback to provide absolute orientation data.
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_TRUE(received_data->Absolute());
 
   listener()->set_did_change_device_orientation(false);
 
@@ -658,13 +659,13 @@ TEST_F(DeviceOrientationEventPumpTest,
   received_data = listener()->data();
   EXPECT_FALSE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(5, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(5, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   listener()->set_did_change_device_orientation(false);
 
@@ -679,15 +680,15 @@ TEST_F(DeviceOrientationEventPumpTest,
   received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
   EXPECT_DOUBLE_EQ(
       5 + DeviceOrientationEventPump::kOrientationThreshold + kEpsilon,
-      received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+      received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   orientation_pump()->Stop();
 
@@ -845,16 +846,16 @@ TEST_F(DeviceAbsoluteOrientationEventPumpTest, SensorIsActive) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(5, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(5, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   absolute_orientation_pump()->Stop();
 
@@ -875,15 +876,15 @@ TEST_F(DeviceAbsoluteOrientationEventPumpTest,
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_FALSE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_FALSE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   absolute_orientation_pump()->Stop();
 
@@ -903,13 +904,13 @@ TEST_F(DeviceAbsoluteOrientationEventPumpTest, FireAllNullEvent) {
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_FALSE(received_data.has_alpha);
-  EXPECT_FALSE(received_data.has_beta);
-  EXPECT_FALSE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_FALSE(received_data->CanProvideAlpha());
+  EXPECT_FALSE(received_data->CanProvideBeta());
+  EXPECT_FALSE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   absolute_orientation_pump()->Stop();
 
@@ -948,16 +949,16 @@ TEST_F(DeviceAbsoluteOrientationEventPumpTest,
 
   FireEvent();
 
-  device::OrientationData received_data = listener()->data();
+  const DeviceOrientationData* received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(5, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(5, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   listener()->set_did_change_device_orientation(false);
 
@@ -971,13 +972,13 @@ TEST_F(DeviceAbsoluteOrientationEventPumpTest,
   received_data = listener()->data();
   EXPECT_FALSE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
-  EXPECT_DOUBLE_EQ(5, received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
+  EXPECT_DOUBLE_EQ(5, received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   listener()->set_did_change_device_orientation(false);
 
@@ -992,15 +993,15 @@ TEST_F(DeviceAbsoluteOrientationEventPumpTest,
   received_data = listener()->data();
   EXPECT_TRUE(listener()->did_change_device_orientation());
 
-  EXPECT_DOUBLE_EQ(4, received_data.alpha);
-  EXPECT_TRUE(received_data.has_alpha);
+  EXPECT_DOUBLE_EQ(4, received_data->Alpha());
+  EXPECT_TRUE(received_data->CanProvideAlpha());
   EXPECT_DOUBLE_EQ(
       5 + DeviceOrientationEventPump::kOrientationThreshold + kEpsilon,
-      received_data.beta);
-  EXPECT_TRUE(received_data.has_beta);
-  EXPECT_DOUBLE_EQ(6, received_data.gamma);
-  EXPECT_TRUE(received_data.has_gamma);
-  EXPECT_TRUE(received_data.absolute);
+      received_data->Beta());
+  EXPECT_TRUE(received_data->CanProvideBeta());
+  EXPECT_DOUBLE_EQ(6, received_data->Gamma());
+  EXPECT_TRUE(received_data->CanProvideGamma());
+  EXPECT_TRUE(received_data->Absolute());
 
   absolute_orientation_pump()->Stop();