[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 "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 
 using namespace device::mojom::blink;
 
 namespace blink {
 
+using mojom::blink::PermissionName;
+using mojom::blink::PermissionService;
+using mojom::blink::PermissionStatus;
+
 SensorProxy::SensorProxy(SensorType sensorType,
+                         PermissionService* permissionService,
+                         RefPtr<SecurityOrigin> origin,
                          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_maximumFrequency(0.0) {}
+      m_maximumFrequency(0.0),
+      m_permissionStatus(PermissionStatus::ASK),
+      m_permissionService(permissionService),
+      m_securityOrigin(std::move(origin)) {}
+
+void SensorProxy::onPermissionUpdate(PermissionStatus status) {
+  if (m_state == Uninitialized)
+    return;
+
+  if (m_permissionStatus != status) {
+    m_permissionStatus = status;
+    if (isInitializing())

[Mikhail, 2016/11/21 14:29:41]

what if this came after permission has already been obtained and we're in the
middle of GetSensor() call? it will be called another time, right?

and if the new value is ASK (and we're still initializing) it will ask for
permission again?

+      initialize();
+  }
+
+  // If permission is revoked, throw error.
+  if (isInitialized() && m_permissionStatus != PermissionStatus::GRANTED)
+    handleSensorError(NotAllowedError, "Permission not granted.");
+
+  // Keep listening to changes.
+  m_permissionService->GetNextPermissionChange(
+      createPermissionDescriptor(PermissionName::SENSORS), m_securityOrigin,
+      m_permissionStatus,
+      convertToBaseCallback(WTF::bind(&SensorProxy::onPermissionUpdate,
+                                      wrapWeakPersistent(this))));
+}
 
 SensorProxy::~SensorProxy() {}
 
 void SensorProxy::dispose() {
   m_clientBinding.Close();
 }
 
 DEFINE_TRACE(SensorProxy) {
   visitor->trace(m_reading);
   visitor->trace(m_observers);
   visitor->trace(m_provider);
 }
 
 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)
+  if (m_state == Initialized)
     return;
 
   if (!m_provider->sensorProvider()) {
     handleSensorError();
     return;
   }
 
   m_state = Initializing;
-  auto callback = convertToBaseCallback(
-      WTF::bind(&SensorProxy::onSensorCreated, wrapWeakPersistent(this)));
-  m_provider->sensorProvider()->GetSensor(m_type, mojo::GetProxy(&m_sensor),
-                                          callback);
+
+  switch (m_permissionStatus) {
+    case PermissionStatus::ASK:
+      // Request permission.
+      m_permissionService->RequestPermission(
+          createPermissionDescriptor(PermissionName::SENSORS), m_securityOrigin,
+          UserGestureIndicator::processingUserGesture(),
+          convertToBaseCallback(WTF::bind(&SensorProxy::onPermissionUpdate,
+                                          wrapWeakPersistent(this))));
+      break;
+    case PermissionStatus::DENIED:
+      handleSensorError(NotAllowedError, "Permission not granted.");

[Mikhail, 2016/11/21 14:29:41]

so, state will be still "Initializing"?

[riju_, 2016/11/23 09:02:28]

handleSensorError resets m_state to Uninitialized.
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/modules/sensor...

+      break;
+    case PermissionStatus::GRANTED:
+      m_provider->sensorProvider()->GetSensor(
+          m_type, mojo::GetProxy(&m_sensor),
+          convertToBaseCallback(WTF::bind(&SensorProxy::onSensorCreated,
+                                          wrapWeakPersistent(this))));
+      break;
+    default:
+      NOTREACHED();
+  }
 }
 
 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 128 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