Add a policy list for access to capture devices

chrome/browser/policy/policy_browsertest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 1947 matching lines @@
   // ShowHomeButton has policy ID 35.
   EXPECT_NE(std::string::npos, text.find("<br>35  ---"));
   // BookmarkBarEnabled has policy ID 82.
   EXPECT_NE(std::string::npos, text.find("<br>82  ---"));
 }
 
 class MediaStreamDevicesControllerBrowserTest
     : public PolicyTest,
       public testing::WithParamInterface<bool> {
  public:
-  MediaStreamDevicesControllerBrowserTest() {
+  MediaStreamDevicesControllerBrowserTest()
+      : request_url_allowed_via_whitelist_(false) {
     policy_value_ = GetParam();
   }
   virtual ~MediaStreamDevicesControllerBrowserTest() {}
 
+  // Configure a given policy map.
+  // The |policy_name| is the name of either the audio or video capture allow
+  // policy and must never be NULL.
+  // |whitelist_policy| is optional.  If NULL, no whitelist policy is set.
+  // If non-NULL, the request_url_ will be set to be non empty and a matching
+  // policy that allows the request url, will be set.
+  void ConfigurePolicyMap(PolicyMap* policies, const char* policy_name,
+                          const char* whitelist_policy) {
+    policies->Set(policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+        base::Value::CreateBooleanValue(policy_value_));
+
+    if (whitelist_policy) {
+      // Add an entry to the whitelist that allows the specified URL regardless
+      // of the setting of kAudioCapturedAllowed.
+      request_url_ = GURL("http://www.example.com/foo");
+      const char kRequestPattern[] = "http://*.example.com/";
+      base::ListValue* list = new base::ListValue();
+      list->AppendString(kRequestPattern);
+      policies->Set(whitelist_policy, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_USER, list);
+      request_url_allowed_via_whitelist_ = true;
+    }
+  }
+
   void Accept(const content::MediaStreamDevices& devices,
               scoped_ptr<content::MediaStreamUI> ui) {
-    if (policy_value_) {
+    if (policy_value_ || request_url_allowed_via_whitelist_) {
       ASSERT_EQ(1U, devices.size());
       ASSERT_EQ("fake_dev", devices[0].id);
     } else {
       ASSERT_EQ(0U, devices.size());
     }
   }
 
   void FinishAudioTest() {
-    content::MediaStreamRequest request(0, 0, GURL(),
+    content::MediaStreamRequest request(0, 0, request_url_.GetOrigin(),
                                         content::MEDIA_OPEN_DEVICE, "fake_dev",
                                         content::MEDIA_DEVICE_AUDIO_CAPTURE,
                                         content::MEDIA_NO_SERVICE);
     MediaStreamDevicesController controller(
         browser()->tab_strip_model()->GetActiveWebContents(), request,
         base::Bind(&MediaStreamDevicesControllerBrowserTest::Accept, this));
     controller.DismissInfoBarAndTakeActionOnSettings();
 
     MessageLoop::current()->QuitWhenIdle();
   }
 
   void FinishVideoTest() {
-    content::MediaStreamRequest request(0, 0, GURL(),
+    content::MediaStreamRequest request(0, 0, request_url_.GetOrigin(),
                                         content::MEDIA_OPEN_DEVICE, "fake_dev",
                                         content::MEDIA_NO_SERVICE,
                                         content::MEDIA_DEVICE_VIDEO_CAPTURE);
     MediaStreamDevicesController controller(
         browser()->tab_strip_model()->GetActiveWebContents(), request,
         base::Bind(&MediaStreamDevicesControllerBrowserTest::Accept, this));
     controller.DismissInfoBarAndTakeActionOnSettings();
 
     MessageLoop::current()->QuitWhenIdle();
   }
 
   bool policy_value_;
+  bool request_url_allowed_via_whitelist_;
+  GURL request_url_;
 };
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        AudioCaptureAllowed) {
   content::MediaStreamDevices audio_devices;
   content::MediaStreamDevice fake_audio_device(
       content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device");
   audio_devices.push_back(fake_audio_device);
 
   PolicyMap policies;
-  policies.Set(key::kAudioCaptureAllowed, POLICY_LEVEL_MANDATORY,
-               POLICY_SCOPE_USER,
-               base::Value::CreateBooleanValue(policy_value_));
+  ConfigurePolicyMap(&policies, key::kAudioCaptureAllowed, NULL);
   UpdateProviderPolicy(policies);
 
   content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged,
+                 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
+                 audio_devices),
+      base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
+                 this));
+
+  MessageLoop::current()->Run();
+}
+
+IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
+                       AudioCaptureAllowedUrls) {
+  content::MediaStreamDevices audio_devices;
+  content::MediaStreamDevice fake_audio_device(
+      content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device");
+  audio_devices.push_back(fake_audio_device);
+
+  PolicyMap policies;
+  ConfigurePolicyMap(&policies, key::kAudioCaptureAllowed,
+                     key::kAudioCaptureAllowedUrls);
+  UpdateProviderPolicy(policies);
+
+  content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged,
                  base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
                  audio_devices),
       base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
                  this));
 
   MessageLoop::current()->Run();
 }
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        VideoCaptureAllowed) {
   content::MediaStreamDevices video_devices;
   content::MediaStreamDevice fake_video_device(
       content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device");
   video_devices.push_back(fake_video_device);
 
   PolicyMap policies;
-  policies.Set(key::kVideoCaptureAllowed, POLICY_LEVEL_MANDATORY,
-               POLICY_SCOPE_USER,
-               base::Value::CreateBooleanValue(policy_value_));
+  ConfigurePolicyMap(&policies, key::kVideoCaptureAllowed, NULL);
   UpdateProviderPolicy(policies);
 
   content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged,
+                 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
+                 video_devices),
+      base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
+                 this));
+
+  MessageLoop::current()->Run();
+}
+
+IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
+                       VideoCaptureAllowedUrls) {
+  content::MediaStreamDevices video_devices;
+  content::MediaStreamDevice fake_video_device(
+      content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device");
+  video_devices.push_back(fake_video_device);
+
+  PolicyMap policies;
+  ConfigurePolicyMap(&policies, key::kVideoCaptureAllowed,
+                     key::kVideoCaptureAllowedUrls);
+  UpdateProviderPolicy(policies);
+
+  content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged,
                  base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
                  video_devices),
       base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
                  this));
 
   MessageLoop::current()->Run();
 }
 
@@ skipping 27 matching lines @@
       chrome_variations::VariationsService::GetVariationsServerURL(
           g_browser_process->local_state());
   EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true));
   std::string value;
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("restricted", value);
 }
 #endif
 
 }  // namespace policy