Public Sessions - prompt the user for pageCapture requests

chrome/browser/media/public_session_media_access_handler.cc

 // 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 "chrome/browser/media/public_session_media_access_handler.h"
 
+#include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
+#include "chrome/browser/chromeos/extensions/public_session_permission_helper.h"
+#include "chrome/browser/profiles/profiles_state.h"
 #include "chromeos/login/login_state.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/manifest_permission_set.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/url_pattern_set.h"
 
-namespace {
-
-// Returns true if we're in a Public Session.
-bool IsPublicSession() {
-  return chromeos::LoginState::IsInitialized() &&
-         chromeos::LoginState::Get()->IsPublicSessionUser();
-}
-
-}  // namespace
-
 PublicSessionMediaAccessHandler::PublicSessionMediaAccessHandler() {}
 
 PublicSessionMediaAccessHandler::~PublicSessionMediaAccessHandler() {}
 
 bool PublicSessionMediaAccessHandler::SupportsStreamType(
     const content::MediaStreamType type,
     const extensions::Extension* extension) {
   return extension_media_access_handler_.SupportsStreamType(type, extension);
 }
 
 bool PublicSessionMediaAccessHandler::CheckMediaAccessPermission(
     content::WebContents* web_contents,
     const GURL& security_origin,
     content::MediaStreamType type,
     const extensions::Extension* extension) {
   return extension_media_access_handler_.CheckMediaAccessPermission(
       web_contents, security_origin, type, extension);
 }
 
 void PublicSessionMediaAccessHandler::HandleRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   // This class handles requests for Public Sessions only, outside of them just
   // pass the request through to the original class.
-  if (!IsPublicSession() || !extension->is_platform_app()) {
+  if (!profiles::IsPublicSession() || !extension->is_platform_app()) {
     return extension_media_access_handler_.HandleRequest(web_contents, request,
                                                          callback, extension);
   }
 
-  bool needs_prompt = false;
-  extensions::APIPermissionSet new_apis;
-  UserChoice& user_choice = user_choice_cache_[extension->id()];
+  // This Unretained is safe because the lifetime of this object is until
+  // process exit (living inside a base::Singleton object).
+  auto prompt_resolved_callback = base::Bind(
+      &PublicSessionMediaAccessHandler::ChainHandleRequest,
+      base::Unretained(this), web_contents, request, callback, extension);
 
-  if (user_choice.NeedsPrompting(request.audio_type)) {
-    new_apis.insert(extensions::APIPermission::kAudioCapture);
-    user_choice.SetPrompted(content::MEDIA_DEVICE_AUDIO_CAPTURE);
-    needs_prompt = true;
-  }
-  if (user_choice.NeedsPrompting(request.video_type)) {
-    new_apis.insert(extensions::APIPermission::kVideoCapture);
-    user_choice.SetPrompted(content::MEDIA_DEVICE_VIDEO_CAPTURE);
-    needs_prompt = true;
-  }
+  extensions::PermissionIDSet requested_permissions;
+  if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE)
+    requested_permissions.insert(extensions::APIPermission::kAudioCapture);
+  if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE)
+    requested_permissions.insert(extensions::APIPermission::kVideoCapture);
 
-  if (!needs_prompt)
-    return ChainHandleRequest(web_contents, request, callback, extension);
-
-  auto permission_set = base::MakeUnique<extensions::PermissionSet>(
-      new_apis, extensions::ManifestPermissionSet(),
-      extensions::URLPatternSet(), extensions::URLPatternSet());
-
-  auto prompt = base::MakeUnique<ExtensionInstallPrompt>(web_contents);
-
-  prompt->ShowDialog(
-      base::Bind(&PublicSessionMediaAccessHandler::ResolvePermissionPrompt,
-                 base::Unretained(this), web_contents, request, callback,
-                 extension),
-      extension,
-      nullptr,  // Uses the extension icon.
-      base::MakeUnique<ExtensionInstallPrompt::Prompt>(
-          ExtensionInstallPrompt::PERMISSIONS_PROMPT),
-      std::move(permission_set),
-      ExtensionInstallPrompt::GetDefaultShowDialogCallback());
-
-  extension_install_prompt_map_[extension->id()] = std::move(prompt);
+  extensions::permission_helper::HandlePermissionRequest(
+      *extension, requested_permissions, web_contents, prompt_resolved_callback,
+      extensions::permission_helper::PromptFactory());
 }
 
 void PublicSessionMediaAccessHandler::ChainHandleRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
