Remove [ConstructorCallWith=ScriptState] from Sensor

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/ExecutionContextTask.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "device/generic_sensor/public/interfaces/sensor.mojom-blink.h"
 #include "modules/sensor/SensorErrorEvent.h"
 #include "modules/sensor/SensorProviderProxy.h"
 #include "modules/sensor/SensorReading.h"
 #include "modules/sensor/SensorUpdateNotificationStrategy.h"
 
 using namespace device::mojom::blink;
 
 namespace blink {
 
-Sensor::Sensor(ScriptState* scriptState,
+Sensor::Sensor(ExecutionContext* executionContext,
                const SensorOptions& sensorOptions,
                ExceptionState& exceptionState,
                SensorType type)
     : ActiveScriptWrappable(this),
-      ContextLifecycleObserver(scriptState->getExecutionContext()),
+      ContextLifecycleObserver(executionContext),
       m_sensorOptions(sensorOptions),
       m_type(type),
       m_state(Sensor::SensorState::Idle) {
   // Check secure context.
   String errorMessage;
-  if (!scriptState->getExecutionContext()->isSecureContext(errorMessage)) {
+  if (!executionContext->isSecureContext(errorMessage)) {
     exceptionState.throwDOMException(SecurityError, errorMessage);
     return;
   }
 
   // Check top-level browsing context.
-  if (!scriptState->domWindow() || !scriptState->domWindow()->frame() ||
-      !scriptState->domWindow()->frame()->isMainFrame()) {
+  if (!toDocument(executionContext)->domWindow()->frame() ||
+      !toDocument(executionContext)->frame()->isMainFrame()) {
     exceptionState.throwSecurityError(
         "Must be in a top-level browsing context");
     return;
   }
 
   // Check the given frequency value.
   if (m_sensorOptions.hasFrequency()) {
     double frequency = m_sensorOptions.frequency();
     if (frequency <= 0.0) {
       exceptionState.throwRangeError("Frequency must be positive.");
       return;
     }
 
     if (frequency > SensorConfiguration::kMaxAllowedFrequency) {
       m_sensorOptions.setFrequency(SensorConfiguration::kMaxAllowedFrequency);
       ConsoleMessage* consoleMessage = ConsoleMessage::create(
           JSMessageSource, InfoMessageLevel, "Frequency is limited to 60 Hz.");
-      scriptState->getExecutionContext()->addConsoleMessage(consoleMessage);
+      executionContext->addConsoleMessage(consoleMessage);
     }
   }
 }
 
 Sensor::~Sensor() = default;
 
 void Sensor::start(ScriptState* scriptState, ExceptionState& exceptionState) {
   if (m_state != Sensor::SensorState::Idle &&
       m_state != Sensor::SensorState::Errored) {
     exceptionState.throwDOMException(
@@ skipping 246 matching lines @@
 void Sensor::notifyOnActivate() {
   dispatchEvent(Event::create(EventTypeNames::activate));
 }
 
 void Sensor::notifyError(DOMException* error) {
   dispatchEvent(
       SensorErrorEvent::create(EventTypeNames::error, std::move(error)));
 }
 
 }  // namespace blink