[Media Router] Remove desktop capture prompts.

chrome/browser/media/webrtc/desktop_capture_access_handler.cc

 // Copyright 2015 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/desktop_capture_access_handler.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 44 matching lines @@
   if (extension) {
     title = extension->name();
     return base::UTF8ToUTF16(title);
   }
   GURL url = web_contents->GetURL();
   title = content::IsOriginSecure(url) ? net::GetHostAndOptionalPort(url)
                                        : url.GetOrigin().spec();
   return base::UTF8ToUTF16(title);
 }
 
+// Returns whether an on-screen notification should appear after desktop capture
+// is approved for |extension|.  Component extensions do not display a
+// notification.
+bool ShouldDisplayNotification(const extensions::Extension* extension) {
+  return !(extension &&
+           (extension->location() == extensions::Manifest::COMPONENT ||
+            extension->location() == extensions::Manifest::EXTERNAL_COMPONENT));
+}
+
 base::string16 GetStopSharingUIString(
     const base::string16& application_title,
     const base::string16& registered_extension_name,
     bool capture_audio,
     content::DesktopMediaID::Type capture_type) {
   if (!capture_audio) {
     if (application_title == registered_extension_name) {
       switch (capture_type) {
         case content::DesktopMediaID::TYPE_SCREEN:
           return l10n_util::GetStringFUTF16(
@@ skipping 65 matching lines @@
     content::MediaStreamDevices* devices,
     content::DesktopMediaID media_id,
     bool capture_audio,
     bool mute_system_audio,
     bool display_notification,
     const base::string16& application_title,
     const base::string16& registered_extension_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::unique_ptr<content::MediaStreamUI> ui;
 
+  DVLOG(2) << __FUNCTION__ << ": media_id " << media_id.ToString()
+           << ", capture_audio " << capture_audio << ", mute_system_audio "
+           << mute_system_audio << ", display_notification "
+           << display_notification << ", application_title "
+           << application_title << ", extension_name "
+           << registered_extension_name;
+
   // Add selected desktop source to the list.
   devices->push_back(content::MediaStreamDevice(
       content::MEDIA_DESKTOP_VIDEO_CAPTURE, media_id.ToString(), "Screen"));
   if (capture_audio) {
     if (media_id.type == content::DesktopMediaID::TYPE_WEB_CONTENTS) {
       devices->push_back(
           content::MediaStreamDevice(content::MEDIA_DESKTOP_AUDIO_CAPTURE,
                                      media_id.ToString(), "Tab audio"));
     } else if (mute_system_audio) {
       // Use the special loopback device ID for system audio capture.
@@ skipping 63 matching lines @@
   DCHECK_EQ(request.video_type, content::MEDIA_DESKTOP_VIDEO_CAPTURE);
 
   UpdateExtensionTrusted(request, extension);
 
   bool loopback_audio_supported = false;
 #if defined(USE_CRAS) || defined(OS_WIN)
   // Currently loopback audio capture is supported only on Windows and ChromeOS.
   loopback_audio_supported = true;
 #endif
 
-  bool component_extension = false;
-  component_extension =
-      extension && extension->location() == extensions::Manifest::COMPONENT;
-
   bool screen_capture_enabled =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableUserMediaScreenCapturing) ||
       MediaCaptureDevicesDispatcher::IsOriginForCasting(
           request.security_origin) ||
       IsExtensionWhitelistedForScreenCapture(extension) ||
       IsBuiltInExtension(request.security_origin);
 
   const bool origin_is_secure =
       content::IsOriginSecure(request.security_origin) ||
@@ skipping 20 matching lines @@
     base::string16 application_title =
         GetApplicationTitle(web_contents, extension);
 #if !defined(OS_ANDROID)
     gfx::NativeWindow parent_window =
         FindParentWindowForWebContents(web_contents);
 #else
     gfx::NativeWindow parent_window = NULL;
 #endif
     web_contents = NULL;
 
-    bool whitelisted_extension =
-        IsExtensionWhitelistedForScreenCapture(extension);
-
-    // For whitelisted or component extensions, bypass message box.
-    bool user_approved = false;
-    if (!whitelisted_extension && !component_extension) {
+    // Some extensions do not require user approval, because they provide their
+    // own user approval UI.
+    bool is_approved = IsDefaultApproved(extension);
+    if (!is_approved) {
       base::string16 application_name =
           base::UTF8ToUTF16(request.security_origin.spec());
       if (extension)
         application_name = base::UTF8ToUTF16(extension->name());
       base::string16 confirmation_text = l10n_util::GetStringFUTF16(
           request.audio_type == content::MEDIA_NO_SERVICE
               ? IDS_MEDIA_SCREEN_CAPTURE_CONFIRMATION_TEXT
               : IDS_MEDIA_SCREEN_AND_AUDIO_CAPTURE_CONFIRMATION_TEXT,
           application_name);
       chrome::MessageBoxResult result = chrome::ShowQuestionMessageBox(
           parent_window,
           l10n_util::GetStringFUTF16(
               IDS_MEDIA_SCREEN_CAPTURE_CONFIRMATION_TITLE, application_name),
           confirmation_text);
-      user_approved = (result == chrome::MESSAGE_BOX_RESULT_YES);
+      is_approved = (result == chrome::MESSAGE_BOX_RESULT_YES);
     }
 
-    if (user_approved || component_extension || whitelisted_extension) {
+    if (is_approved) {
       content::DesktopMediaID screen_id;
 #if defined(OS_CHROMEOS)
       screen_id = content::DesktopMediaID::RegisterAuraWindow(
           content::DesktopMediaID::TYPE_SCREEN,
           ash::Shell::GetInstance()->GetPrimaryRootWindow());
 #else   // defined(OS_CHROMEOS)
       screen_id = content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN,
                                           webrtc::kFullDesktopScreenId);
 #endif  // !defined(OS_CHROMEOS)
 
       bool capture_audio =
           (request.audio_type == content::MEDIA_DESKTOP_AUDIO_CAPTURE &&
            loopback_audio_supported);
 
-      // Unless we're being invoked from a component extension, register to
-      // display the notification for stream capture.
-      bool display_notification = !component_extension;
+      // Determine if the extension is required to display a notification.
+      const bool display_notification = ShouldDisplayNotification(extension);
 
       ui = GetDevicesForDesktopCapture(&devices, screen_id, capture_audio, true,
                                        display_notification, application_title,
                                        application_title);
       DCHECK(!devices.empty());
     }
 
     // The only case when devices can be empty is if the user has denied
     // permission.
     result = devices.empty() ? content::MEDIA_DEVICE_PERMISSION_DENIED
                              : content::MEDIA_DEVICE_OK;
   }
 
   callback.Run(devices, result, std::move(ui));
 }
 
+bool DesktopCaptureAccessHandler::IsDefaultApproved(
+    const extensions::Extension* extension) {
+  return extension &&
+         (extension->location() == extensions::Manifest::COMPONENT ||
+          extension->location() == extensions::Manifest::EXTERNAL_COMPONENT ||
+          IsExtensionWhitelistedForScreenCapture(extension));
+}
+
 bool DesktopCaptureAccessHandler::SupportsStreamType(
     const content::MediaStreamType type,
     const extensions::Extension* extension) {
   return type == content::MEDIA_DESKTOP_VIDEO_CAPTURE ||
          type == content::MEDIA_DESKTOP_AUDIO_CAPTURE;
 }
 
 bool DesktopCaptureAccessHandler::CheckMediaAccessPermission(
     content::WebContents* web_contents,
     const GURL& security_origin,
@@ skipping 74 matching lines @@
        loopback_audio_supported) ||
       media_id.type == content::DesktopMediaID::TYPE_WEB_CONTENTS;
 
   const bool check_audio_permission =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           extensions::switches::kDisableDesktopCaptureAudio);
   const bool capture_audio =
       (check_audio_permission ? audio_permitted : true) && audio_requested &&
       audio_supported;
 
+  // Determine if the extension is required to display a notification.
+  const bool display_notification = ShouldDisplayNotification(extension);
+
   ui = GetDevicesForDesktopCapture(&devices, media_id, capture_audio, false,
-                                   true,
+                                   display_notification,
                                    GetApplicationTitle(web_contents, extension),
                                    base::UTF8ToUTF16(original_extension_name));
   UpdateExtensionTrusted(request, extension);
   callback.Run(devices, content::MEDIA_DEVICE_OK, std::move(ui));
 }
-