[sensors] Add Permission guard to the generic sensor apis.

third_party/WebKit/Source/modules/sensor/SensorProxy.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/SensorProxy.h"
 
 #include "core/frame/LocalFrame.h"
+#include "modules/permissions/PermissionUtils.h"
 #include "modules/sensor/SensorProviderProxy.h"
 #include "modules/sensor/SensorReading.h"
+#include "platform/UserGestureIndicator.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/Platform.h"
+#include "wtf/RefPtr.h"
 
 using namespace device::mojom::blink;
 
 namespace blink {
 
+using mojom::blink::PermissionName;
+using mojom::blink::PermissionService;
+using mojom::blink::PermissionStatus;
+
 SensorProxy::SensorProxy(SensorType sensorType,
+                         ExecutionContext* executionContext,
                          SensorProviderProxy* provider,
                          std::unique_ptr<SensorReadingFactory> readingFactory)
     : m_type(sensorType),
       m_mode(ReportingMode::CONTINUOUS),
       m_provider(provider),
       m_clientBinding(this),
       m_state(SensorProxy::Uninitialized),
       m_suspended(false),
-      m_readingFactory(std::move(readingFactory)) {}
+      m_readingFactory(std::move(readingFactory)),
+      m_sensorPermission(PermissionStatus::ASK),
+      m_executionContext(executionContext),

[Mikhail, 2016/11/10 09:30:48]

can we pass the "prepared" permissionService here instead of executionContext?

[riju_, 2016/11/14 14:00:06]

Yes, done now.

+      m_startPendingPermission(false) {}
+
+void SensorProxy::getNextPermissionChange(ExecutionContext* executionContext,

[Mikhail, 2016/11/10 09:30:48]

we don't need this wrapper, it's called only once

[riju_, 2016/11/14 14:00:06]

Done. removed.

+                                          PermissionStatus status) {
+  m_permissionService->GetNextPermissionChange(
+      createPermissionDescriptor(PermissionName::SENSORS),
+      executionContext->getSecurityOrigin(), m_sensorPermission,
+      convertToBaseCallback(
+          WTF::bind(&SensorProxy::onPermissionUpdate, wrapPersistent(this))));
+}
+
+void SensorProxy::requestPermission(ExecutionContext* executionContext,
+                                    PermissionStatus status) {
+  m_permissionService->RequestPermission(
+      createPermissionDescriptor(PermissionName::SENSORS),
+      m_executionContext->getSecurityOrigin(),
+      UserGestureIndicator::processingUserGesture(),
+      convertToBaseCallback(
+          WTF::bind(&SensorProxy::onPermissionUpdate, wrapPersistent(this))));
+}
+
+void SensorProxy::onPermissionUpdate(PermissionStatus status) {
+  if (m_sensorPermission != status) {
+    m_sensorPermission = status;
+    SensorPermissionChanged();
+  }
+  // Keep listening to changes.
+  getNextPermissionChange(m_executionContext, m_sensorPermission);
+}
 
 SensorProxy::~SensorProxy() {}
 
+void SensorProxy::resetPermissionService() {
+  m_permissionService.reset();
+}
+
+PermissionService* SensorProxy::getPermissionService(
+    ExecutionContext* executionContext) {
+  if (!m_permissionService &&

[Mikhail, 2016/11/10 09:30:48]

think we should not init it lazily, see my comment in ctor

[riju_, 2016/11/14 14:00:07]

Done.

+      connectToPermissionService(executionContext,
+                                 mojo::GetProxy(&m_permissionService))) {
+    m_permissionService.set_connection_error_handler(convertToBaseCallback(
+        WTF::bind(&SensorProxy::permissionServiceConnectionError,
+                  wrapWeakPersistent(this))));
+  }
+  return m_permissionService.get();
+}
+
+void SensorProxy::permissionServiceConnectionError() {
+  m_permissionService.reset();

[Mikhail, 2016/11/10 09:30:48]

this looks like a fatal error, so service reset is not enough.
handleSensorError() to be invoked

[riju_, 2016/11/14 14:00:06]

Done.

+}
+
 void SensorProxy::dispose() {
   m_clientBinding.Close();
 }
 
 DEFINE_TRACE(SensorProxy) {
   visitor->trace(m_reading);
   visitor->trace(m_observers);
   visitor->trace(m_provider);
+  visitor->trace(m_executionContext);
 }
 
 void SensorProxy::addObserver(Observer* observer) {
   if (!m_observers.contains(observer))
     m_observers.add(observer);
 }
 
 void SensorProxy::removeObserver(Observer* observer) {
   m_observers.remove(observer);
 }
 
 void SensorProxy::initialize() {
   if (m_state != Uninitialized)
     return;
 
   if (!m_provider->sensorProvider()) {
     handleSensorError();
     return;
   }
+  // Get permission service.
+  PermissionService* permissionService =
+      getPermissionService(m_executionContext);
+
+  if (!permissionService) {
+    handleSensorError(
+        InvalidStateError,
+        "In its current state, the global scope can't request permissions");
+  }
+
+  // Request permission.
+  if (m_sensorPermission == PermissionStatus::ASK) {
+    setStartPendingPermission(true);

[Mikhail, 2016/11/10 09:30:48]

why split 'setStartPendingPermission' and 'requestPermission'?
we can put pending flag inside 'requestPermission'

[riju_, 2016/11/14 14:00:06]

Done.

+    requestPermission(m_executionContext, m_sensorPermission);

[Mikhail, 2016/11/10 09:30:48]

here we should interrupt and wait for permissions

[riju_, 2016/11/14 14:00:06]

Acknowledged.

+  }
 
   m_state = Initializing;
   auto callback = convertToBaseCallback(
       WTF::bind(&SensorProxy::onSensorCreated, wrapWeakPersistent(this)));
   m_provider->sensorProvider()->GetSensor(m_type, mojo::GetProxy(&m_sensor),

[Mikhail, 2016/11/10 09:30:48]

this method should be called *AFTER* permission is granted

[riju_, 2016/11/14 14:00:07]

Done.

                                           callback);
 }
 
 void SensorProxy::addConfiguration(
     SensorConfigurationPtr configuration,
     std::unique_ptr<Function<void(bool)>> callback) {
   DCHECK(isInitialized());
   m_sensor->AddConfiguration(std::move(configuration),
                              convertToBaseCallback(std::move(callback)));
 }
@@ skipping 48 matching lines @@
 
 void SensorProxy::RaiseError() {
   handleSensorError();
 }
 
 void SensorProxy::SensorReadingChanged() {
   for (Observer* observer : m_observers)
     observer->onSensorReadingChanged();
 }
 
+void SensorProxy::SensorPermissionChanged() {
+  for (Observer* observer : m_observers)
+    observer->onSensorPermissionChanged();
+}
+
 void SensorProxy::handleSensorError(ExceptionCode code,
                                     String sanitizedMessage,
                                     String unsanitizedMessage) {
   if (!Platform::current()) {
     // TODO(rockot): Remove this hack once renderer shutdown sequence is fixed.
     return;
   }
 
   m_state = Uninitialized;
   // The m_sensor.reset() will release all callbacks and its bound parameters,
   // therefore, handleSensorError accepts messages by value.
   m_sensor.reset();
   m_sharedBuffer.reset();
   m_sharedBufferHandle.reset();
   m_defaultConfig.reset();
   m_clientBinding.Close();
   m_reading = nullptr;
+  m_permissionService.reset();
 
   for (Observer* observer : m_observers)
     observer->onSensorError(code, sanitizedMessage, unsanitizedMessage);
 }
 
 void SensorProxy::onSensorCreated(SensorInitParamsPtr params,
                                   SensorClientRequest clientRequest) {
   DCHECK_EQ(Initializing, m_state);
   if (!params) {
     handleSensorError(NotFoundError, "Sensor is not present on the platform.");
@@ skipping 41 matching lines @@
   const device::OneWriterSeqLock& seqlock = buffer->seqlock.value();
   auto version = seqlock.ReadBegin();
   auto readingData = buffer->reading;
   if (seqlock.ReadRetry(version))
     return false;
   result = readingData;
   return true;
 }
 
 }  // namespace blink