Public Sessions - prompt the user for pageCapture requests

chrome/browser/chromeos/extensions/public_session_permission_helper.cc

Index: chrome/browser/chromeos/extensions/public_session_permission_helper.cc
diff --git a/chrome/browser/chromeos/extensions/public_session_permission_helper.cc b/chrome/browser/chromeos/extensions/public_session_permission_helper.cc
new file mode 100644
index 0000000000000000000000000000000000000000..07a7b908c5b126c098012d15830b4bd0a82fe905
--- /dev/null
+++ b/chrome/browser/chromeos/extensions/public_session_permission_helper.cc
@@ -0,0 +1,169 @@
+// Copyright 2017 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 "chrome/browser/chromeos/extensions/public_session_permission_helper.h"
+
+#include <map>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/lazy_instance.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/permissions/api_permission_set.h"
+#include "extensions/common/permissions/manifest_permission_set.h"
+#include "extensions/common/permissions/permission_set.h"
+#include "extensions/common/url_pattern_set.h"
+
+namespace extensions {
+
+namespace {
+
+base::LazyInstance<std::map<ExtensionId, PublicSessionPermissionHelper>>::Leaky
+    g_helpers = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+// static
+void PublicSessionPermissionHelper::HandlePermissionRequest(
+    const Extension& extension,
+    PermissionHelperSet requested_permissions,
+    content::WebContents* web_contents,
+    const base::Closure& success_callback,
+    const base::Closure& failure_callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return g_helpers.Get()[extension.id()].HandlePermissionRequestImpl(
+      extension, requested_permissions, web_contents, success_callback,
+      failure_callback);
+}
+
+// static
+bool PublicSessionPermissionHelper::PermissionAllowed(
+    ExtensionId extension_id,
+    APIPermission::ID permission_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return g_helpers.Get()[extension_id].PermissionAllowedImpl(permission_id);
+}
+
+PublicSessionPermissionHelper::PublicSessionPermissionHelper() {}
+
+PublicSessionPermissionHelper::PublicSessionPermissionHelper(
+    PublicSessionPermissionHelper&& other) = default;
+
+PublicSessionPermissionHelper::~PublicSessionPermissionHelper() {}
+
+void PublicSessionPermissionHelper::HandlePermissionRequestImpl(
+    const Extension& extension,
+    PermissionHelperSet requested_permissions,

[Andrew T Wilson (Slow), 2017/01/31 16:22:24]

Why does PermissionHelperSet exist? Why don't we just pass in PermissionIDSet
instead?

[Ivan Šandrk, 2017/02/01 18:11:29]

PermissionIDSet::ContainsAnyID() function accepts only
std::set<APIPermission::ID> argument. Plus the PermissionIDSet doesn't have a
nice constructor that can take an argument like {Permission_A} or {Permission_B,
Permission_C}.

I may make some modifications to PermissionIDSet so the ContainsAnyID function
supports PermissionIDSet, and the constructor behaves more nicely.

+    content::WebContents* web_contents,
+    const base::Closure& success_callback,
+    const base::Closure& failure_callback) {
+  CHECK(web_contents);
+
+  PermissionIDSet requested_permission_set;
+  for (auto permission : requested_permissions) {
+    requested_permission_set.insert(permission);
+  }
+
+  PermissionIDSet unresolved_permissions = PermissionIDSet::Difference(
+      requested_permission_set, allowed_permission_set_);
+  if (unresolved_permissions.empty()) {
+    success_callback.Run();
+    return;
+  }
+  unresolved_permissions = PermissionIDSet::Difference(
+      unresolved_permissions, denied_permission_set_);
+  if (unresolved_permissions.empty()) {

[Andrew T Wilson (Slow), 2017/01/31 16:22:24]

kind of weird, that even if we know the permissions request will fail (since
there is at least one denied permission) we still prompt the user for unresolved
permissions anyway. Not a huge deal, but kind of a weird API wrinkle based on
how you've defined the API (to have a failure callback that is invoked even
though some permissions have been granted).

[Ivan Šandrk, 2017/02/01 18:11:28]

Scraped completely the failure/success callbacks, using only one callback now.

+    failure_callback.Run();
+    return;
+  }
+
+  // Since not all permissions are resolved yet, queue the callback to be called
+  // when all of them are resolved.
+  callbacks_.push_back(RequestCallback(
+      success_callback, failure_callback, requested_permissions));
+
+  PermissionIDSet unprompted_permissions = PermissionIDSet::Difference(
+      unresolved_permissions, prompted_permission_set_);
+  if (unprompted_permissions.empty())

[Andrew T Wilson (Slow), 2017/01/31 16:22:24]

You should comment the various steps in this flow, because it's a bit subtle.
For example, I think in this case what's happening is you have one or more
permissions prompt on-screen right now, so no need to do anything further.

[Ivan Šandrk, 2017/02/01 18:11:29]

Done.

+    return;
+
+  APIPermissionSet new_apis;
+  for (const auto& permission : unprompted_permissions) {
+    prompted_permission_set_.insert(permission.id());
+    new_apis.insert(permission.id());
+  }
+  auto permission_set = base::MakeUnique<PermissionSet>(
+      new_apis, ManifestPermissionSet(), URLPatternSet(), URLPatternSet());
+  auto prompt = base::MakeUnique<ExtensionInstallPrompt>(web_contents);
+  // This Unretained is safe because the lifetime of this object is until
+  // process exit.
+  prompt->ShowDialog(
+      base::Bind(&PublicSessionPermissionHelper::ResolvePermissionPrompt,
+                 base::Unretained(this), &prompt,
+                 std::move(unprompted_permissions)),
+      &extension,
+      nullptr,  // Use the extension icon.
+      base::MakeUnique<ExtensionInstallPrompt::Prompt>(
+          ExtensionInstallPrompt::PERMISSIONS_PROMPT),
+      std::move(permission_set),
+      ExtensionInstallPrompt::GetDefaultShowDialogCallback());
+  prompts_.insert(std::move(prompt));
+}
+
+bool PublicSessionPermissionHelper::PermissionAllowedImpl(
+    APIPermission::ID permission_id) {
+  return allowed_permission_set_.ContainsID(permission_id);
+}
+
+void PublicSessionPermissionHelper::ResolvePermissionPrompt(
+    const std::unique_ptr<ExtensionInstallPrompt>* prompt,
+    const PermissionIDSet& unprompted_permissions,
+    ExtensionInstallPrompt::Result prompt_result) {
+  // Dispose of the prompt as it's not needed anymore.
+  size_t erased = prompts_.erase(*prompt);
+  DCHECK_EQ(1u, erased);
+
+  bool allowed = prompt_result == ExtensionInstallPrompt::Result::ACCEPTED;

[Andrew T Wilson (Slow), 2017/01/31 16:22:24]

this is fine, but maybe make it clear that this is a shorthand for
(prompt_result == ACCEPTED) by marking it as "const bool allowed".

[Ivan Šandrk, 2017/02/01 18:11:28]

Done.

+  for (const auto& permission : unprompted_permissions) {
+    prompted_permission_set_.erase(permission.id());
+    if (allowed)
+      allowed_permission_set_.insert(permission.id());
+    else
+      denied_permission_set_.insert(permission.id());
+  }
+
+  for (auto callback = callbacks_.begin(); callback != callbacks_.end(); ) {
+    if (prompted_permission_set_.ContainsAnyID(callback->permission_list)) {
+      // The request is still waiting on other permissions to be resolved - wait
+      // until all of them are resolved before calling the callback.
+      callback++;
+      continue;
+    }
+    if (denied_permission_set_.ContainsAnyID(callback->permission_list))
+      callback->failure_callback.Run();
+    else
+      callback->success_callback.Run();
+    callback = callbacks_.erase(callback);
+  }
+}
+
+PublicSessionPermissionHelper::RequestCallback::RequestCallback(
+    const base::Closure& success_callback,
+    const base::Closure& failure_callback,
+    const PermissionHelperSet& permission_list)
+    : success_callback(success_callback),
+      failure_callback(failure_callback),
+      permission_list(permission_list) {}
+
+PublicSessionPermissionHelper::RequestCallback::RequestCallback(
+    const RequestCallback& other) = default;
+
+PublicSessionPermissionHelper::RequestCallback::~RequestCallback() {}
+
+}  // namespace extensions