Begin adding support for tab mirroring via the MediaStream audio/video capturing

chrome/browser/media/media_stream_devices_controller.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_stream_devices_controller.h"
 
 #include "base/values.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
+#include "content/public/common/media_stream_request.h"
 
 using content::BrowserThread;
 
 namespace {
 
-// A predicate that checks if a StreamDeviceInfo object has the same ID as the
-// device ID specified at construction.
-class DeviceIdEquals {
- public:
-  explicit DeviceIdEquals(const std::string& device_id)
-      : device_id_(device_id) {
-  }
-
-  bool operator() (const content::MediaStreamDevice& device) {
-    return device.device_id == device_id_;
-  }
-
- private:
-  std::string device_id_;
-};
-
 // A predicate that checks if a StreamDeviceInfo object has the same device
 // name as the device name specified at construction.
 class DeviceNameEquals {
  public:
   explicit DeviceNameEquals(const std::string& device_name)
       : device_name_(device_name) {
   }
 
   bool operator() (const content::MediaStreamDevice& device) {
     return device.name == device_name_;
   }
 
  private:
   std::string device_name_;
 };
 
-// Whether |request| contains any device of given |type|.
-bool HasDevice(const content::MediaStreamRequest& request,
-               content::MediaStreamDeviceType type) {
-  content::MediaStreamDeviceMap::const_iterator device_it =
-      request.devices.find(type);
-  return device_it != request.devices.end() && !device_it->second.empty();
-}
-
 const char kAudioKey[] = "audio";
 const char kVideoKey[] = "video";
 
 }  // namespace
 
 MediaStreamDevicesController::MediaStreamDevicesController(
     Profile* profile,
     const content::MediaStreamRequest* request,
     const content::MediaResponseCallback& callback)
     : profile_(profile),
       request_(*request),
       callback_(callback) {
-  has_audio_ =
-      HasDevice(request_, content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE);
-  has_video_ =
-      HasDevice(request_, content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
+  has_audio_ = false;
+  has_video_ = false;

[tommi (sloooow) - chröme, 2012/09/10 09:17:25]

initialize these in the initializer list.

[miu, 2012/09/10 21:24:38]

Done.

+  for (content::MediaStreamDeviceMap::const_iterator it =
+           request_.devices.begin();
+       it != request_.devices.end(); ++it) {
+    if (content::IsAudioMediaType(it->first)) {
+      has_audio_ |= !it->second.empty();
+    } else if (content::IsVideoMediaType(it->first)) {
+      has_video_ |= !it->second.empty();
+    }
+  }
 }
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {}
 
 bool MediaStreamDevicesController::DismissInfoBarAndTakeActionOnSettings() {
   // Deny the request if the security origin is empty, this happens with
   // file access without |--allow-file-access-from-files| flag.
   if (request_.security_origin.is_empty()) {
     Deny();
     return true;
@@ skipping 25 matching lines @@
     return false;
   }
 
   // Dismiss the infobar by selecting the "always allowed" devices.
   Accept(audio, video, false);
   return true;
 }
 
 content::MediaStreamDevices
 MediaStreamDevicesController::GetAudioDevices() const {
-  if (!has_audio_)
-    return content::MediaStreamDevices();
-
-  content::MediaStreamDeviceMap::const_iterator it =
-      request_.devices.find(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE);
-  DCHECK(it != request_.devices.end());
-  return it->second;
+  content::MediaStreamDevices all_audio_devices;
+  if (has_audio_) {

[tommi (sloooow) - chröme, 2012/09/10 09:17:25]

no need for {}
same throughout since the file wasn't using {} for single line  if's before.

[miu, 2012/09/10 21:24:38]

Done; but only to be style-consistent with the existing code in this file.

I've asked several engineers about this, and it was unanimous that braces should
be used around single-statement "then" blocks.  Some reasons cited: 1)
readability; 2) prevent bugs in future code (e.g., when adding another statement
to the "then" block).

One person mentioned that WebKit code style requires that no braces be used in
such cases, and this might be the motivation for your review comment.  However,
note that Chrome code follows Google C++ Style, which allows both
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Conditionals).

