[Sensors] Simplify calculation of the reporting period

third_party/WebKit/Source/modules/sensor/Sensor.cpp

 // Copyright 2016 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 "modules/sensor/Sensor.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/inspector/ConsoleMessage.h"
@@ skipping 15 matching lines @@
 }  // namespace
 
 Sensor::Sensor(ExecutionContext* execution_context,
                const SensorOptions& sensor_options,
                ExceptionState& exception_state,
                SensorType type)
     : ContextLifecycleObserver(execution_context),
       sensor_options_(sensor_options),
       type_(type),
       state_(SensorState::kIdle),
-      last_update_timestamp_(0.0),
       pending_reading_update_(false) {
   // Check secure context.
   String error_message;
   if (!execution_context->IsSecureContext(error_message)) {
     exception_state.ThrowDOMException(kSecurityError, error_message);
     return;
   }
 
   // Check top-level browsing context.
   if (!ToDocument(execution_context)->domWindow()->GetFrame() ||
@@ skipping 116 matching lines @@
   StopListening();
 }
 
 void Sensor::OnSensorInitialized() {
   if (state_ != Sensor::SensorState::kActivating)
     return;
 
   RequestAddConfiguration();
 }
 
-void Sensor::OnSensorReadingChanged(double timestamp) {
+void Sensor::OnSensorReadingChanged() {
   if (state_ != Sensor::SensorState::kActivated)
     return;
 
   // Return if reading update is already scheduled or the cached
   // reading is up-to-date.
-  if (pending_reading_update_ ||
-      sensor_proxy_->reading().timestamp == reading_.timestamp)
+  if (pending_reading_update_)
     return;
 
   pending_reading_update_ = true;
 
-  double elapsedTime = timestamp - last_update_timestamp_;
+  double elapsedTime = sensor_proxy_->reading().timestamp - reading_.timestamp;
+  DCHECK_GT(elapsedTime, 0.0);
 
   DCHECK_GT(configuration_->frequency, 0.0);
   double waitingTime = 1 / configuration_->frequency - elapsedTime;
 
   // Negative or zero 'waitingTime' means that polling period has elapsed.
   // We also avoid scheduling if the elapsed time is slightly behind the
   // polling period.
   auto sensor_reading_changed =
       WTF::Bind(&Sensor::UpdateReading, WrapWeakPersistent(this));
   if (waitingTime < kMinWaitingInterval) {
@@ skipping 17 matching lines @@
 
 void Sensor::OnAddConfigurationRequestCompleted(bool result) {
   if (state_ != SensorState::kActivating)
     return;
 
   if (!result) {
     HandleError(kNotReadableError, "start() call has failed.");
     return;
   }
 
-  // The initial value for m_lastUpdateTimestamp is set to current time,
-  // so that the first reading update will be notified considering the given
-  // frequency hint.
-  last_update_timestamp_ = WTF::MonotonicallyIncreasingTime();
-
   UpdateState(Sensor::SensorState::kActivated);
 
   if (GetExecutionContext()) {
     TaskRunnerHelper::Get(TaskType::kSensor, GetExecutionContext())
         ->PostTask(BLINK_FROM_HERE, WTF::Bind(&Sensor::NotifyOnActivate,
                                               WrapWeakPersistent(this)));
   }
 }
 
 void Sensor::StartListening() {
@@ skipping 59 matching lines @@
     auto error =
         DOMException::Create(code, sanitized_message, unsanitized_message);
     TaskRunnerHelper::Get(TaskType::kSensor, GetExecutionContext())
         ->PostTask(BLINK_FROM_HERE,
                    WTF::Bind(&Sensor::NotifyError, WrapWeakPersistent(this),
                              WrapPersistent(error)));
   }
 }
 
 void Sensor::UpdateReading() {
-  last_update_timestamp_ = WTF::MonotonicallyIncreasingTime();
   reading_ = sensor_proxy_->reading();
   pending_reading_update_ = false;
   DispatchEvent(Event::Create(EventTypeNames::change));
 }
 
 void Sensor::NotifyOnActivate() {
   DispatchEvent(Event::Create(EventTypeNames::activate));
 }
 
 void Sensor::NotifyError(DOMException* error) {
   DispatchEvent(
       SensorErrorEvent::Create(EventTypeNames::error, std::move(error)));
 }
 
 bool Sensor::CanReturnReadings() const {
   if (!IsActivated())
     return false;
   DCHECK(sensor_proxy_);
   return sensor_proxy_->reading().timestamp != 0.0;
 }
 
 }  // namespace blink