Make tab capture media stream requests verify that the request came from extension 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 12 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "googleurl/src/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 using content::BrowserThread;
 using content::MediaStreamRequest;
 
-namespace {
-const char kExtensionScheme[] = "chrome-extension";
-}  // namespace
-
 namespace media_stream {
 
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
   // An earlier PeerConnection spec,
   // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the
   // MediaStream::label alphabet as containing 36 characters from
   // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E,
   // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E.
   // Here we use a safe subset.
@@ skipping 194 matching lines @@
 
   // Get user confirmation to use the capture device.
   device_settings_->RequestCaptureDeviceUsage(*label,
                                               render_process_id,
                                               render_view_id,
                                               options,
                                               security_origin);
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableTabCapture) ||
-      !security_origin.SchemeIs(kExtensionScheme) ||
       (options.audio_type != content::MEDIA_TAB_AUDIO_CAPTURE &&
        options.audio_type != content::MEDIA_NO_SERVICE) ||
       (options.video_type != content::MEDIA_TAB_VIDEO_CAPTURE &&
        options.video_type != content::MEDIA_NO_SERVICE)) {
     LOG(ERROR) << "Invalid request or used tab capture outside extension API.";
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&MediaStreamManager::CancelGenerateStream,
                    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.
-  StreamDeviceInfoArray devices;
   if (content::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,
                      content::MEDIA_REQUEST_STATE_REQUESTED);
     request.setState(options.audio_type,
                      content::MEDIA_REQUEST_STATE_PENDING_APPROVAL);
-    devices.push_back(
-        StreamDeviceInfo(options.audio_type, device_id, device_id, false));
+    device_settings_->AvailableDevices(
+        *label, options.audio_type, StreamDeviceInfoArray(
+            1, StreamDeviceInfo(options.audio_type, device_id, device_id,
+                                false)));
   }
   if (content::IsVideoMediaType(options.video_type)) {
     request.setState(options.video_type,
                      content::MEDIA_REQUEST_STATE_REQUESTED);
     request.setState(options.video_type,
                      content::MEDIA_REQUEST_STATE_PENDING_APPROVAL);
-    devices.push_back(
-        StreamDeviceInfo(options.video_type, device_id, device_id, false));
+    device_settings_->AvailableDevices(
+        *label, options.video_type, StreamDeviceInfoArray(
+            1, StreamDeviceInfo(options.video_type, device_id, device_id,
+                                false)));
   }
-
-  // Bypass the user authorization dropdown for tab capture.
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::DevicesAccepted,
-                 base::Unretained(this), *label, devices));
 }
 
 void MediaStreamManager::CancelGenerateStream(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     // The request isn't complete.
     if (!RequestDone(it->second)) {
       DeviceRequest& request = it->second;
@@ skipping 671 matching lines @@
        it != requests_.end(); ++it) {
     if (it->second.type == DeviceRequest::ENUMERATE_DEVICES &&
         Requested(it->second.options, stream_type)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media_stream