[sensors][permission] Add new permission types in permission module.

third_party/WebKit/Source/modules/permissions/Permissions.cpp

 // Copyright 2014 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/permissions/Permissions.h"
 
 #include <memory>
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/modules/v8/V8MidiPermissionDescriptor.h"
 #include "bindings/modules/v8/V8PermissionDescriptor.h"
 #include "bindings/modules/v8/V8PushPermissionDescriptor.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/permissions/PermissionDescriptor.h"
 #include "modules/permissions/PermissionStatus.h"
 #include "modules/permissions/PermissionUtils.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/NotFound.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/Vector.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 using mojom::blink::PermissionDescriptorPtr;
 using mojom::blink::PermissionName;
 using mojom::blink::PermissionService;
 
 namespace {
 
+bool IsSensorRuntimeFlagEnabled(ExceptionState& exception_state) {
+  if (!RuntimeEnabledFeatures::sensorEnabled()) {
+    exception_state.ThrowTypeError("GenericSensor flag is not enabled.");
+    return false;
+  }
+  return true;
+}
+
 // Parses the raw permission dictionary and returns the Mojo
 // PermissionDescriptor if parsing was successful. If an exception occurs, it
 // will be stored in |exceptionState| and null will be returned. Therefore, the
 // |exceptionState| should be checked before attempting to use the returned
 // permission as the non-null assert will be fired otherwise.
 //
 // Websites will be able to run code when `name()` is called, changing the
 // current context. The caller should make sure that no assumption is made
 // after this has been called.
 PermissionDescriptorPtr ParsePermission(ScriptState* script_state,
@@ skipping 36 matching lines @@
   }
   if (name == "midi") {
     MidiPermissionDescriptor midi_permission =
         NativeValueTraits<MidiPermissionDescriptor>::NativeValue(
             script_state->GetIsolate(), raw_permission.V8Value(),
             exception_state);
     return CreateMidiPermissionDescriptor(midi_permission.sysex());
   }
   if (name == "background-sync")
     return CreatePermissionDescriptor(PermissionName::BACKGROUND_SYNC);
+  // TODO(riju): Remove runtime flag check when Generic Sensor feature is
+  // stable.
+  if (name == "ambient-light-sensor" &&
+      IsSensorRuntimeFlagEnabled(exception_state))

[mlamouri (slow - plz ping), 2017/04/20 13:26:32]

Instead of checking for the flag N times, could you do:
```
if (name == "ambient-ligth-sensor" || name == "accelerometer" || name =
"gyroscope" || name == "magnetometer") {
  if (!RuntimeEnabledFeatures::sensorEnabled()) {
    exception_state.ThrowTypeError("GenericSensor flag is not enabled.");
    return nullptr;
  }
  // check for all permissions
}
```

[riju_, 2017/07/19 06:56:46]

Done.

+    return CreatePermissionDescriptor(PermissionName::AMBIENT_LIGHT_SENSOR);
+  if (name == "accelerometer" && IsSensorRuntimeFlagEnabled(exception_state))
+    return CreatePermissionDescriptor(PermissionName::ACCELEROMETER);
+  if (name == "gyroscope" && IsSensorRuntimeFlagEnabled(exception_state))
+    return CreatePermissionDescriptor(PermissionName::GYROSCOPE);
+  if (name == "magnetometer" && IsSensorRuntimeFlagEnabled(exception_state))
+    return CreatePermissionDescriptor(PermissionName::MAGNETOMETER);
 
   return nullptr;
 }
 
 }  // anonymous namespace
 
 ScriptPromise Permissions::query(ScriptState* script_state,
                                  const Dictionary& raw_permission) {
   ExceptionState exception_state(script_state->GetIsolate(),
                                  ExceptionState::kGetterContext, "Permissions",
@@ skipping 195 matching lines @@
   result.ReserveInitialCapacity(caller_index_to_internal_index.size());
   for (int internal_index : caller_index_to_internal_index) {
     result.push_back(PermissionStatus::CreateAndListen(
         resolver->GetExecutionContext(), results[internal_index],
         descriptors[internal_index]->Clone()));
   }
   resolver->Resolve(result);
 }
 
 }  // namespace blink