-    const extensions::Extension* extension) {
-  DCHECK(IsPublicSession() && extension && extension->is_platform_app());
-  const UserChoice& user_choice = user_choice_cache_[extension->id()];
+    const extensions::Extension* extension,
+    const extensions::PermissionIDSet& allowed_permissions) {
   content::MediaStreamRequest request_copy(request);
 
   // If the user denies audio or video capture, here it gets filtered out from
   // the request before being passed on to the actual implementation.
-  if (!user_choice.IsAllowed(content::MEDIA_DEVICE_AUDIO_CAPTURE))
+  if (!allowed_permissions.ContainsID(extensions::APIPermission::kAudioCapture))
     request_copy.audio_type = content::MEDIA_NO_SERVICE;
-  if (!user_choice.IsAllowed(content::MEDIA_DEVICE_VIDEO_CAPTURE))
+  if (!allowed_permissions.ContainsID(extensions::APIPermission::kVideoCapture))
     request_copy.video_type = content::MEDIA_NO_SERVICE;
 
   // Pass the request through to the original class.
   extension_media_access_handler_.HandleRequest(web_contents, request_copy,
                                                 callback, extension);
 }
-
-void PublicSessionMediaAccessHandler::ResolvePermissionPrompt(
-    content::WebContents* web_contents,
-    const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback,
-    const extensions::Extension* extension,
-    ExtensionInstallPrompt::Result prompt_result) {
-  // Dispose of the prompt as it's not needed anymore.
-  extension_install_prompt_map_.erase(extension->id());
-
-  bool allowed = prompt_result == ExtensionInstallPrompt::Result::ACCEPTED;
-  UserChoice& user_choice = user_choice_cache_[extension->id()];
-
-  if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE)
-    user_choice.Set(content::MEDIA_DEVICE_AUDIO_CAPTURE, allowed);
-  if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE)
-    user_choice.Set(content::MEDIA_DEVICE_VIDEO_CAPTURE, allowed);
-
-  ChainHandleRequest(web_contents, request, callback, extension);
-}
-
-bool PublicSessionMediaAccessHandler::UserChoice::IsAllowed(
-    content::MediaStreamType type) const {
-  switch (type) {
-    case content::MEDIA_DEVICE_AUDIO_CAPTURE:
-      return !audio_prompted_ || audio_allowed_;
-    case content::MEDIA_DEVICE_VIDEO_CAPTURE:
-      return !video_prompted_ || video_allowed_;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool PublicSessionMediaAccessHandler::UserChoice::NeedsPrompting(
-    content::MediaStreamType type) const {
-  switch (type) {
-    case content::MEDIA_DEVICE_AUDIO_CAPTURE:
-      return !audio_prompted_;
-    case content::MEDIA_DEVICE_VIDEO_CAPTURE:
-      return !video_prompted_;
-    default:
-      return false;
-  }
-}
-
-void PublicSessionMediaAccessHandler::UserChoice::Set(
-    content::MediaStreamType type,
-    bool allowed) {
-  switch (type) {
-    case content::MEDIA_DEVICE_AUDIO_CAPTURE:
-      audio_allowed_ = allowed;
-      break;
-    case content::MEDIA_DEVICE_VIDEO_CAPTURE:
-      video_allowed_ = allowed;
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
-void PublicSessionMediaAccessHandler::UserChoice::SetPrompted(
-    content::MediaStreamType type) {
-  switch (type) {
-    case content::MEDIA_DEVICE_AUDIO_CAPTURE:
-      audio_prompted_ = true;
-      break;
-    case content::MEDIA_DEVICE_VIDEO_CAPTURE:
-      video_prompted_ = true;
-      break;
-    default:
-      NOTREACHED();
-  }
-}