[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 "platform/UserGestureIndicator.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/Platform.h"
+#include "wtf/RefPtr.h"
 
 using namespace device::mojom::blink;
 
 namespace blink {
 
-SensorProxy::SensorProxy(SensorType sensorType, SensorProviderProxy* provider)
+using mojom::blink::PermissionName;
+using mojom::blink::PermissionService;
+using mojom::blink::PermissionStatus;
+
+SensorProxy::SensorProxy(SensorType sensorType,
+                         ExecutionContext* executionContext,
+                         SensorProviderProxy* provider)
     : m_type(sensorType),
       m_mode(ReportingMode::CONTINUOUS),
       m_provider(provider),
       m_clientBinding(this),
       m_state(SensorProxy::Uninitialized),
       m_reading(),
-      m_suspended(false) {}
+      m_suspended(false),
+      m_sensorPermission(PermissionStatus::ASK),
+      m_executionContext(executionContext) {
+  // Get permission service.

[shalamov, 2016/11/04 19:00:20]

Is this needed in constructor? Also, handleSersonError will go through all
observers (JS instances) and notify them, so line 39 doesn't do anything, since
there can't be any observers at this point.

[riju_, 2016/11/09 10:30:34]

Moving to Initialize

+  PermissionService* permissionService =
+      getPermissionService(m_executionContext);
+  if (!permissionService) {
+    handleSensorError(
+        InvalidStateError,
+        "In its current state, the global scope can't request permissions");
+  }
 
-SensorProxy::~SensorProxy() {}
+  // Check permissions.
+  m_permissionService->HasPermission(
+      createPermissionDescriptor(PermissionName::SENSORS),
+      m_executionContext->getSecurityOrigin(),
+      convertToBaseCallback(
+          WTF::bind(&SensorProxy::onPermissionUpdate, wrapPersistent(this))));
+}
+
+void SensorProxy::getNextPermissionChange(ExecutionContext* executionContext,
+                                          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();
+  }
+}
+
+SensorProxy::~SensorProxy() {
+  m_permissionService.reset();

[Mikhail, 2016/11/07 08:02:02]

isn't it automatically reset when destructed?

[riju_, 2016/11/09 10:30:34]

Done.

+}
+
+void SensorProxy::resetPermissionService() {
+  m_permissionService.reset();
+}
+
+PermissionService* SensorProxy::getPermissionService(
+    ExecutionContext* executionContext) {
+  if (!m_permissionService &&
+      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();
+}
 
 void SensorProxy::dispose() {
   m_clientBinding.Close();
 }
 
 DEFINE_TRACE(SensorProxy) {
   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);
 }
@@ skipping 68 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,
                                     const String& sanitizedMessage,
                                     const String& unsanitizedMessage) {
   if (!Platform::current()) {
     // TODO(rockot): Remove this hack once renderer shutdown sequence is fixed.
     return;
   }
   m_state = Uninitialized;
   m_sensor.reset();
   m_sharedBuffer.reset();
   m_sharedBufferHandle.reset();
   m_defaultConfig.reset();
   m_clientBinding.Close();
+  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 16 matching lines @@
   m_sharedBufferHandle = std::move(params->memory);
   DCHECK(!m_sharedBuffer);
   m_sharedBuffer =
       m_sharedBufferHandle->MapAtOffset(kReadBufferSize, params->buffer_offset);
 
   if (!m_sharedBuffer) {
     handleSensorError();
     return;
   }
 
+  // Check permission now.
+  if (m_sensorPermission == PermissionStatus::ASK)
+    requestPermission(m_executionContext, m_sensorPermission);

[Mikhail, 2016/11/04 13:05:59]

here it's a bit late to check permission as sensor is already created.

I'd move permissions check to 'initialize' before we start any other actions.

[riju_, 2016/11/09 10:30:34]

Done.

+
   auto errorCallback =
       WTF::bind(&SensorProxy::handleSensorError, wrapWeakPersistent(this),
                 UnknownError, String("Internal error"), String());
   m_sensor.set_connection_error_handler(
       convertToBaseCallback(std::move(errorCallback)));
 
   m_state = Initialized;
   for (Observer* observer : m_observers)
     observer->onSensorInitialized();
 }
 
 bool SensorProxy::tryReadFromBuffer() {
   DCHECK(isInitialized());
   const ReadingBuffer* buffer =
       static_cast<const ReadingBuffer*>(m_sharedBuffer.get());
   const device::OneWriterSeqLock& seqlock = buffer->seqlock.value();
   auto version = seqlock.ReadBegin();
   auto reading = buffer->reading;
   if (seqlock.ReadRetry(version))
     return false;
   m_reading = reading;
   return true;
 }
 
 }  // namespace blink