Extend content::DesktopMediaID to allow Aura windows as capture sources.

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"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 #include "chrome/browser/media/audio_stream_indicator.h"
 #include "chrome/browser/media/desktop_streams_registry.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/media/media_stream_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/screen_capture_notification_ui.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/desktop_media_id.h"
 #include "content/public/browser/media_devices_monitor.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/desktop_media_id.h"
 #include "content/public/common/media_stream_request.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "grit/generated_resources.h"
 #include "media/audio/audio_manager_base.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(OS_CHROMEOS)
+#include "ash/shell.h"
+#endif  //  defined(OS_CHROMEOS)
+
 using content::BrowserThread;
 using content::MediaStreamDevices;
 
 namespace {
 
 // Finds a device in |devices| that has |device_id|, or NULL if not found.
 const content::MediaStreamDevice* FindDeviceWithId(
     const content::MediaStreamDevices& devices,
     const std::string& device_id) {
   content::MediaStreamDevices::const_iterator iter = devices.begin();
@@ skipping 178 matching lines @@
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   scoped_ptr<content::MediaStreamUI> ui;
 
   if (request.video_type != content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
     callback.Run(devices, ui.Pass());
     return;
   }
 
-  // First check if Desktop Capture API (i.e.
-  // chrome.desktopCapture.chooseDesktopMedia()) was used to generate device Id.
+  // If the device id wasn't specified then this is a screen capture request
+  // (i.e. chooseDesktopMedia() API wasn't used to generate device id).
+  if (request.requested_video_device_id.empty()) {
+    ProcessScreenCaptureAccessRequest(
+        web_contents, request, callback, extension);
+    return;
+  }
+
+  // Resolve DesktopMediaID for the specified device id.
   content::DesktopMediaID media_id =
       GetDesktopStreamsRegistry()->RequestMediaForStreamId(
           request.requested_video_device_id, request.render_process_id,
           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.
+  // Received invalid device id.
   if (media_id.type == content::DesktopMediaID::TYPE_NONE) {
-    ProcessScreenCaptureAccessRequest(
-        web_contents, request, callback, extension);
+    callback.Run(devices, ui.Pass());
     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)
@@ skipping 20 matching lines @@
 void MediaCaptureDevicesDispatcher::ProcessScreenCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   scoped_ptr<content::MediaStreamUI> ui;
 
   DCHECK_EQ(request.video_type, content::MEDIA_DESKTOP_VIDEO_CAPTURE);
 
-  content::DesktopMediaID media_id =
-      content::DesktopMediaID::Parse(request.requested_video_device_id);
-  if (media_id.is_null()) {
-    LOG(ERROR) << "Invalid desktop media ID: "
-               << request.requested_video_device_id;
-    callback.Run(devices, ui.Pass());
-    return;
-  }
-
-  // Only screen capture can be requested without using desktop media picker.
-  if (media_id.type != content::DesktopMediaID::TYPE_SCREEN) {
-    LOG(ERROR) << "Unsupported desktop media ID: "
-               << request.requested_video_device_id;
-    callback.Run(devices, ui.Pass());
-    return;
-  }
-
   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
 
   const bool component_extension =
       extension && extension->location() == extensions::Manifest::COMPONENT;
 
   const bool screen_capture_enabled =
@@ skipping 25 matching lines @@
       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"));
+      content::DesktopMediaID screen_id;
+#if defined(OS_CHROMEOS)
+      screen_id = content::DesktopMediaID::RegisterAuraWindow(
+          ash::Shell::GetInstance()->GetPrimaryRootWindow());
+#else  // defined(OS_CHROMEOS)
+      screen_id =
+          content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN, 0);
+#endif  // !defined(OS_CHROMEOS)
+      devices.push_back(
+          content::MediaStreamDevice(content::MEDIA_DESKTOP_VIDEO_CAPTURE,
+                                     screen_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"));
       }
     }
   }
 
@@ skipping 344 matching lines @@
                                     state));
 }
 
 void MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread(
     int render_process_id,
     int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCreatingAudioStream(render_process_id, render_view_id));
 }