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;
+  for (content::MediaStreamDeviceMap::const_iterator it =
+           request_.devices.begin();
+       it != request_.devices.end(); ++it) {
+    if (content::IsAudioMediaStreamDeviceType(it->first)) {
+      has_audio_ |= !it->second.empty();
+    } else if (content::IsVideoMediaStreamDeviceType(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;
+  FindSubsetOfDevices(&content::IsAudioMediaStreamDeviceType,
+                      &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;
+  FindSubsetOfDevices(&content::IsVideoMediaStreamDeviceType,
+                      &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::IsAudioMediaStreamDeviceType,
+      content::MEDIA_STREAM_DEVICE_TYPE_USER_AUDIO_CAPTURE);
+}
+
+bool MediaStreamDevicesController::IsSafeToAlwaysAllowVideo() const {
+  return IsSafeToAlwaysAllow(
+      &content::IsVideoMediaStreamDeviceType,
+      content::MEDIA_STREAM_DEVICE_TYPE_USER_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::IsAudioMediaStreamDeviceType,
+                                    audio_id);
+  if (audio_device) {
+    if (audio_device->type !=
+            content::MEDIA_STREAM_DEVICE_TYPE_USER_AUDIO_CAPTURE) {
+      always_allow = false;  // override for non-user audio device type
+    }
+    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::IsVideoMediaStreamDeviceType,
+                                    video_id);
+  if (video_device) {
+    if (video_device->type !=
+            content::MEDIA_STREAM_DEVICE_TYPE_USER_VIDEO_CAPTURE) {
+      always_allow = false;  // override for non-user video device type
+    }
+    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 user_type) const {
+  DCHECK(user_type == content::MEDIA_STREAM_DEVICE_TYPE_USER_AUDIO_CAPTURE ||
+         user_type == content::MEDIA_STREAM_DEVICE_TYPE_USER_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-user devices are available for the choosing, then it's not safe.
+  for (content::MediaStreamDeviceMap::const_iterator it =
+           request_.devices.begin();
+       it != request_.devices.end(); ++it) {
+    if (it->first != user_type && is_included(it->first)) {
+      return false;

[no longer working on chromium, 2012/08/31 13:38:23]

I may miss something here, how possibly get into this if?

Furthermore, from the comments above, I assume that it is not safe if no
available subset devices in the requests. That say, if the requests_ contain no
audio device, is_included(it->first) will always return false, but we are return
true as the result of IsSafeToAlwaysAllow()

[miu, 2012/09/01 01:32:00]

Example: When checking the video devices, if it->first is
MEDIA_TAB_VIDEO_CAPTURE, this will not match user_type (which is
MEDIA_USER_VIDEO_CAPTURE).  is_included(...) will still evaluate to true since
MEDIA_TAB_VIDEO_CAPTURE is a video type.  Therefore, the whole expression is
true; meaning, we've found a non-user capture device so it is NOT safe to always
allow the device.
Good catch!  Fixed.

+    }
+  }
+
+  return true;
 }
 
 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_STREAM_DEVICE_TYPE_USER_AUDIO_CAPTURE);
     }
     if (has_video_) {
-      *video_id =
-          GetFirstDeviceId(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
+      *video_id = GetFirstDeviceId(
+          content::MEDIA_STREAM_DEVICE_TYPE_USER_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_STREAM_DEVICE_TYPE_USER_AUDIO_CAPTURE, audio_name);
   }
   if (has_video_ && !video_name.empty()) {
     *video_id = GetDeviceIdByName(
-        content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, video_name);
+        content::MEDIA_STREAM_DEVICE_TYPE_USER_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;

[no longer working on chromium, 2012/08/31 13:38:23]

Do we need this local variable?

[miu, 2012/09/01 01:32:00]

No.  I did it for readability (no runtime cost since it's just a reference). 
Otherwise, the following two lines of code would look like:

  if (device_it->device_id == device_id) {
    return &(*device_it);
  }

If you still prefer I change it, please let me know.

+      if (candidate.device_id == device_id) {
+        return &candidate;
+      }
+    }
+  }
+  return NULL;
+}