ScreenCapture for Android phase1, part II

chrome/browser/media/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 31 matching lines @@
     controller->PermissionGranted();
 }
 
 }  // namespace
 
 class MediaStreamDevicesControllerTest : public WebRtcTestBase {
  public:
   MediaStreamDevicesControllerTest()
       : example_audio_id_("fake_audio_dev"),
         example_video_id_("fake_video_dev"),
+        example_screen_id_("fake_screen_dev"),
         media_stream_result_(content::NUM_MEDIA_REQUEST_RESULTS) {}
 
   // Dummy callback for when we deny the current request directly.
   void OnMediaStreamResponse(const content::MediaStreamDevices& devices,
                              content::MediaStreamRequestResult result,
                              std::unique_ptr<content::MediaStreamUI> ui) {
     media_stream_devices_ = devices;
     media_stream_result_ = result;
   }
 
  protected:
   enum DeviceType { DEVICE_TYPE_AUDIO, DEVICE_TYPE_VIDEO };
   enum Access { ACCESS_ALLOWED, ACCESS_DENIED };
 
   const GURL& example_url() const { return example_url_; }
 
   TabSpecificContentSettings* GetContentSettings() {
     return TabSpecificContentSettings::FromWebContents(GetWebContents());
   }
 
   const std::string& example_audio_id() const { return example_audio_id_; }
   const std::string& example_video_id() const { return example_video_id_; }
+  const std::string& example_screen_id() const { return example_screen_id_; }
 
   content::MediaStreamRequestResult media_stream_result() const {
     return media_stream_result_;
   }
 
   // Sets the device policy-controlled |access| for |example_url_| to be for the
   // selected |device_type|.
   void SetDevicePolicy(DeviceType device_type, Access access) {
     PrefService* prefs = Profile::FromBrowserContext(
         GetWebContents()->GetBrowserContext())->GetPrefs();
@@ skipping 17 matching lines @@
             Profile::FromBrowserContext(GetWebContents()->GetBrowserContext()));
     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.

[Sergey Ulanov, 2016/08/19 05:54:15]

update comment?

-  bool DevicesContains(bool needs_mic, bool needs_cam) {
-    bool has_mic = false;
-    bool has_cam = false;
+  bool DevicesContains(bool needs_audio, bool needs_video) {

[Sergey Ulanov, 2016/08/19 05:54:15]

I think it would be cleaner to replace this with a function that compares single
type. 
So instead of 
  EXPECT_TRUE(DevicesContains(true, false));

the tests would do something like this:
  CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE, true);
  CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE, false);

Right now this function confuses MEDIA_DEVICE_VIDEO_CAPTURE and
MEDIA_DESKTOP_VIDEO_CAPTURE, which is not desirable.

+    bool has_audio = false;
+    bool has_video = false;
     for (const auto& device : media_stream_devices_) {
       if (device.type == content::MEDIA_DEVICE_AUDIO_CAPTURE)
-        has_mic = true;
+        has_audio = true;
       if (device.type == content::MEDIA_DEVICE_VIDEO_CAPTURE)
-        has_cam = true;
+        has_video = true;
+#if defined(OS_ANDROID)
+      if (device.type == content::MEDIA_DESKTOP_VIDEO_CAPTURE)
+        has_video = true;
+#endif
     }
 
-    return needs_mic == has_mic && needs_cam == has_cam;
+    return needs_audio == has_audio && needs_video == has_video;
   }
 
   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,
       const std::string& video_id,
       content::MediaStreamRequestType request_type) {
     content::MediaStreamType audio_type =
         audio_id.empty() ? content::MEDIA_NO_SERVICE
                          : content::MEDIA_DEVICE_AUDIO_CAPTURE;
     content::MediaStreamType video_type =
         video_id.empty() ? content::MEDIA_NO_SERVICE
                          : content::MEDIA_DEVICE_VIDEO_CAPTURE;
+#if defined(OS_ANDROID)
+    if (!video_id.compare(example_screen_id()))
+      video_type = content::MEDIA_DESKTOP_VIDEO_CAPTURE;
+#endif
+
     return content::MediaStreamRequest(0, 0, 0, example_url(), false,
                                        request_type, audio_id, video_id,
                                        audio_type, video_type);
   }
 
   content::MediaStreamRequest CreateRequest(const std::string& audio_id,
                                             const std::string& video_id) {
     return CreateRequestWithType(audio_id, video_id,
                                  content::MEDIA_DEVICE_ACCESS);
   }
@@ skipping 27 matching lines @@
         content::MEDIA_DEVICE_VIDEO_CAPTURE, example_video_id_,
         "Fake Video Device");
     video_devices.push_back(fake_video_device);
     MediaCaptureDevicesDispatcher::GetInstance()->SetTestVideoCaptureDevices(
         video_devices);
   }
 
   GURL example_url_;
   const std::string example_audio_id_;
   const std::string example_video_id_;
+  const std::string example_screen_id_;
 
   content::MediaStreamDevices media_stream_devices_;
   content::MediaStreamRequestResult media_stream_result_;
 };
 
 // Request and allow microphone access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestAndAllowMic) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_ALLOWED);
   MediaStreamDevicesController controller(
@@ skipping 527 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());
 }
+
+#if defined(OS_ANDROID)
+IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestScreenCapture) {

[Sergey Ulanov, 2016/08/19 05:54:15]

Also add a test for the case when access is denied.

+  InitWithUrl(GURL("https://www.example.com"));
+  // Test that a prompt is required.
+  MediaStreamDevicesController controller(
+      GetWebContents(), CreateRequest(std::string(), example_screen_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 this));
+  ASSERT_TRUE(controller.IsAskingForScreenCapture());
+
+  // Accept the prompt.
+  controller.PermissionGranted();
+  ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
+  ASSERT_TRUE(DevicesContains(false, true));
+
+  // Check that re-requesting still requires prompting.
+  MediaStreamDevicesController controller2(
+      GetWebContents(), CreateRequest(std::string(), example_screen_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 this));
+  ASSERT_TRUE(controller2.IsAskingForScreenCapture());
+}
+#endif