[Sensors] Cancel pending 'onchange' notifications

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 14 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),
-      pending_reading_update_(false) {
+      state_(SensorState::kIdle) {
   // 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() ||
       !ToDocument(execution_context)->GetFrame()->IsMainFrame()) {
@@ skipping 121 matching lines @@
 
   RequestAddConfiguration();
 }
 
 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_)
+  if (pending_reading_update_.IsActive())
     return;
 
-  pending_reading_update_ = true;
-
   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) {
     // Invoke JS callbacks in a different callchain to obviate
     // possible modifications of SensorProxy::observers_ container
     // while it is being iterated through.
-    TaskRunnerHelper::Get(TaskType::kSensor, GetExecutionContext())
-        ->PostTask(BLINK_FROM_HERE, std::move(sensor_reading_changed));
+    pending_reading_update_ =
+        TaskRunnerHelper::Get(TaskType::kSensor, GetExecutionContext())
+            ->PostCancellableTask(BLINK_FROM_HERE,
+                                  std::move(sensor_reading_changed));
   } else {
-    TaskRunnerHelper::Get(TaskType::kSensor, GetExecutionContext())
-        ->PostDelayedTask(BLINK_FROM_HERE, std::move(sensor_reading_changed),
-                          WTF::TimeDelta::FromSecondsD(waitingTime));
+    pending_reading_update_ =
+        TaskRunnerHelper::Get(TaskType::kSensor, GetExecutionContext())
+            ->PostDelayedCancellableTask(
+                BLINK_FROM_HERE, std::move(sensor_reading_changed),
+                WTF::TimeDelta::FromSecondsD(waitingTime));
   }
 }
 
 void Sensor::OnSensorError(ExceptionCode code,
                            const String& sanitized_message,
                            const String& unsanitized_message) {
   HandleError(code, sanitized_message, unsanitized_message);
 }
 
 void Sensor::OnAddConfigurationRequestCompleted(bool result) {
@@ skipping 31 matching lines @@
     sensor_proxy_->Initialize();
 
   sensor_proxy_->AddObserver(this);
   UpdateState(SensorState::kActivating);
 }
 
 void Sensor::StopListening() {
   if (state_ == SensorState::kIdle)
     return;
 
+  pending_reading_update_.Cancel();
+
   DCHECK(sensor_proxy_);
   if (sensor_proxy_->IsInitialized()) {
     DCHECK(configuration_);
     sensor_proxy_->RemoveConfiguration(configuration_->Clone());
   }
 
   sensor_proxy_->RemoveObserver(this);
   UpdateState(Sensor::SensorState::kIdle);
 }
 
@@ skipping 27 matching lines @@
         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() {
   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