ScreenCapture for Android phase1, part II

chrome/browser/media/webrtc/media_stream_devices_controller_browsertest.cc

 // Copyright 2014 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 <string>
 
 #include "base/bind.h"
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
@@ skipping 91 matching lines @@
     content_settings->SetContentSettingDefaultScope(
         example_url_, GURL(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
         std::string(), mic_setting);
     content_settings->SetContentSettingDefaultScope(
         example_url_, GURL(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
         std::string(), cam_setting);
   }
 
   // Checks whether the devices returned in OnMediaStreamResponse contains a
   // microphone and/or camera device.
-  bool DevicesContains(bool needs_mic, bool needs_cam) {
-    bool has_mic = false;
-    bool has_cam = false;
+  bool CheckDevicesListContains(content::MediaStreamType type) {
     for (const auto& device : media_stream_devices_) {
-      if (device.type == content::MEDIA_DEVICE_AUDIO_CAPTURE)
-        has_mic = true;
-      if (device.type == content::MEDIA_DEVICE_VIDEO_CAPTURE)
-        has_cam = true;
+      if (device.type == type) {
+        return true;
+      }
     }
-
-    return needs_mic == has_mic && needs_cam == has_cam;
+    return false;
   }
 
   content::WebContents* GetWebContents() {
     return browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   // Creates a MediaStreamRequest, asking for those media types, which have a
   // non-empty id string.
   content::MediaStreamRequest CreateRequestWithType(
       const std::string& audio_id,
@@ skipping 497 matching lines @@
     if (test.ExpectMicInfobar() || test.ExpectCamInfobar()) {
       if (test.accept_infobar)
         controller.PermissionGranted();
       else
         controller.PermissionDenied();
     }
 
     // Check the media stream result is expected and the devices returned are
     // expected;
     ASSERT_EQ(test.ExpectedMediaStreamResult(), media_stream_result());
-    ASSERT_TRUE(
-        DevicesContains(test.ExpectMicAllowed(), test.ExpectCamAllowed()));
+    ASSERT_EQ(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE),
+              test.ExpectMicAllowed());
+    ASSERT_EQ(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE),
+              test.ExpectCamAllowed());
   }
 }
 
 // Request and allow camera access on WebUI pages without prompting.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        WebUIRequestAndAllowCam) {
   InitWithUrl(GURL("chrome://test-page"));
   MediaStreamDevicesController controller(
       GetWebContents(), CreateRequest(std::string(), example_video_id()),
       base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
                  base::Unretained(this)));
 
   ASSERT_FALSE(controller.IsAskingForAudio());
   ASSERT_FALSE(controller.IsAskingForVideo());
 
   ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
-  ASSERT_TRUE(DevicesContains(false, true));
+  ASSERT_FALSE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
+  ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        ExtensionRequestMicCam) {
   InitWithUrl(GURL("chrome-extension://test-page"));
   // Test that a prompt is required.
   MediaStreamDevicesController controller(
       GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
       base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
                  base::Unretained(this)));
   ASSERT_TRUE(controller.IsAskingForAudio());
   ASSERT_TRUE(controller.IsAskingForVideo());
 
   // Accept the prompt.
   controller.PermissionGranted();
   ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
-  ASSERT_TRUE(DevicesContains(true, true));
+  ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
+  ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 
   // Check that re-requesting allows without prompting.
   MediaStreamDevicesController controller2(
       GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
       base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
                  base::Unretained(this)));
   ASSERT_FALSE(controller2.IsAskingForAudio());
   ASSERT_FALSE(controller2.IsAskingForVideo());
 
   ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
-  ASSERT_TRUE(DevicesContains(true, true));
+  ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
+  ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 }
 
 // For Pepper request from insecure origin, even if it's ALLOW, it won't be
 // changed to ASK.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        PepperRequestInsecure) {
   InitWithUrl(GURL("http://www.example.com"));
   SetContentSettings(CONTENT_SETTING_ALLOW, CONTENT_SETTING_ALLOW);
 
   MediaStreamDevicesController controller(
@@ skipping 28 matching lines @@
   MediaStreamDevicesController controller(
       GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
       base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
                  base::Unretained(this)));
 
   EXPECT_FALSE(controller.IsAllowedForAudio());
   EXPECT_FALSE(controller.IsAllowedForVideo());
   EXPECT_FALSE(controller.IsAskingForAudio());
   EXPECT_FALSE(controller.IsAskingForVideo());
 }