Public Sessions - prompt the user for pageCapture requests

extensions/common/permissions/api_permission_set.cc

 // Copyright 2013 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 "extensions/common/permissions/api_permission_set.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 179 matching lines @@
                            const base::string16& parameter)
     : std::pair<APIPermission::ID, base::string16>(id, parameter) {
 }
 
 PermissionID::~PermissionID() {
 }
 
 PermissionIDSet::PermissionIDSet() {
 }
 
+PermissionIDSet::PermissionIDSet(
+    const std::initializer_list<APIPermission::ID>& permissions) {

[Devlin, 2017/02/10 19:54:46]

nit: if we make this a pass-by-value (or rvalue ref, if you prefer)
initializer_list, we could then also just do
PermissionIDSet::PermissionIDSet(
    std::initializer_list<ID> permissions)
    : permissions_(std::move(permissions)) {}

[Ivan Šandrk, 2017/02/13 13:18:20]

This doesn't really compile. I've tried getting it to work before, the problem
is that this class stores a set<PermissionID>, while we pass in a list of
APIPermission::ID.

Maybe I'm missing something, this is the error output from the compiler
https://paste.googleplex.com/5486718933270528

[Devlin, 2017/02/13 22:33:59]

Oh, grr, you're right.  Not something you should have to fix in this cl.  This
is fine.

+  for (auto permission : permissions) {
+    permissions_.insert(PermissionID(permission));
+  }
+}
+
 PermissionIDSet::PermissionIDSet(const PermissionIDSet& other) = default;
 
 PermissionIDSet::~PermissionIDSet() {
 }
 
 void PermissionIDSet::insert(APIPermission::ID permission_id) {
   insert(permission_id, base::string16());
 }
 
 void PermissionIDSet::insert(APIPermission::ID permission_id,
@@ skipping 19 matching lines @@
 
 std::vector<base::string16> PermissionIDSet::GetAllPermissionParameters()
     const {
   std::vector<base::string16> params;
   for (const auto& permission : permissions_) {
     params.push_back(permission.parameter());
   }
   return params;
 }
 
+bool PermissionIDSet::ContainsID(PermissionID permission_id) const {
+  auto it = permissions_.lower_bound(permission_id);
+  return it != permissions_.end() && it->id() == permission_id.id();
+}
+
 bool PermissionIDSet::ContainsID(APIPermission::ID permission_id) const {
-  auto it = permissions_.lower_bound(PermissionID(permission_id));
-  return it != permissions_.end() && it->id() == permission_id;
+  return ContainsID(PermissionID(permission_id));
 }
 
 bool PermissionIDSet::ContainsAllIDs(
     const std::set<APIPermission::ID>& permission_ids) const {
   return std::includes(permissions_.begin(), permissions_.end(),
                        permission_ids.begin(), permission_ids.end(),
                        [] (const PermissionIDCompareHelper& lhs,
                            const PermissionIDCompareHelper& rhs) {
                          return lhs.id < rhs.id;
                        });
 }
 
 bool PermissionIDSet::ContainsAnyID(
     const std::set<APIPermission::ID>& permission_ids) const {
   for (APIPermission::ID id : permission_ids) {
     if (ContainsID(id))
       return true;
   }
   return false;
 }
 
+bool PermissionIDSet::ContainsAnyID(const PermissionIDSet& other) const {
+  for (const auto& id : other) {
+    if (ContainsID(id))
+      return true;
+  }
+  return false;
+}
+
 PermissionIDSet PermissionIDSet::GetAllPermissionsWithID(
     APIPermission::ID permission_id) const {
   PermissionIDSet subset;
   auto it = permissions_.lower_bound(PermissionID(permission_id));
   while (it != permissions_.end() && it->id() == permission_id) {
     subset.permissions_.insert(*it);
     ++it;
   }
   return subset;
 }
@@ skipping 30 matching lines @@
 
 bool PermissionIDSet::empty() const {
   return permissions_.empty();
 }
 
 PermissionIDSet::PermissionIDSet(const std::set<PermissionID>& permissions)
     : permissions_(permissions) {
 }
 
 }  // namespace extensions