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..b6dce0dac8b26d9acd4671b8d08c6852e6459f77
--- /dev/null
+++ b/chrome/browser/chromeos/extensions/public_session_permission_helper.cc
@@ -0,0 +1,46 @@
+// 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 "chrome/browser/chromeos/extensions/public_session_permission_helper_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "extensions/common/extension.h"
+
+namespace extensions {
+namespace permission_helper {
+
+// static
+PublicSessionPermissionHelper& PublicSessionPermissionHelper::Instance() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  CR_DEFINE_STATIC_LOCAL(PublicSessionPermissionHelper, instance, ());

[Devlin, 2017/01/23 22:59:48]

usually for something like this, we prefer LazyInstance

[Ivan Šandrk, 2017/01/24 19:57:22]

Why?

[Devlin, 2017/01/25 16:00:31]

Mostly just because it is the canonical, known-to-be-safe, easy way to create a
singleton instance of an object.  That's not to say it's the only way, or is
concretely better than alternatives, but we prefer using the common patterns we
have so that readers instantly know how it works and how to use it.

[Ivan Šandrk, 2017/01/26 18:53:21]

I meant why as in why LazyInstance over CR_DEFINE_STATIC_LOCAL :) CR is
obviously also used across the codebase, and for the same purpose of creating a
singleton (eg. https://goo.gl/Nrnlll). Why have two things to do one thing in
the codebase anyway?

I'd say the CR is also a canonical way to create a singleton (Meyers singleton)
- https://yaqs.googleplex.com/eng/q/5555555103932416. Maybe even simpler than
LazyInstance now that we have C++11 (in terms of implementation), because as far
as I can tell LazyInstance was used over CR because it was thread safe.

Anyway since you're the owner you make the call :)

+  return instance;
+}
+
+void PublicSessionPermissionHelper::HandlePermissionRequest(
+    const Extension* extension,
+    PermissionHelperSet requested_permissions,
+    content::WebContents* web_contents,
+    const base::Closure& success_callback,
+    const base::Closure& failure_callback) {
+  CHECK(extension);
+  impl_[extension->id()].HandlePermissionRequest(
+      extension,
+      requested_permissions,
+      web_contents,
+      success_callback,
+      failure_callback);
+}
+
+PermissionState PublicSessionPermissionHelper::GetUserChoice(
+    ExtensionId extension_id, APIPermission::ID permission_id) {
+  return impl_[extension_id].GetUserChoice(permission_id);
+}
+
+PublicSessionPermissionHelper::PublicSessionPermissionHelper() {}
+
+PublicSessionPermissionHelper::~PublicSessionPermissionHelper() {}
+
+}  // namespace permission_helper
+}  // namespace extensions