Public Sessions - prompt the user for pageCapture requests

chrome/browser/media/webrtc/public_session_tab_capture_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/webrtc/public_session_tab_capture_access_handler.h"
 
 #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
-
 PublicSessionTabCaptureAccessHandler::PublicSessionTabCaptureAccessHandler() {}
 
 PublicSessionTabCaptureAccessHandler::~PublicSessionTabCaptureAccessHandler() {}
 
 bool PublicSessionTabCaptureAccessHandler::SupportsStreamType(
     const content::MediaStreamType type,
     const extensions::Extension* extension) {
   return tab_capture_access_handler_.SupportsStreamType(type, extension);
 }
 
 bool PublicSessionTabCaptureAccessHandler::CheckMediaAccessPermission(
     content::WebContents* web_contents,
     const GURL& security_origin,
     content::MediaStreamType type,
     const extensions::Extension* extension) {
   return tab_capture_access_handler_.CheckMediaAccessPermission(
       web_contents, security_origin, type, extension);
 }
 
 void PublicSessionTabCaptureAccessHandler::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) {
+  if (!profiles::IsPublicSession() || !extension ||
+      (request.audio_type != content::MEDIA_TAB_AUDIO_CAPTURE &&
+       request.video_type != content::MEDIA_TAB_VIDEO_CAPTURE)) {
     return tab_capture_access_handler_.HandleRequest(web_contents, request,
                                                      callback, extension);
   }
 
-  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(
+      &PublicSessionTabCaptureAccessHandler::ChainHandleRequest,
+      base::Unretained(this), web_contents, request, callback, extension);
 
-  if ((request.audio_type != content::MEDIA_TAB_AUDIO_CAPTURE &&
-       request.video_type != content::MEDIA_TAB_VIDEO_CAPTURE) ||
-      !user_choice.NeedsPrompting()) {
-    return ChainHandleRequest(web_contents, request, callback, extension);
-  }
-
-  user_choice.SetPrompted();
-
-  extensions::APIPermissionSet new_apis;
-  new_apis.insert(extensions::APIPermission::kTabCapture);
-  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(&PublicSessionTabCaptureAccessHandler::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, {extensions::APIPermission::kTabCapture}, web_contents,
+      prompt_resolved_callback);
 }
 
 void PublicSessionTabCaptureAccessHandler::ChainHandleRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
-    const extensions::Extension* extension) {
-  DCHECK(IsPublicSession() && extension);
-  const UserChoice& user_choice = user_choice_cache_[extension->id()];
+    const extensions::Extension* extension,
+    extensions::PermissionIDSet allowed_permissions) {
+  DCHECK(profiles::IsPublicSession() && extension);

[Andrew T Wilson (Slow), 2017/02/07 14:26:51]

BTW, if this DCHECK is hit, it won't be clear which part of the expression
evaluated to false. So you might want to just have 2 DCHECKs.

[Ivan Šandrk, 2017/02/07 20:41:32]

Good point. Though I've decided to completely remove this DCHECK as it isn't
really useful or neccessary (the function shouldn't even be called because of
the if clause above).

   content::MediaStreamRequest request_copy(request);
 
   // If the user denied tab capture, here the request gets filtered out before
   // being passed on to the actual implementation.
-  if (!user_choice.IsAllowed()) {
+  if (!allowed_permissions.ContainsID(extensions::APIPermission::kTabCapture)) {
     request_copy.audio_type = content::MEDIA_NO_SERVICE;
     request_copy.video_type = content::MEDIA_NO_SERVICE;
   }
 
   // Pass the request through to the original class.
   tab_capture_access_handler_.HandleRequest(web_contents, request_copy,
                                             callback, extension);
 }
-
-void PublicSessionTabCaptureAccessHandler::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()];
-
-  user_choice.Set(allowed);
-
-  ChainHandleRequest(web_contents, request, callback, extension);
-}
-
-bool PublicSessionTabCaptureAccessHandler::UserChoice::IsAllowed() const {
-  return tab_capture_allowed_;
-}
-
-bool PublicSessionTabCaptureAccessHandler::UserChoice::NeedsPrompting() const {
-  return !tab_capture_prompted_;
-}
-
-void PublicSessionTabCaptureAccessHandler::UserChoice::Set(bool allowed) {
-  tab_capture_allowed_ = allowed;
-}
-
-void PublicSessionTabCaptureAccessHandler::UserChoice::SetPrompted() {
-  tab_capture_prompted_ = true;
-}