[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/dom/Document.h"
 #include "core/frame/LocalFrame.h"
+#include "modules/permissions/PermissionUtils.h"
 #include "modules/sensor/SensorProviderProxy.h"
 #include "modules/sensor/SensorReadingUpdater.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;
+
+namespace {
+PermissionName GetPermissionType(SensorType type) {
+  PermissionName permission_name = PermissionName::SENSORS;
+
+  if (type == SensorType::AMBIENT_LIGHT)
+    permission_name = PermissionName::AMBIENT_LIGHT_SENSOR;
+  else if (type == SensorType::ACCELEROMETER)
+    permission_name = PermissionName::ACCELEROMETER;
+  else if (type == SensorType::GYROSCOPE)
+    permission_name = PermissionName::GYROSCOPE;
+  else if (type == SensorType::MAGNETOMETER)
+    permission_name = PermissionName::MAGNETOMETER;
+  else if (type == SensorType::ABSOLUTE_ORIENTATION)
+    permission_name = PermissionName::ORIENTATION_SENSOR;
+
+  return permission_name;
+}
+}
+
 SensorProxy::SensorProxy(SensorType sensor_type,
+                         RefPtr<SecurityOrigin> origin,
                          SensorProviderProxy* provider,
                          Page* page)
     : PageVisibilityObserver(page),
       type_(sensor_type),
       mode_(ReportingMode::CONTINUOUS),
       provider_(provider),
       client_binding_(this),
       state_(SensorProxy::kUninitialized),
-      suspended_(false) {}
+      suspended_(false),
+      security_origin_(std::move(origin)),
+      binding_(this),
+      permission_subscribed_(false) {}
+
+void SensorProxy::OnPermissionStatusChange(PermissionStatus status) {
+  if (state_ == kUninitialized)
+    return;
+
+  // PermissionName permission_name = GetPermissionType(type_);
+
+  switch (status) {
+    case mojom::blink::PermissionStatus::DENIED:
+      HandleSensorError();
+      // HandleSensorError(NotAllowedError, "Permission denied.");
+      return;
+    case mojom::blink::PermissionStatus::ASK:
+      HandleSensorError();
+      // HandleSensorError(NotAllowedError, "Permission revoked.");
+      return;
+    case mojom::blink::PermissionStatus::GRANTED:
+      if (IsInitializing()) {
+        if (!permission_subscribed_) {
+          DCHECK(!binding_.is_bound());
+          mojom::blink::PermissionObserverPtr observer;
+          binding_.Bind(mojo::MakeRequest(&observer));
+          provider_->permission_service_->AddPermissionObserver(
+              CreatePermissionDescriptor(PermissionName::SENSORS),
+              security_origin_, status, std::move(observer));
+          permission_subscribed_ = true;
+        }
+        state_ = kInitialized;
+        for (Observer* observer : observers_)
+          observer->OnSensorInitialized();
+      }
+      break;
+    default:
+      NOTREACHED();
+  }
+}
 
 SensorProxy::~SensorProxy() {}
 
 void SensorProxy::Dispose() {
   client_binding_.Close();
 }
 
 DEFINE_TRACE(SensorProxy) {
   visitor->Trace(reading_updater_);
   visitor->Trace(observers_);
@@ skipping 185 matching lines @@
       SensorConfiguration::kMaxAllowedFrequency;
   DCHECK_GE(kMaxAllowedFrequency, frequency_limits_.second);
 
   auto error_callback =
       WTF::Bind(&SensorProxy::HandleSensorError, WrapWeakPersistent(this));
   sensor_.set_connection_error_handler(
       ConvertToBaseCallback(std::move(error_callback)));
 
   reading_updater_ = SensorReadingUpdater::Create(this, mode_);
 
-  state_ = kInitialized;
-
   for (Observer* observer : observers_)
     observer->OnSensorInitialized();
+
+  // PermissionName permission_name = GetPermissionType(type_);
+
+  provider_->permission_service_->RequestPermission(
+      CreatePermissionDescriptor(PermissionName::SENSORS), security_origin_,
+      UserGestureIndicator::ProcessingUserGesture(),
+      ConvertToBaseCallback(WTF::Bind(&SensorProxy::OnPermissionStatusChange,
+                                      WrapWeakPersistent(this))));
 }
 
 void SensorProxy::OnAddConfigurationCompleted(
     double frequency,
     std::unique_ptr<Function<void(bool)>> callback,
     bool result) {
   if (result) {
     frequencies_used_.push_back(frequency);
     std::sort(frequencies_used_.begin(), frequencies_used_.end());
     if (IsActive())
@@ skipping 24 matching lines @@
   const device::OneWriterSeqLock& seqlock = buffer->seqlock.value();
   auto version = seqlock.ReadBegin();
   auto reading_data = buffer->reading;
   if (seqlock.ReadRetry(version))
     return false;
   result = reading_data;
   return true;
 }
 
 }  // namespace blink