Browser-wide audio mirroring for TabCapture API

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 91 matching lines @@
 
     if (options.video_type != MEDIA_TAB_VIDEO_CAPTURE &&
         options.audio_type != MEDIA_TAB_AUDIO_CAPTURE)
       return;
 
     MediaObserver* media_observer =
         GetContentClient()->browser()->GetMediaObserver();
     if (media_observer == NULL)
       return;
 
+    std::string device_id = requested_device_id;
+    if (WebContentsCaptureUtil::IsWebContentsDeviceId(requested_device_id))
+      device_id = WebContentsCaptureUtil::StripWebContentsDeviceScheme(
+          requested_device_id);
+

[no longer working on chromium, 2012/11/26 22:20:07]

can this (WebContentsCaptureUtil::IsWebContentsDeviceId(requested_device_id)) be
false here, if not, add a unreached()

[justinlin, 2012/11/27 22:26:12]

Done. Actually don't need the "if" anymore.

     media_observer->OnMediaRequestStateChanged(
       render_process_id, render_view_id,
       MediaStreamDevice(
-          stream_type, requested_device_id, requested_device_id), new_state);
+          stream_type, device_id, device_id), new_state);
   }
 
   MediaRequestState getState(MediaStreamType stream_type) const {
     return state_[stream_type];
   }
 
   MediaStreamRequester* requester;  // Can be NULL.
   StreamOptions options;
   RequestType type;
   int render_process_id;
@@ skipping 113 matching lines @@
     const GURL& security_origin, std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request based on options.
   AddRequest(DeviceRequest(requester, options,
                            DeviceRequest::GENERATE_STREAM,
                            render_process_id, render_view_id,
                            security_origin),
              label);
   DeviceRequest& request = requests_[*label];
+
   request.requested_device_id = device_id;
 
   // Get user confirmation to use the capture device.
   PostRequestToUI(*label);
 
   if (!security_origin.SchemeIs(kExtensionScheme) ||
       (options.audio_type != MEDIA_TAB_AUDIO_CAPTURE &&
        options.audio_type != MEDIA_NO_SERVICE) ||
       (options.video_type != MEDIA_TAB_VIDEO_CAPTURE &&
        options.video_type != MEDIA_NO_SERVICE)) {
     LOG(ERROR) << "Invalid request or used tab capture outside extension API.";
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&MediaStreamManager::CancelRequest,
                    base::Unretained(this), *label));
     return;
   }
 
   // TODO(miu): We should ask the device manager whether a device with id
   // |device_id| actually exists.  Note that no such MediaStreamProvider API for
   // this currently exists.  Also, we don't have a user-friendly device name for
   // the infobar UI.
   if (IsAudioMediaType(options.audio_type)) {
     // TODO(justinlin): Updating the state to requested and pending are no-ops
     // in terms of the media manager, but these are the state changes we want to
     // support in terms of extensions (which is registered as an observer).
     request.setState(options.audio_type, MEDIA_REQUEST_STATE_REQUESTED);
     request.setState(options.audio_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
     ui_controller_->AddAvailableDevicesToRequest(
         *label, options.audio_type, StreamDeviceInfoArray(
-            1, StreamDeviceInfo(options.audio_type, device_id, device_id,
+            1, StreamDeviceInfo(options.audio_type,
+                                device_id,
+                                device_id,
                                 false)));
   }
   if (IsVideoMediaType(options.video_type)) {
     request.setState(options.video_type, MEDIA_REQUEST_STATE_REQUESTED);
     request.setState(options.video_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
     ui_controller_->AddAvailableDevicesToRequest(
         *label, options.video_type, StreamDeviceInfoArray(
-            1, StreamDeviceInfo(options.video_type, device_id, device_id,
+            1, StreamDeviceInfo(options.video_type,
+                                device_id,
+                                device_id,
                                 false)));
   }
 }
 
 void MediaStreamManager::CancelRequest(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     // The request isn't complete, notify the UI immediately.
@@ skipping 753 matching lines @@
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices();
 }
 
 }  // namespace content