add "always allow" option to the mediastream infobar and allow user to allow/not allow acces to devi

chrome/browser/ui/media_stream_infobar_delegate.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 <algorithm>
 #include <functional>
 
 #include "base/logging.h"
+#include "chrome/browser/media/media_stream_devices_prefs.h"
 #include "chrome/browser/ui/media_stream_infobar_delegate.h"
 #include "content/public/common/media_stream_request.h"
 #include "googleurl/src/gurl.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/resource/resource_bundle.h"
 
 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_;
 };
 
 }  // namespace
 
 MediaStreamInfoBarDelegate::MediaStreamInfoBarDelegate(
     InfoBarTabHelper* tab_helper,
+    Profile* profile,
     const content::MediaStreamRequest* request,
     const content::MediaResponseCallback& callback)
     : InfoBarDelegate(tab_helper),
       request_(request),
-      callback_(callback) {
+      callback_(callback),
+      prefs_(profile) {
   DCHECK(request_);
   has_audio_ = request_->devices.count(
       content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) != 0;
   has_video_ = request_->devices.count(
       content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) != 0;
 }
 
 MediaStreamInfoBarDelegate::~MediaStreamInfoBarDelegate() {
 }
 
@@ skipping 14 matching lines @@
   content::MediaStreamDeviceMap::const_iterator it =
       request_->devices.find(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
   DCHECK(it != request_->devices.end());
   return it->second;
 }
 
 const GURL& MediaStreamInfoBarDelegate::GetSecurityOrigin() const {
   return request_->security_origin;
 }
 
+bool MediaStreamInfoBarDelegate::ShouldShowInfoBar() {

[Evan Stade, 2012/06/12 01:51:12]

it's unexpected that a function called ShouldShowInfoBar() would have the
audacity to Accept or Deny. I would expect it to simply check some state and
return true or false, not to take any action. (basically, it needs a better
name)

[no longer working on chromium, 2012/06/14 13:03:25]

The name has been changed to DismissInfoBarAndTakeActionOnSettings(), hope it is
fine.

+  DCHECK(has_audio_ || has_video_);
+  if (prefs_.IsMediaDeviceBlocked()){
+    // Users has blocked the access to the media device in content settings,

[Bernhard Bauer, 2012/06/11 18:16:00]

Nit: "The user has blocked […]"

[no longer working on chromium, 2012/06/14 13:03:25]

Done.

+    // deny the request without showing the infobar.
+    Deny();
+    return false;
+  }
+
+  std::string audio_id, video_id;
+  if (GetAlwaysAllowedDevices(&audio_id, &video_id)) {
+    // There are always allowed devices available for this request, grant the
+    // permission immediately without showing the infobar.
+    Accept(audio_id, video_id, false);
+    return false;
+  }
+
+  return true;
+}
+
 void MediaStreamInfoBarDelegate::Accept(const std::string& audio_id,
-                                        const std::string& video_id) {
+                                        const std::string& video_id,
+                                        bool always_allow) {
   content::MediaStreamDevices devices;
+  GetDevicesWithId(audio_id, video_id, &devices);
+  DCHECK(devices.size());
 
-  if (has_audio_) {
-    AddDeviceWithId(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
-                    audio_id, &devices);
-  }
-  if (has_video_) {
-    AddDeviceWithId(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                    video_id, &devices);
-  }
+  if (always_allow)
+    prefs_.WhitelistOriginAndDevices(request_->security_origin, devices);
 
   callback_.Run(devices);
 }
 
 void MediaStreamInfoBarDelegate::Deny() {
   callback_.Run(content::MediaStreamDevices());
 }
 
+void MediaStreamInfoBarDelegate::GetDevicesWithId(
+    const std::string& audio_id,
+    const std::string& video_id,
+    content::MediaStreamDevices* devices) {
+  if (has_audio_) {
+    AddDeviceWithId(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
+                    audio_id, devices);
+  }
+  if (has_video_) {
+    AddDeviceWithId(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
+                    video_id, devices);
+  }
+}
+
 void MediaStreamInfoBarDelegate::AddDeviceWithId(
     content::MediaStreamDeviceType type,
     const std::string& id,
     content::MediaStreamDevices* devices) {
   DCHECK(devices);
   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(), DeviceIdEquals(id));
     if (it != device_it->second.end())
       devices->push_back(*it);
   }
 }
 
+bool MediaStreamInfoBarDelegate::GetAlwaysAllowedDevices(

[Evan Stade, 2012/06/12 01:51:12]

with the addition of these new methods, this class is looking less like an
infobar delegate and more like a controller...

[no longer working on chromium, 2012/06/14 13:03:25]

Added a MediaStreamDevicesController, moved most of the code from the delegate
to the new controller.

+    std::string* audio_id, std::string* video_id) {
+  // Check if the |origin| is in content settings exception list.
+  if (!prefs_.IsOriginAlwaysAllowed(request_->security_origin)) {
+    // Remove the |origin| if it exists in the device whitelists.
+    prefs_.RemoveOriginFromWhitelists(request_->security_origin);
+    return false;
+  }
+
+  // Check if the always allowed devices are available.
+  if (has_audio_) {
+    content::MediaStreamDevices devices = GetAudioDevices();
+    *audio_id = prefs_.GetAlwaysAllowedAudioDevice(request_->security_origin,
+                                                   devices);
+    if (audio_id->empty())
+      return false;
+  }
+  if (has_video_) {
+    content::MediaStreamDevices devices = GetVideoDevices();
+    *video_id = prefs_.GetAlwaysAllowedVideoDevice(request_->security_origin,
+                                                   devices);
+    if (video_id->empty())
+      return false;
+  }
+
+  return true;
+}
+
 // MediaStreamInfoBarDelegate::CreateInfoBar is implemented in platform-specific
 // files.
 
 void MediaStreamInfoBarDelegate::InfoBarDismissed() {
   // Deny the request if the infobar was closed with the 'x' button, since
   // we don't want WebRTC to be waiting for an answer that will never come.
   Deny();
 }
 
 gfx::Image* MediaStreamInfoBarDelegate::GetIcon() const {
   return &ResourceBundle::GetSharedInstance().GetNativeImageNamed(has_video_ ?
       IDR_INFOBAR_MEDIA_STREAM_CAMERA : IDR_INFOBAR_MEDIA_STREAM_MIC);
 }
 
 InfoBarDelegate::Type MediaStreamInfoBarDelegate::GetInfoBarType() const {
   return PAGE_ACTION_TYPE;
 }
 
 MediaStreamInfoBarDelegate*
     MediaStreamInfoBarDelegate::AsMediaStreamInfoBarDelegate() {
   return this;
 }