Revert 179093

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/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry_factory.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_internals.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/browser/browser_thread.h"
 #include "content/public/common/media_stream_request.h"
 
 using content::BrowserThread;
 
+// TODO(xians): Remove this when the Omnibar UI has been completed.
+// See http://crbug.com/167263 for more details.
+#define ALLOW_STICKY_DENY 0
+
 namespace {
 
 bool HasAnyAvailableDevice() {
   MediaCaptureDevicesDispatcher* dispatcher =
       MediaInternals::GetInstance()->GetMediaCaptureDevicesDispatcher();
   const content::MediaStreamDevices& audio_devices =
       dispatcher->GetAudioCaptureDevices();
   const content::MediaStreamDevices& video_devices =
       dispatcher->GetVideoCaptureDevices();
 
   return !audio_devices.empty() || !video_devices.empty();
 };
 
 }  // namespace
 
 MediaStreamDevicesController::MediaStreamDevicesController(
     Profile* profile,
-    TabSpecificContentSettings* content_settings,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback)
     : profile_(profile),
-      content_settings_(content_settings),
       request_(request),
       callback_(callback),
       has_audio_(content::IsAudioMediaType(request.audio_type) &&
                  !IsAudioDeviceBlockedByPolicy()),
       has_video_(content::IsVideoMediaType(request.video_type) &&
                  !IsVideoDeviceBlockedByPolicy()) {
 }
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {}
 
@@ skipping 56 matching lines @@
 
   // Show the infobar.
   return false;
 }
 
 const std::string& MediaStreamDevicesController::GetSecurityOriginSpec() const {
   return request_.security_origin.spec();
 }
 
 void MediaStreamDevicesController::Accept(bool update_content_setting) {
-  content_settings_->OnMediaStreamAccessed();
-
-  // Get the default devices for the request.
   content::MediaStreamDevices devices;
   if (has_audio_ || has_video_) {
     switch (request_.request_type) {
       case content::MEDIA_OPEN_DEVICE:
         // For open device request pick the desired device or fall back to the
         // first available of the given type.
         media::GetRequestedDevice(request_.requested_device_id,
                                   has_audio_,
                                   has_video_,
                                   &devices);
         break;
       case content::MEDIA_DEVICE_ACCESS:
       case content::MEDIA_GENERATE_STREAM:
       case content::MEDIA_ENUMERATE_DEVICES:
         // Get the default devices for the request.
         media::GetDefaultDevicesForProfile(profile_,
                                            has_audio_,
                                            has_video_,
                                            &devices);
         break;
     }
 
-  if (update_content_setting && IsSchemeSecure() && !devices.empty())
+    if (update_content_setting && IsSchemeSecure() && !devices.empty())
       SetPermission(true);
   }
 
   callback_.Run(devices);
 }
 
 void MediaStreamDevicesController::Deny(bool update_content_setting) {
-  // TODO(markusheintz): Replace CONTENT_SETTINGS_TYPE_MEDIA_STREAM with the
-  // appropriate new CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC and
-  // CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA.
-  content_settings_->OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM,
-                                      std::string());
+#if ALLOW_STICKY_DENY
   if (update_content_setting)
     SetPermission(false);
+#endif
 
   callback_.Run(content::MediaStreamDevices());
 }
 
 bool MediaStreamDevicesController::IsAudioDeviceBlockedByPolicy() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return (!profile_->GetPrefs()->GetBoolean(prefs::kAudioCaptureAllowed) &&
           profile_->GetPrefs()->IsManagedPreference(
               prefs::kAudioCaptureAllowed));
 }
@@ skipping 25 matching lines @@
           request_.security_origin,
           CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
           NO_RESOURCE_IDENTIFIER) != CONTENT_SETTING_ALLOW) {
     return false;
   }
 
   return true;
 }
 
 bool MediaStreamDevicesController::IsRequestBlockedByDefault() const {
+#if ALLOW_STICKY_DENY
   if (has_audio_ &&
       profile_->GetHostContentSettingsMap()->GetContentSetting(
           request_.security_origin,
           request_.security_origin,
           CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
           NO_RESOURCE_IDENTIFIER) != CONTENT_SETTING_BLOCK) {
     return false;
   }
 
   if (has_video_ &&
       profile_->GetHostContentSettingsMap()->GetContentSetting(
           request_.security_origin,
           request_.security_origin,
           CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
           NO_RESOURCE_IDENTIFIER) != CONTENT_SETTING_BLOCK) {
     return false;
   }
 
   return true;
+#else
+  return false;
+#endif
 }
 
 bool MediaStreamDevicesController::IsDefaultMediaAccessBlocked() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // TODO(markusheintz): Replace CONTENT_SETTINGS_TYPE_MEDIA_STREAM with the
-  // appropriate new CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC and
-  // CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA.
+#if ALLOW_STICKY_DENY
   ContentSetting current_setting =
       profile_->GetHostContentSettingsMap()->GetDefaultContentSetting(
           CONTENT_SETTINGS_TYPE_MEDIASTREAM, NULL);
   return (current_setting == CONTENT_SETTING_BLOCK);
+#else
+  return false;
+#endif
 }
 
 void MediaStreamDevicesController::HandleTapMediaRequest() {
   // For tab media requests, we need to make sure the request came from the
   // extension API, so we check the registry here.
   extensions::TabCaptureRegistry* registry =
       extensions::TabCaptureRegistryFactory::GetForProfile(profile_);
 
   if (!registry->VerifyRequest(request_.render_process_id,
                                request_.render_view_id)) {
@@ skipping 12 matching lines @@
 
     callback_.Run(devices);
   }
 }
 
 bool MediaStreamDevicesController::IsSchemeSecure() const {
   return (request_.security_origin.SchemeIsSecure());
 }
 
 bool MediaStreamDevicesController::ShouldAlwaysAllowOrigin() const {
-  // TODO(markusheintz): Replace CONTENT_SETTINGS_TYPE_MEDIA_STREAM with the
-  // appropriate new CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC and
-  // CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA.
   return profile_->GetHostContentSettingsMap()->ShouldAllowAllContent(
       request_.security_origin, request_.security_origin,
       CONTENT_SETTINGS_TYPE_MEDIASTREAM);
 }
 
 void MediaStreamDevicesController::SetPermission(bool allowed) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ContentSettingsPattern primary_pattern =
       ContentSettingsPattern::FromURLNoWildcard(request_.security_origin);
   // Check the pattern is valid or not. When the request is from a file access,
@@ skipping 13 matching lines @@
   }
   if (has_video_) {
     profile_->GetHostContentSettingsMap()->SetContentSetting(
         primary_pattern,
         ContentSettingsPattern::Wildcard(),
         CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
         std::string(),
         content_setting);
   }
 }