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

third_party/WebKit/Source/modules/sensor/SensorProxy.cpp

Index: third_party/WebKit/Source/modules/sensor/SensorProxy.cpp
diff --git a/third_party/WebKit/Source/modules/sensor/SensorProxy.cpp b/third_party/WebKit/Source/modules/sensor/SensorProxy.cpp
index 9aea416ebdbd44a897fd3a27ac343f510f43df97..5b17ecab0b74345275575a428c8cd276df5cd2e3 100644
--- a/third_party/WebKit/Source/modules/sensor/SensorProxy.cpp
+++ b/third_party/WebKit/Source/modules/sensor/SensorProxy.cpp
@@ -5,16 +5,24 @@
 #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),
@@ -23,10 +31,61 @@ SensorProxy::SensorProxy(SensorType sensorType,
       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();
 }
@@ -35,6 +94,7 @@ DEFINE_TRACE(SensorProxy) {
   visitor->trace(m_reading);
   visitor->trace(m_observers);
   visitor->trace(m_provider);
+  visitor->trace(m_executionContext);
 }
 
 void SensorProxy::addObserver(Observer* observer) {
@@ -54,6 +114,21 @@ void SensorProxy::initialize() {
     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(
@@ -127,6 +202,11 @@ void SensorProxy::SensorReadingChanged() {
     observer->onSensorReadingChanged();
 }
 
+void SensorProxy::SensorPermissionChanged() {
+  for (Observer* observer : m_observers)
+    observer->onSensorPermissionChanged();
+}
+
 void SensorProxy::handleSensorError(ExceptionCode code,
                                     String sanitizedMessage,
                                     String unsanitizedMessage) {
@@ -144,6 +224,7 @@ void SensorProxy::handleSensorError(ExceptionCode code,
   m_defaultConfig.reset();
   m_clientBinding.Close();
   m_reading = nullptr;
+  m_permissionService.reset();
 
   for (Observer* observer : m_observers)
     observer->onSensorError(code, sanitizedMessage, unsanitizedMessage);