Implement Chrome Extension 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"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_device_settings.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/media_request_state.h"
+#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 {
@@ skipping 205 matching lines @@
   DeviceRequest& request = requests_[*label];
   request.requested_device_id = device_id;
 
   // Get user confirmation to use the capture device.
   device_settings_->RequestCaptureDeviceUsage(*label,
                                               render_process_id,
                                               render_view_id,
                                               options,
                                               security_origin);
 
-  if (!security_origin.SchemeIs(kExtensionScheme) ||
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(

[Aaron Boodman, 2012/10/18 22:51:35]

I think this check should be done in RequestMediaAccessPermission() on the
Chrome side.

[justinlin, 2012/10/19 00:03:33]

While I agree that might be nicer, I think it's better to keep this flag check
in content/ for now for safety. In case something changes in the way user
authorization works, we don't want to allow tab media streams without the flag.

[Aaron Boodman, 2012/10/19 00:37:20]

The way that FeatureSwitch works, you can do --tab-capture=1 or --tab-capture=0.
--tab-capture doesn't mean anything on its own. So this logic is broken.

I don't want you to duplicate part of the logic of FeatureSwitch here, and you
can't access it from content/. I think the risk is ok given the other safeguards
we have.

[justinlin, 2012/10/19 00:47:26]

Sorry should have explained. The way I set it up is there's really 2 flags:
"enable-tab-capture" and "tab-capture". "enable-tab-capture" is purely a
content/ flag and this is the one that is setup in about_flags.cc. The
"tab-capture" flag one is the one that is added to FeatureSwitch, and I rely on
the IsEnabled() method doing the legacy mode check (i.e. it prepends "enable-"
and checks HasSwitch).

Maybe I should just remove the FeatureSwitch and not check that flag in the
extension API. Then, we only have this content flag which prevent all tab
capture streams.

Would that be better?

+          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;
   }
@@ skipping 711 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