Refactor motion data in device orientation

removed acceleration and rotation rate class from device motion data and put all the logic into device_acceleration and device_rotation_data class

Change-Id: If54ad00321f4fe14be4468ed3d01291af4d6c783
Reviewed-on: https://chromium-review.googlesource.com/c/1320589Reviewed-by: Tim Volodine <timvolodine@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Commit-Queue: James Hollyer <jameshollyer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#608227}

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

@@ -24,40 +24,42 @@
  */
 
 #include "third_party/blink/renderer/modules/device_orientation/device_acceleration.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_acceleration_init.h"
 
 namespace blink {
 
-DeviceAcceleration::DeviceAcceleration(
-    DeviceMotionData::Acceleration* acceleration)
-    : acceleration_(acceleration) {}
+DeviceAcceleration* DeviceAcceleration::Create(double x, double y, double z) {
+  return new DeviceAcceleration(x, y, z);
+}
 
-void DeviceAcceleration::Trace(blink::Visitor* visitor) {
-  visitor->Trace(acceleration_);
-  ScriptWrappable::Trace(visitor);
+DeviceAcceleration* DeviceAcceleration::Create(
+    const DeviceAccelerationInit* init) {
+  double x = init->hasX() ? init->x() : NAN;
+  double y = init->hasY() ? init->y() : NAN;
+  double z = init->hasZ() ? init->z() : NAN;
+  return DeviceAcceleration::Create(x, y, z);
 }
 
-double DeviceAcceleration::x(bool& is_null) const {
-  if (acceleration_->CanProvideX())
-    return acceleration_->X();
+DeviceAcceleration::DeviceAcceleration(double x, double y, double z)
+    : x_(x), y_(y), z_(z) {}
 
-  is_null = true;
-  return 0;
+bool DeviceAcceleration::HasAccelerationData() const {
+  return !std::isnan(x_) || !std::isnan(y_) || !std::isnan(z_);
 }
 
-double DeviceAcceleration::y(bool& is_null) const {
-  if (acceleration_->CanProvideY())
-    return acceleration_->Y();
+double DeviceAcceleration::x(bool& is_null) const {
+  is_null = std::isnan(x_);
+  return x_;
+}
 
-  is_null = true;
-  return 0;
+double DeviceAcceleration::y(bool& is_null) const {
+  is_null = std::isnan(y_);
+  return y_;
 }
 
 double DeviceAcceleration::z(bool& is_null) const {
-  if (acceleration_->CanProvideZ())
-    return acceleration_->Z();
-
-  is_null = true;
-  return 0;
+  is_null = std::isnan(z_);
+  return z_;
 }
 
 }  // namespace blink

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

@@ -27,29 +27,33 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_DEVICE_ORIENTATION_DEVICE_ACCELERATION_H_
 
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_data.h"
+#include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
 namespace blink {
 
-class DeviceAcceleration final : public ScriptWrappable {
+class DeviceAccelerationInit;
+
+class MODULES_EXPORT DeviceAcceleration final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static DeviceAcceleration* Create(
-      DeviceMotionData::Acceleration* acceleration) {
-    return new DeviceAcceleration(acceleration);
-  }
-  void Trace(blink::Visitor*) override;
+  static DeviceAcceleration* Create(double x, double y, double z);
+  static DeviceAcceleration* Create(const DeviceAccelerationInit*);
+
+  bool HasAccelerationData() const;
 
   double x(bool& is_null) const;
   double y(bool& is_null) const;
   double z(bool& is_null) const;
 
  private:
-  explicit DeviceAcceleration(DeviceMotionData::Acceleration*);
+  DeviceAcceleration(double x, double y, double z);
 
-  Member<DeviceMotionData::Acceleration> acceleration_;
+  const double x_;
+  const double y_;
+  const double z_;
 };
 
 }  // namespace blink

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

@@ -24,87 +24,18 @@
  */
 
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_data.h"
-
+#include "third_party/blink/renderer/modules/device_orientation/device_acceleration.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_acceleration_init.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_event_init.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_rotation_rate.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_rotation_rate_init.h"
 
 namespace blink {
 
-DeviceMotionData::Acceleration* DeviceMotionData::Acceleration::Create(
-    bool can_provide_x,
-    double x,
-    bool can_provide_y,
-    double y,
-    bool can_provide_z,
-    double z) {
-  return new DeviceMotionData::Acceleration(can_provide_x, x, can_provide_y, y,
-                                            can_provide_z, z);
-}
-
-DeviceMotionData::Acceleration* DeviceMotionData::Acceleration::Create(
-    const DeviceAccelerationInit* init) {
-  return new DeviceMotionData::Acceleration(
-      init->hasX(), init->hasX() ? init->x() : 0, init->hasY(),
-      init->hasY() ? init->y() : 0, init->hasZ(), init->hasZ() ? init->z() : 0);
-}
-
-DeviceMotionData::Acceleration::Acceleration(bool can_provide_x,
-                                             double x,
-                                             bool can_provide_y,
-                                             double y,
-                                             bool can_provide_z,
-                                             double z)
-    : x_(x),
-      y_(y),
-      z_(z),
-      can_provide_x_(can_provide_x),
-      can_provide_y_(can_provide_y),
-      can_provide_z_(can_provide_z)
-
-{}
-
-DeviceMotionData::RotationRate* DeviceMotionData::RotationRate::Create(
-    bool can_provide_alpha,
-    double alpha,
-    bool can_provide_beta,
-    double beta,
-    bool can_provide_gamma,
-    double gamma) {
-  return new DeviceMotionData::RotationRate(can_provide_alpha, alpha,
-                                            can_provide_beta, beta,
-                                            can_provide_gamma, gamma);
-}
-
-DeviceMotionData::RotationRate* DeviceMotionData::RotationRate::Create(
-    const DeviceRotationRateInit* init) {
-  return new DeviceMotionData::RotationRate(
-      init->hasAlpha(), init->hasAlpha() ? init->alpha() : 0, init->hasBeta(),
-      init->hasBeta() ? init->beta() : 0, init->hasGamma(),
-      init->hasGamma() ? init->gamma() : 0);
-}
-
-DeviceMotionData::RotationRate::RotationRate(bool can_provide_alpha,
-                                             double alpha,
-                                             bool can_provide_beta,
-                                             double beta,
-                                             bool can_provide_gamma,
-                                             double gamma)
-    : alpha_(alpha),
-      beta_(beta),
-      gamma_(gamma),
-      can_provide_alpha_(can_provide_alpha),
-      can_provide_beta_(can_provide_beta),
-      can_provide_gamma_(can_provide_gamma) {}
-
-DeviceMotionData* DeviceMotionData::Create() {
-  return new DeviceMotionData;
-}
-
 DeviceMotionData* DeviceMotionData::Create(
-    Acceleration* acceleration,
-    Acceleration* acceleration_including_gravity,
-    RotationRate* rotation_rate,
+    DeviceAcceleration* acceleration,
+    DeviceAcceleration* acceleration_including_gravity,
+    DeviceRotationRate* rotation_rate,
     double interval) {
   return new DeviceMotionData(acceleration, acceleration_including_gravity,
                               rotation_rate, interval);
@@ -112,25 +43,27 @@ DeviceMotionData* DeviceMotionData::Create(
 
 DeviceMotionData* DeviceMotionData::Create(const DeviceMotionEventInit* init) {
   return DeviceMotionData::Create(
-      init->hasAcceleration()
-          ? DeviceMotionData::Acceleration::Create(init->acceleration())
-          : nullptr,
+      init->hasAcceleration() ? DeviceAcceleration::Create(init->acceleration())
+                              : nullptr,
       init->hasAccelerationIncludingGravity()
-          ? DeviceMotionData::Acceleration::Create(
-                init->accelerationIncludingGravity())
-          : nullptr,
-      init->hasRotationRate()
-          ? DeviceMotionData::RotationRate::Create(init->rotationRate())
+          ? DeviceAcceleration::Create(init->accelerationIncludingGravity())
           : nullptr,
+      init->hasRotationRate() ? DeviceRotationRate::Create(init->rotationRate())
+                              : nullptr,
       init->interval());
 }
 
+DeviceMotionData* DeviceMotionData::Create() {
+  return new DeviceMotionData;
+}
+
 DeviceMotionData::DeviceMotionData() : interval_(0) {}
 
-DeviceMotionData::DeviceMotionData(Acceleration* acceleration,
-                                   Acceleration* acceleration_including_gravity,
-                                   RotationRate* rotation_rate,
-                                   double interval)
+DeviceMotionData::DeviceMotionData(
+    DeviceAcceleration* acceleration,
+    DeviceAcceleration* acceleration_including_gravity,
+    DeviceRotationRate* rotation_rate,
+    double interval)
     : acceleration_(acceleration),
       acceleration_including_gravity_(acceleration_including_gravity),
       rotation_rate_(rotation_rate),
@@ -144,18 +77,12 @@ void DeviceMotionData::Trace(blink::Visitor* visitor) {
 
 bool DeviceMotionData::CanProvideEventData() const {
   const bool has_acceleration =
-      acceleration_ &&
-      (acceleration_->CanProvideX() || acceleration_->CanProvideY() ||
-       acceleration_->CanProvideZ());
+      acceleration_ && acceleration_->HasAccelerationData();
   const bool has_acceleration_including_gravity =
       acceleration_including_gravity_ &&
-      (acceleration_including_gravity_->CanProvideX() ||
-       acceleration_including_gravity_->CanProvideY() ||
-       acceleration_including_gravity_->CanProvideZ());
+      acceleration_including_gravity_->HasAccelerationData();
   const bool has_rotation_rate =
-      rotation_rate_ &&
-      (rotation_rate_->CanProvideAlpha() || rotation_rate_->CanProvideBeta() ||
-       rotation_rate_->CanProvideGamma());
+      rotation_rate_ && rotation_rate_->HasRotationData();
 
   return has_acceleration || has_acceleration_including_gravity ||
          has_rotation_rate;

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

@@ -31,100 +31,27 @@
 
 namespace blink {
 
-class DeviceAccelerationInit;
+class DeviceAcceleration;
+class DeviceRotationRate;
 class DeviceMotionEventInit;
-class DeviceRotationRateInit;
 
 class MODULES_EXPORT DeviceMotionData final
     : public GarbageCollected<DeviceMotionData> {
  public:
-  class Acceleration final
-      : public GarbageCollected<DeviceMotionData::Acceleration> {
-   public:
-    static Acceleration* Create(bool can_provide_x,
-                                double x,
-                                bool can_provide_y,
-                                double y,
-                                bool can_provide_z,
-                                double z);
-    static Acceleration* Create(const DeviceAccelerationInit*);
-    void Trace(blink::Visitor* visitor) {}
-
-    bool CanProvideX() const { return can_provide_x_; }
-    bool CanProvideY() const { return can_provide_y_; }
-    bool CanProvideZ() const { return can_provide_z_; }
-
-    double X() const { return x_; }
-    double Y() const { return y_; }
-    double Z() const { return z_; }
-
-   private:
-    Acceleration(bool can_provide_x,
-                 double x,
-                 bool can_provide_y,
-                 double y,
-                 bool can_provide_z,
-                 double z);
-
-    double x_;
-    double y_;
-    double z_;
-
-    bool can_provide_x_;
-    bool can_provide_y_;
-    bool can_provide_z_;
-  };
-
-  class RotationRate final
-      : public GarbageCollected<DeviceMotionData::RotationRate> {
-   public:
-    static RotationRate* Create(bool can_provide_alpha,
-                                double alpha,
-                                bool can_provide_beta,
-                                double beta,
-                                bool can_provide_gamma,
-                                double gamma);
-    static RotationRate* Create(const DeviceRotationRateInit*);
-    void Trace(blink::Visitor* visitor) {}
-
-    bool CanProvideAlpha() const { return can_provide_alpha_; }
-    bool CanProvideBeta() const { return can_provide_beta_; }
-    bool CanProvideGamma() const { return can_provide_gamma_; }
-
-    double Alpha() const { return alpha_; }
-    double Beta() const { return beta_; }
-    double Gamma() const { return gamma_; }
-
-   private:
-    RotationRate(bool can_provide_alpha,
-                 double alpha,
-                 bool can_provide_beta,
-                 double beta,
-                 bool can_provide_gamma,
-                 double gamma);
-
-    double alpha_;
-    double beta_;
-    double gamma_;
-
-    bool can_provide_alpha_;
-    bool can_provide_beta_;
-    bool can_provide_gamma_;
-  };
-
   static DeviceMotionData* Create();
-  static DeviceMotionData* Create(Acceleration*,
-                                  Acceleration* acceleration_including_gravity,
-                                  RotationRate*,
-                                  double interval);
+  static DeviceMotionData* Create(
+      DeviceAcceleration*,
+      DeviceAcceleration* acceleration_including_gravity,
+      DeviceRotationRate*,
+      double interval);
   static DeviceMotionData* Create(const DeviceMotionEventInit*);
   void Trace(blink::Visitor*);
 
-  Acceleration* GetAcceleration() const { return acceleration_.Get(); }
-  Acceleration* GetAccelerationIncludingGravity() const {
+  DeviceAcceleration* GetAcceleration() const { return acceleration_.Get(); }
+  DeviceAcceleration* GetAccelerationIncludingGravity() const {
     return acceleration_including_gravity_.Get();
   }
-  RotationRate* GetRotationRate() const { return rotation_rate_.Get(); }
+  DeviceRotationRate* GetRotationRate() const { return rotation_rate_.Get(); }
 
   double Interval() const { return interval_; }
 
@@ -132,14 +59,14 @@ class MODULES_EXPORT DeviceMotionData final
 
  private:
   DeviceMotionData();
-  DeviceMotionData(Acceleration*,
-                   Acceleration* acceleration_including_gravity,
-                   RotationRate*,
+  DeviceMotionData(DeviceAcceleration*,
+                   DeviceAcceleration* acceleration_including_gravity,
+                   DeviceRotationRate*,
                    double interval);
 
-  Member<Acceleration> acceleration_;
-  Member<Acceleration> acceleration_including_gravity_;
-  Member<RotationRate> rotation_rate_;
+  Member<DeviceAcceleration> acceleration_;
+  Member<DeviceAcceleration> acceleration_including_gravity_;
+  Member<DeviceRotationRate> rotation_rate_;
   double interval_;
 };
 

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

@@ -48,36 +48,15 @@ DeviceMotionEvent::DeviceMotionEvent(const AtomicString& event_type,
       device_motion_data_(device_motion_data) {}
 
 DeviceAcceleration* DeviceMotionEvent::acceleration() {
-  if (!device_motion_data_->GetAcceleration())
-    return nullptr;
-
-  if (!acceleration_)
-    acceleration_ =
-        DeviceAcceleration::Create(device_motion_data_->GetAcceleration());
-
-  return acceleration_.Get();
+  return device_motion_data_->GetAcceleration();
 }
 
 DeviceAcceleration* DeviceMotionEvent::accelerationIncludingGravity() {
-  if (!device_motion_data_->GetAccelerationIncludingGravity())
-    return nullptr;
-
-  if (!acceleration_including_gravity_)
-    acceleration_including_gravity_ = DeviceAcceleration::Create(
-        device_motion_data_->GetAccelerationIncludingGravity());
-
-  return acceleration_including_gravity_.Get();
+  return device_motion_data_->GetAccelerationIncludingGravity();
 }
 
 DeviceRotationRate* DeviceMotionEvent::rotationRate() {
-  if (!device_motion_data_->GetRotationRate())
-    return nullptr;
-
-  if (!rotation_rate_)
-    rotation_rate_ =
-        DeviceRotationRate::Create(device_motion_data_->GetRotationRate());
-
-  return rotation_rate_.Get();
+  return device_motion_data_->GetRotationRate();
 }
 
 double DeviceMotionEvent::interval() const {
@@ -90,9 +69,6 @@ const AtomicString& DeviceMotionEvent::InterfaceName() const {
 
 void DeviceMotionEvent::Trace(blink::Visitor* visitor) {
   visitor->Trace(device_motion_data_);
-  visitor->Trace(acceleration_);
-  visitor->Trace(acceleration_including_gravity_);
-  visitor->Trace(rotation_rate_);
   Event::Trace(visitor);
 }
 

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

@@ -70,9 +70,6 @@ class DeviceMotionEvent final : public Event {
   DeviceMotionEvent(const AtomicString& event_type, const DeviceMotionData*);
 
   Member<const DeviceMotionData> device_motion_data_;
-  Member<DeviceAcceleration> acceleration_;
-  Member<DeviceAcceleration> acceleration_including_gravity_;
-  Member<DeviceRotationRate> rotation_rate_;
 };
 
 DEFINE_TYPE_CASTS(DeviceMotionEvent,

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

@@ -10,8 +10,10 @@
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/platform_event_controller.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_acceleration.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_data.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_event_pump.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_rotation_rate.h"
 #include "ui/gfx/geometry/angle_conversions.h"
 
 namespace {
@@ -121,56 +123,43 @@ bool DeviceMotionEventPump::SensorsReadyOrErrored() const {
 }
 
 DeviceMotionData* DeviceMotionEventPump::GetDataFromSharedMemory() {
-  DeviceMotionData::Acceleration* acceleration = nullptr;
-  DeviceMotionData::Acceleration* acceleration_including_gravity = nullptr;
-  DeviceMotionData::RotationRate* rotation_rate = nullptr;
+  DeviceAcceleration* acceleration = nullptr;
+  DeviceAcceleration* acceleration_including_gravity = nullptr;
+  DeviceRotationRate* rotation_rate = nullptr;
 
   if (accelerometer_.SensorReadingCouldBeRead()) {
     if (accelerometer_.reading.timestamp() == 0.0)
       return nullptr;
 
-    acceleration_including_gravity = DeviceMotionData::Acceleration::Create(
-        !std::isnan(accelerometer_.reading.accel.x.value()),
-        accelerometer_.reading.accel.x,
-        !std::isnan(accelerometer_.reading.accel.y.value()),
-        accelerometer_.reading.accel.y,
-        !std::isnan(accelerometer_.reading.accel.z.value()),
+    acceleration_including_gravity = DeviceAcceleration::Create(
+        accelerometer_.reading.accel.x, accelerometer_.reading.accel.y,
         accelerometer_.reading.accel.z);
   } else {
-    acceleration_including_gravity = DeviceMotionData::Acceleration::Create(
-        false, 0.0, false, 0.0, false, 0.0);
+    acceleration_including_gravity = DeviceAcceleration::Create(NAN, NAN, NAN);
   }
 
   if (linear_acceleration_sensor_.SensorReadingCouldBeRead()) {
     if (linear_acceleration_sensor_.reading.timestamp() == 0.0)
       return nullptr;
 
-    acceleration = DeviceMotionData::Acceleration::Create(
-        !std::isnan(linear_acceleration_sensor_.reading.accel.x.value()),
-        linear_acceleration_sensor_.reading.accel.x,
-        !std::isnan(linear_acceleration_sensor_.reading.accel.y.value()),
-        linear_acceleration_sensor_.reading.accel.y,
-        !std::isnan(linear_acceleration_sensor_.reading.accel.z.value()),
-        linear_acceleration_sensor_.reading.accel.z);
+    acceleration =
+        DeviceAcceleration::Create(linear_acceleration_sensor_.reading.accel.x,
+                                   linear_acceleration_sensor_.reading.accel.y,
+                                   linear_acceleration_sensor_.reading.accel.z);
   } else {
-    acceleration = DeviceMotionData::Acceleration::Create(false, 0.0, false,
-                                                          0.0, false, 0.0);
+    acceleration = DeviceAcceleration::Create(NAN, NAN, NAN);
   }
 
   if (gyroscope_.SensorReadingCouldBeRead()) {
     if (gyroscope_.reading.timestamp() == 0.0)
       return nullptr;
 
-    rotation_rate = DeviceMotionData::RotationRate::Create(
-        !std::isnan(gyroscope_.reading.gyro.x.value()),
-        gfx::RadToDeg(gyroscope_.reading.gyro.x),
-        !std::isnan(gyroscope_.reading.gyro.y.value()),
-        gfx::RadToDeg(gyroscope_.reading.gyro.y),
-        !std::isnan(gyroscope_.reading.gyro.z.value()),
-        gfx::RadToDeg(gyroscope_.reading.gyro.z));
+    rotation_rate =
+        DeviceRotationRate::Create(gfx::RadToDeg(gyroscope_.reading.gyro.x),
+                                   gfx::RadToDeg(gyroscope_.reading.gyro.y),
+                                   gfx::RadToDeg(gyroscope_.reading.gyro.z));
   } else {
-    rotation_rate = DeviceMotionData::RotationRate::Create(false, 0.0, false,
-                                                           0.0, false, 0.0);
+    rotation_rate = DeviceRotationRate::Create(NAN, NAN, NAN);
   }
 
   // The device orientation spec states that interval should be in

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

@@ -11,8 +11,10 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/blink/renderer/core/frame/platform_event_controller.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_acceleration.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_data.h"
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_event_pump.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_rotation_rate.h"
 #include "third_party/blink/renderer/platform/heap/persistent.h"
 #include "ui/gfx/geometry/angle_conversions.h"
 
@@ -224,26 +226,34 @@ TEST_F(DeviceMotionEventPumpTest, AllSensorsAreActive) {
   const DeviceMotionData* received_data = controller()->data();
   EXPECT_TRUE(controller()->did_change_device_motion());
 
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideX());
-  EXPECT_EQ(1, received_data->GetAccelerationIncludingGravity()->X());
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideY());
-  EXPECT_EQ(2, received_data->GetAccelerationIncludingGravity()->Y());
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideZ());
-  EXPECT_EQ(3, received_data->GetAccelerationIncludingGravity()->Z());
-
-  EXPECT_TRUE(received_data->GetAcceleration()->CanProvideX());
-  EXPECT_EQ(4, received_data->GetAcceleration()->X());
-  EXPECT_TRUE(received_data->GetAcceleration()->CanProvideY());
-  EXPECT_EQ(5, received_data->GetAcceleration()->Y());
-  EXPECT_TRUE(received_data->GetAcceleration()->CanProvideZ());
-  EXPECT_EQ(6, received_data->GetAcceleration()->Z());
-
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideAlpha());
-  EXPECT_EQ(gfx::RadToDeg(7.0), received_data->GetRotationRate()->Alpha());
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideBeta());
-  EXPECT_EQ(gfx::RadToDeg(8.0), received_data->GetRotationRate()->Beta());
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideGamma());
-  EXPECT_EQ(gfx::RadToDeg(9.0), received_data->GetRotationRate()->Gamma());
+  bool is_null;
+  EXPECT_TRUE(
+      received_data->GetAccelerationIncludingGravity()->HasAccelerationData());
+  EXPECT_EQ(1, received_data->GetAccelerationIncludingGravity()->x(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(2, received_data->GetAccelerationIncludingGravity()->y(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(3, received_data->GetAccelerationIncludingGravity()->z(is_null));
+  EXPECT_FALSE(is_null);
+
+  EXPECT_TRUE(received_data->GetAcceleration()->HasAccelerationData());
+  EXPECT_EQ(4, received_data->GetAcceleration()->x(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(5, received_data->GetAcceleration()->y(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(6, received_data->GetAcceleration()->z(is_null));
+  EXPECT_FALSE(is_null);
+
+  EXPECT_TRUE(received_data->GetRotationRate()->HasRotationData());
+  EXPECT_EQ(gfx::RadToDeg(7.0),
+            received_data->GetRotationRate()->alpha(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(gfx::RadToDeg(8.0),
+            received_data->GetRotationRate()->beta(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(gfx::RadToDeg(9.0),
+            received_data->GetRotationRate()->gamma(is_null));
+  EXPECT_FALSE(is_null);
 
   controller()->motion_pump()->Stop();
 
@@ -270,23 +280,33 @@ TEST_F(DeviceMotionEventPumpTest, TwoSensorsAreActive) {
   const DeviceMotionData* received_data = controller()->data();
   EXPECT_TRUE(controller()->did_change_device_motion());
 
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideX());
-  EXPECT_EQ(1, received_data->GetAccelerationIncludingGravity()->X());
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideY());
-  EXPECT_EQ(2, received_data->GetAccelerationIncludingGravity()->Y());
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideZ());
-  EXPECT_EQ(3, received_data->GetAccelerationIncludingGravity()->Z());
-
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideX());
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideY());
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideZ());
-
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideAlpha());
-  EXPECT_EQ(gfx::RadToDeg(7.0), received_data->GetRotationRate()->Alpha());
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideBeta());
-  EXPECT_EQ(gfx::RadToDeg(8.0), received_data->GetRotationRate()->Beta());
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideGamma());
-  EXPECT_EQ(gfx::RadToDeg(9.0), received_data->GetRotationRate()->Gamma());
+  bool is_null;
+  EXPECT_TRUE(
+      received_data->GetAccelerationIncludingGravity()->HasAccelerationData());
+  EXPECT_EQ(1, received_data->GetAccelerationIncludingGravity()->x(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(2, received_data->GetAccelerationIncludingGravity()->y(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(3, received_data->GetAccelerationIncludingGravity()->z(is_null));
+  EXPECT_FALSE(is_null);
+
+  received_data->GetAcceleration()->x(is_null);
+  EXPECT_TRUE(is_null);
+  received_data->GetAcceleration()->y(is_null);
+  EXPECT_TRUE(is_null);
+  received_data->GetAcceleration()->z(is_null);
+  EXPECT_TRUE(is_null);
+
+  EXPECT_TRUE(received_data->GetRotationRate()->HasRotationData());
+  EXPECT_EQ(gfx::RadToDeg(7.0),
+            received_data->GetRotationRate()->alpha(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(gfx::RadToDeg(8.0),
+            received_data->GetRotationRate()->beta(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(gfx::RadToDeg(9.0),
+            received_data->GetRotationRate()->gamma(is_null));
+  EXPECT_FALSE(is_null);
 
   controller()->motion_pump()->Stop();
 
@@ -312,23 +332,30 @@ TEST_F(DeviceMotionEventPumpTest, SomeSensorDataFieldsNotAvailable) {
   const DeviceMotionData* received_data = controller()->data();
   EXPECT_TRUE(controller()->did_change_device_motion());
 
-  EXPECT_FALSE(received_data->GetAccelerationIncludingGravity()->CanProvideX());
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideY());
-  EXPECT_EQ(2, received_data->GetAccelerationIncludingGravity()->Y());
-  EXPECT_TRUE(received_data->GetAccelerationIncludingGravity()->CanProvideZ());
-  EXPECT_EQ(3, received_data->GetAccelerationIncludingGravity()->Z());
-
-  EXPECT_TRUE(received_data->GetAcceleration()->CanProvideX());
-  EXPECT_EQ(4, received_data->GetAcceleration()->X());
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideY());
-  EXPECT_TRUE(received_data->GetAcceleration()->CanProvideZ());
-  EXPECT_EQ(6, received_data->GetAcceleration()->Z());
-
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideAlpha());
-  EXPECT_EQ(gfx::RadToDeg(7.0), received_data->GetRotationRate()->Alpha());
-  EXPECT_TRUE(received_data->GetRotationRate()->CanProvideBeta());
-  EXPECT_EQ(gfx::RadToDeg(8.0), received_data->GetRotationRate()->Beta());
-  EXPECT_FALSE(received_data->GetRotationRate()->CanProvideGamma());
+  bool is_null;
+  received_data->GetAccelerationIncludingGravity()->x(is_null);
+  EXPECT_TRUE(is_null);
+  EXPECT_EQ(2, received_data->GetAccelerationIncludingGravity()->y(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(3, received_data->GetAccelerationIncludingGravity()->z(is_null));
+  EXPECT_FALSE(is_null);
+
+  EXPECT_EQ(4, received_data->GetAcceleration()->x(is_null));
+  EXPECT_FALSE(is_null);
+  received_data->GetAcceleration()->y(is_null);
+  EXPECT_TRUE(is_null);
+  EXPECT_EQ(6, received_data->GetAcceleration()->z(is_null));
+  EXPECT_FALSE(is_null);
+
+  EXPECT_TRUE(received_data->GetAcceleration()->HasAccelerationData());
+  EXPECT_EQ(gfx::RadToDeg(7.0),
+            received_data->GetRotationRate()->alpha(is_null));
+  EXPECT_FALSE(is_null);
+  EXPECT_EQ(gfx::RadToDeg(8.0),
+            received_data->GetRotationRate()->beta(is_null));
+  EXPECT_FALSE(is_null);
+  received_data->GetRotationRate()->gamma(is_null);
+  EXPECT_TRUE(is_null);
 
   controller()->motion_pump()->Stop();
 
@@ -353,17 +380,12 @@ TEST_F(DeviceMotionEventPumpTest, FireAllNullEvent) {
   const DeviceMotionData* received_data = controller()->data();
   EXPECT_TRUE(controller()->did_change_device_motion());
 
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideX());
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideY());
-  EXPECT_FALSE(received_data->GetAcceleration()->CanProvideZ());
+  EXPECT_FALSE(received_data->GetAcceleration()->HasAccelerationData());
 
-  EXPECT_FALSE(received_data->GetAccelerationIncludingGravity()->CanProvideX());
-  EXPECT_FALSE(received_data->GetAccelerationIncludingGravity()->CanProvideY());
-  EXPECT_FALSE(received_data->GetAccelerationIncludingGravity()->CanProvideZ());
+  EXPECT_FALSE(
+      received_data->GetAccelerationIncludingGravity()->HasAccelerationData());
 
-  EXPECT_FALSE(received_data->GetRotationRate()->CanProvideAlpha());
-  EXPECT_FALSE(received_data->GetRotationRate()->CanProvideBeta());
-  EXPECT_FALSE(received_data->GetRotationRate()->CanProvideGamma());
+  EXPECT_FALSE(received_data->GetRotationRate()->HasRotationData());
 
   controller()->motion_pump()->Stop();
 

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

@@ -24,40 +24,44 @@
  */
 
 #include "third_party/blink/renderer/modules/device_orientation/device_rotation_rate.h"
+#include "third_party/blink/renderer/modules/device_orientation/device_rotation_rate_init.h"
 
 namespace blink {
 
-DeviceRotationRate::DeviceRotationRate(
-    DeviceMotionData::RotationRate* rotation_rate)
-    : rotation_rate_(rotation_rate) {}
+DeviceRotationRate* DeviceRotationRate::Create(double alpha,
+                                               double beta,
+                                               double gamma) {
+  return new DeviceRotationRate(alpha, beta, gamma);
+}
 
-void DeviceRotationRate::Trace(blink::Visitor* visitor) {
-  visitor->Trace(rotation_rate_);
-  ScriptWrappable::Trace(visitor);
+DeviceRotationRate* DeviceRotationRate::Create(
+    const DeviceRotationRateInit* init) {
+  double alpha = init->hasAlpha() ? init->alpha() : NAN;
+  double beta = init->hasBeta() ? init->beta() : NAN;
+  double gamma = init->hasGamma() ? init->gamma() : NAN;
+  return DeviceRotationRate::Create(alpha, beta, gamma);
 }
 
-double DeviceRotationRate::alpha(bool& is_null) const {
-  if (rotation_rate_->CanProvideAlpha())
-    return rotation_rate_->Alpha();
+DeviceRotationRate::DeviceRotationRate(double alpha, double beta, double gamma)
+    : alpha_(alpha), beta_(beta), gamma_(gamma) {}
 
-  is_null = true;
-  return 0;
+bool DeviceRotationRate::HasRotationData() const {
+  return !std::isnan(alpha_) || !std::isnan(beta_) || !std::isnan(gamma_);
 }
 
-double DeviceRotationRate::beta(bool& is_null) const {
-  if (rotation_rate_->CanProvideBeta())
-    return rotation_rate_->Beta();
+double DeviceRotationRate::alpha(bool& is_null) const {
+  is_null = std::isnan(alpha_);
+  return alpha_;
+}
 
-  is_null = true;
-  return 0;
+double DeviceRotationRate::beta(bool& is_null) const {
+  is_null = std::isnan(beta_);
+  return beta_;
 }
 
 double DeviceRotationRate::gamma(bool& is_null) const {
-  if (rotation_rate_->CanProvideGamma())
-    return rotation_rate_->Gamma();
-
-  is_null = true;
-  return 0;
+  is_null = std::isnan(gamma_);
+  return gamma_;
 }
 
 }  // namespace blink

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

@@ -27,29 +27,33 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_DEVICE_ORIENTATION_DEVICE_ROTATION_RATE_H_
 
 #include "third_party/blink/renderer/modules/device_orientation/device_motion_data.h"
+#include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
 namespace blink {
 
-class DeviceRotationRate final : public ScriptWrappable {
+class DeviceRotationRateInit;
+
+class MODULES_EXPORT DeviceRotationRate final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static DeviceRotationRate* Create(
-      DeviceMotionData::RotationRate* rotation_rate) {
-    return new DeviceRotationRate(rotation_rate);
-  }
-  void Trace(blink::Visitor*) override;
+  static DeviceRotationRate* Create(double alpha, double beta, double gamma);
+  static DeviceRotationRate* Create(const DeviceRotationRateInit*);
+
+  bool HasRotationData() const;
 
   double alpha(bool& is_null) const;
   double beta(bool& is_null) const;
   double gamma(bool& is_null) const;
 
  private:
-  explicit DeviceRotationRate(DeviceMotionData::RotationRate*);
+  DeviceRotationRate(double alpha, double beta, double gamma);
 
-  Member<DeviceMotionData::RotationRate> rotation_rate_;
+  const double alpha_;
+  const double beta_;
+  const double gamma_;
 };
 
 }  // namespace blink