Fix crash in MediaCaptureDevicesDispatcher::ProcessScreenCaptureAccessRequest.

chrome/browser/media/media_capture_devices_dispatcher.cc

 // Copyright (c) 2012 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/media_capture_devices_dispatcher.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 93 matching lines @@
   // Use extension name as title for extensions and origin for drive-by web.
   std::string title;
   if (extension) {
     title = extension->name();
   } else {
     title = web_contents->GetURL().GetOrigin().spec();
   }
   return UTF8ToUTF16(title);
 }
 
+// Helper to get list of media stream devices for desktop capture in |devices|.
+// Registers to display notification if |display_notification| is true.
+// Returns an instance of MediaStreamUI to be passed to content layer.
+scoped_ptr<content::MediaStreamUI> GetDevicesForDesktopCapture(
+    content::MediaStreamDevices& devices,
+    content::DesktopMediaID media_id,
+    bool capture_audio,
+    bool display_notification,
+    base::string16 application_title) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_ptr<content::MediaStreamUI> ui;
+
+  // Add selected desktop source to the list.
+  devices.push_back(content::MediaStreamDevice(
+      content::MEDIA_DESKTOP_VIDEO_CAPTURE, media_id.ToString(), "Screen"));
+  if (capture_audio) {
+    // Use the special loopback device ID for system audio capture.
+    devices.push_back(content::MediaStreamDevice(
+        content::MEDIA_LOOPBACK_AUDIO_CAPTURE,
+        media::AudioManagerBase::kLoopbackInputDeviceId, "System Audio"));
+  }
+
+  // If required, register to display the notification for stream capture.
+  if (display_notification) {
+    ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
+        IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT,
+        application_title));
+  }
+
+  return ui.Pass();
+}
+
 }  // namespace
 
 MediaCaptureDevicesDispatcher::PendingAccessRequest::PendingAccessRequest(
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback)
     : request(request),
       callback(callback) {
 }
 
 MediaCaptureDevicesDispatcher::PendingAccessRequest::~PendingAccessRequest() {}
@@ skipping 120 matching lines @@
           request.render_view_id, request.security_origin);
 
   // If the id wasn't generated using Desktop Capture API then process it as a
   // screen capture request.
   if (media_id.type == content::DesktopMediaID::TYPE_NONE) {
     ProcessScreenCaptureAccessRequest(
         web_contents, request, callback, extension);
     return;
   }
 
-  // Add selected desktop source to the list.
-  devices.push_back(content::MediaStreamDevice(
-      content::MEDIA_DESKTOP_VIDEO_CAPTURE, media_id.ToString(),
-      std::string()));
-
   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
 
   // Audio is only supported for screen capture streams.
-  if (media_id.type == content::DesktopMediaID::TYPE_SCREEN &&
-      request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
-      loopback_audio_supported) {
-    devices.push_back(content::MediaStreamDevice(
-        content::MEDIA_LOOPBACK_AUDIO_CAPTURE,
-        media::AudioManagerBase::kLoopbackInputDeviceId, "System Audio"));
-  }
+  bool capture_audio =
+      (media_id.type == content::DesktopMediaID::TYPE_SCREEN &&
+       request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
+       loopback_audio_supported);
 
-  ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
-      IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT,
-      GetApplicationTitle(web_contents, extension)));
+  ui = GetDevicesForDesktopCapture(
+      devices, media_id, capture_audio, true,
+      GetApplicationTitle(web_contents, extension));
 
   callback.Run(devices, ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::ProcessScreenCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
@@ skipping 36 matching lines @@
       request.security_origin.SchemeIsSecure() ||
       request.security_origin.SchemeIs(extensions::kExtensionScheme) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAllowHttpScreenCapture);
 
   // Approve request only when the following conditions are met:
   //  1. Screen capturing is enabled via command line switch or white-listed for
   //     the given origin.
   //  2. Request comes from a page with a secure origin or from an extension.
   if (screen_capture_enabled && origin_is_secure) {
+    // Get title of the calling application prior to showing the message box.
+    // chrome::ShowMessageBox() starts a nested message loop which may allow
+    // |web_contents| to be destroyed on the UI thread before the message box
+    // is closed. See http://crbug.com/326690.
+    base::string16 application_title =
+        GetApplicationTitle(web_contents, extension);
+    web_contents = NULL;
+
     // For component extensions, bypass message box.
     bool user_approved = false;
     if (!component_extension) {
       base::string16 application_name = UTF8ToUTF16(
           extension ? extension->name() : request.security_origin.spec());
       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::ShowMessageBox(
           NULL,
           l10n_util::GetStringFUTF16(
               IDS_MEDIA_SCREEN_CAPTURE_CONFIRMATION_TITLE, application_name),
           confirmation_text,
           chrome::MESSAGE_BOX_TYPE_QUESTION);
       user_approved = (result == chrome::MESSAGE_BOX_RESULT_YES);
     }
 
     if (user_approved || component_extension) {
-      devices.push_back(content::MediaStreamDevice(
-          content::MEDIA_DESKTOP_VIDEO_CAPTURE, media_id.ToString(), "Screen"));
-      if (request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
-          loopback_audio_supported) {
-        // Use the special loopback device ID for system audio capture.
-        devices.push_back(content::MediaStreamDevice(
-            content::MEDIA_LOOPBACK_AUDIO_CAPTURE,
-            media::AudioManagerBase::kLoopbackInputDeviceId, "System Audio"));
-      }
+      bool capture_audio =
+          (request.audio_type == content::MEDIA_LOOPBACK_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;
+
+      ui = GetDevicesForDesktopCapture(devices, media_id,  capture_audio,
+                                       display_notification, application_title);
     }
   }
 
-  // Unless we're being invoked from a component extension, register to display
-  // the notification for stream capture.
-  if (!devices.empty() && !component_extension) {
-    ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
-        IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT,
-        GetApplicationTitle(web_contents, extension)));
-  }
-
   callback.Run(devices, ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::ProcessTabCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   scoped_ptr<content::MediaStreamUI> ui;
@@ skipping 354 matching lines @@
     int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCreatingAudioStream(render_process_id, render_view_id));
 }
 
 bool MediaCaptureDevicesDispatcher::IsDesktopCaptureInProgress() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return desktop_capture_sessions_.size() > 0;
 }