+    FindSubsetOfDevices(&content::IsAudioMediaType, &all_audio_devices);
+  }
+  return all_audio_devices;
 }
 
 content::MediaStreamDevices
 MediaStreamDevicesController::GetVideoDevices() const {
-  if (!has_video_)
-    return content::MediaStreamDevices();
-
-  content::MediaStreamDeviceMap::const_iterator it =
-      request_.devices.find(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
-  DCHECK(it != request_.devices.end());
-  return it->second;
+  content::MediaStreamDevices all_video_devices;
+  if (has_video_) {
+    FindSubsetOfDevices(&content::IsVideoMediaType, &all_video_devices);
+  }
+  return all_video_devices;
 }
 
-const GURL& MediaStreamDevicesController::GetSecurityOrigin() const {
-  return request_.security_origin;
+const std::string& MediaStreamDevicesController::GetSecurityOriginSpec() const {
+  return request_.security_origin.spec();
+}
+
+bool MediaStreamDevicesController::IsSafeToAlwaysAllowAudio() const {
+  return IsSafeToAlwaysAllow(
+      &content::IsAudioMediaType, content::MEDIA_DEVICE_AUDIO_CAPTURE);
+}
+
+bool MediaStreamDevicesController::IsSafeToAlwaysAllowVideo() const {
+  return IsSafeToAlwaysAllow(
+      &content::IsVideoMediaType, content::MEDIA_DEVICE_VIDEO_CAPTURE);
 }
 
 void MediaStreamDevicesController::Accept(const std::string& audio_id,
                                           const std::string& video_id,
                                           bool always_allow) {
   content::MediaStreamDevices devices;
-  std::string audio_device, video_device;
-  if (has_audio_) {
-    AddDeviceWithId(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-                    audio_id, &devices, &audio_device);
+  std::string audio_device_name, video_device_name;
+
+  const content::MediaStreamDevice* const audio_device =
+      FindFirstDeviceWithIdInSubset(&content::IsAudioMediaType, audio_id);
+  if (audio_device) {
+    if (audio_device->type != content::MEDIA_DEVICE_AUDIO_CAPTURE) {
+      always_allow = false;  // override for virtual audio device type

[scherkus (not reviewing), 2012/09/10 11:08:59]

try to use proper sentence structure for comments (i.e., start w/ capital
letters and end with periods)

[miu, 2012/09/10 21:24:38]

Done.

+    }
+    devices.push_back(*audio_device);
+    audio_device_name = audio_device->name;
   }
-  if (has_video_) {
-    AddDeviceWithId(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                    video_id, &devices, &video_device);
+
+  const content::MediaStreamDevice* const video_device =
+      FindFirstDeviceWithIdInSubset(&content::IsVideoMediaType, video_id);
+  if (video_device) {
+    if (video_device->type != content::MEDIA_DEVICE_VIDEO_CAPTURE) {
+      always_allow = false;  // override for virtual video device type

[scherkus (not reviewing), 2012/09/10 11:08:59]

ditto

[miu, 2012/09/10 21:24:38]

Done.

+    }
+    devices.push_back(*video_device);
+    video_device_name = video_device->name;
   }
+
   DCHECK(!devices.empty());
 
   if (always_allow)
-    AlwaysAllowOriginAndDevices(audio_device, video_device);
+    AlwaysAllowOriginAndDevices(audio_device_name, video_device_name);
 
   callback_.Run(devices);
 }
 
 void MediaStreamDevicesController::Deny() {
   callback_.Run(content::MediaStreamDevices());
 }
 
-void MediaStreamDevicesController::AddDeviceWithId(
-    content::MediaStreamDeviceType type,
-    const std::string& id,
-    content::MediaStreamDevices* devices,
-    std::string* device_name) {
-  DCHECK(devices);
-  content::MediaStreamDeviceMap::const_iterator device_it =
-      request_.devices.find(type);
-  if (device_it == request_.devices.end())
-    return;
+bool MediaStreamDevicesController::IsSafeToAlwaysAllow(
+    FilterByDeviceTypeFunc is_included,
+    content::MediaStreamDeviceType device_type) const {
+  DCHECK(device_type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
+         device_type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
 
-  content::MediaStreamDevices::const_iterator it = std::find_if(
-      device_it->second.begin(), device_it->second.end(), DeviceIdEquals(id));
-  if (it == device_it->second.end())
-    return;
+  if (!request_.security_origin.SchemeIsSecure()) {
+    return false;
+  }
 
-  devices->push_back(*it);
-  *device_name = it->name;
+  // If non-physical devices are available for the choosing, then it's not safe.
+  bool safe_devices_found = false;
+  for (content::MediaStreamDeviceMap::const_iterator it =
+           request_.devices.begin();
+       it != request_.devices.end(); ++it) {
+    if (it->first != device_type && is_included(it->first)) {
+      return false;
+    }
+    safe_devices_found = true;
+  }
+
+  return safe_devices_found;
 }
 
 bool MediaStreamDevicesController::ShouldAlwaysAllowOrigin() {
   return profile_->GetHostContentSettingsMap()->ShouldAllowAllContent(
       request_.security_origin, request_.security_origin,
       CONTENT_SETTINGS_TYPE_MEDIASTREAM);
 }
 
 bool MediaStreamDevicesController::IsMediaDeviceBlocked() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 27 matching lines @@
 
 void MediaStreamDevicesController::GetAlwaysAllowedDevices(
     std::string* audio_id, std::string* video_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(audio_id->empty());
   DCHECK(video_id->empty());
   // If the request is from internal objects like chrome://URLs, use the first
   // devices on the lists.
   if (ShouldAlwaysAllowOrigin()) {
     if (has_audio_) {
-      *audio_id =
-          GetFirstDeviceId(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE);
+      *audio_id = GetFirstDeviceId(content::MEDIA_DEVICE_AUDIO_CAPTURE);
     }
     if (has_video_) {
-      *video_id =
-          GetFirstDeviceId(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
+      *video_id = GetFirstDeviceId(content::MEDIA_DEVICE_VIDEO_CAPTURE);
     }
     return;
   }
 
   // "Always allowed" option is only available for secure connection.
   if (!request_.security_origin.SchemeIsSecure())
     return;
 
   // Checks the media exceptions to get the "always allowed" devices.
   scoped_ptr<Value> value(
@@ skipping 11 matching lines @@
   const DictionaryValue* value_dict = NULL;
   if (!value->GetAsDictionary(&value_dict) || value_dict->empty())
     return;
 
   std::string audio_name, video_name;
   value_dict->GetString(kAudioKey, &audio_name);
   value_dict->GetString(kVideoKey, &video_name);
 
   if (has_audio_ && !audio_name.empty()) {
     *audio_id = GetDeviceIdByName(
-        content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE, audio_name);
+        content::MEDIA_DEVICE_AUDIO_CAPTURE, audio_name);
   }
   if (has_video_ && !video_name.empty()) {
     *video_id = GetDeviceIdByName(
-        content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, video_name);
+        content::MEDIA_DEVICE_VIDEO_CAPTURE, video_name);
   }
 }
 
 std::string MediaStreamDevicesController::GetDeviceIdByName(
     content::MediaStreamDeviceType type,
     const std::string& name) {
   content::MediaStreamDeviceMap::const_iterator device_it =
       request_.devices.find(type);
   if (device_it != request_.devices.end()) {
     content::MediaStreamDevices::const_iterator it = std::find_if(
         device_it->second.begin(), device_it->second.end(),
         DeviceNameEquals(name));
     if (it != device_it->second.end())
       return it->device_id;
   }
 
   // Device is not available, return an empty string.
   return std::string();
 }
 
 std::string MediaStreamDevicesController::GetFirstDeviceId(
     content::MediaStreamDeviceType type) {
   content::MediaStreamDeviceMap::const_iterator device_it =
       request_.devices.find(type);
   if (device_it != request_.devices.end())
     return device_it->second.begin()->device_id;
 
   return std::string();
 }
+
+void MediaStreamDevicesController::FindSubsetOfDevices(
+    FilterByDeviceTypeFunc is_included,
+    content::MediaStreamDevices* out) const {
+  for (content::MediaStreamDeviceMap::const_iterator it =
+           request_.devices.begin();
+       it != request_.devices.end(); ++it) {
+    if (is_included(it->first)) {
+      out->insert(out->end(), it->second.begin(), it->second.end());
+    }
+  }
+}
+
+const content::MediaStreamDevice*
+MediaStreamDevicesController::FindFirstDeviceWithIdInSubset(
+    FilterByDeviceTypeFunc is_included,
+    const std::string& device_id) const {
+  for (content::MediaStreamDeviceMap::const_iterator it =
+           request_.devices.begin();
+       it != request_.devices.end(); ++it) {
+    if (!is_included(it->first)) {
+      continue;
+    }
+    for (content::MediaStreamDevices::const_iterator device_it =
+             it->second.begin();
+         device_it != it->second.end(); ++device_it) {
+      const content::MediaStreamDevice& candidate = *device_it;
+      if (candidate.device_id == device_id) {
+        return &candidate;
+      }
+    }
+  }
+  return NULL;
+}