| // Copyright 2023 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <string_view> |
| |
| #include "ash/capture_mode/capture_mode_test_util.h" |
| #include "ash/constants/ash_features.h" |
| #include "ash/constants/ash_pref_names.h" |
| #include "ash/constants/ash_switches.h" |
| #include "ash/public/cpp/capture_mode/capture_mode_test_api.h" |
| #include "ash/session/session_controller_impl.h" |
| #include "ash/shell.h" |
| #include "ash/strings/grit/ash_strings.h" |
| #include "ash/system/audio/audio_effects_controller.h" |
| #include "ash/system/camera/camera_effects_controller.h" |
| #include "ash/system/status_area_widget_test_helper.h" |
| #include "ash/system/toast/anchored_nudge_manager_impl.h" |
| #include "ash/system/video_conference/bubble/bubble_view_ids.h" |
| #include "ash/system/video_conference/bubble/return_to_app_panel.h" |
| #include "ash/system/video_conference/video_conference_tray.h" |
| #include "ash/system/video_conference/video_conference_tray_controller.h" |
| #include "ash/webui/common/mojom/sea_pen.mojom.h" |
| #include "ash/webui/vc_background_ui/url_constants.h" |
| #include "base/command_line.h" |
| #include "base/containers/span.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/run_loop.h" |
| #include "base/strings/string_view_util.h" |
| #include "base/test/bind.h" |
| #include "base/test/gtest_tags.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/test_timeouts.h" |
| #include "chrome/browser/ash/system_web_apps/system_web_app_manager.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/content_settings/host_content_settings_map_factory.h" |
| #include "chrome/browser/media/webrtc/webrtc_browsertest_base.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/browser/ui/views/frame/browser_view.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "chrome/test/base/ui_test_utils.h" |
| #include "chromeos/ash/components/audio/cras_audio_handler.h" |
| #include "components/content_settings/core/browser/host_content_settings_map.h" |
| #include "components/content_settings/core/common/content_settings.h" |
| #include "components/content_settings/core/common/content_settings_types.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/user_manager/user_names.h" |
| #include "content/public/browser/navigation_entry.h" |
| #include "content/public/browser/visibility.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "content/public/test/test_utils.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/events/base_event_utils.h" |
| #include "ui/gfx/codec/jpeg_codec.h" |
| #include "ui/views/test/button_test_api.h" |
| |
| namespace ash::video_conference { |
| |
| namespace { |
| |
| // Helper to generate a fake image. |
| std::string CreateJpgBytes() { |
| SkBitmap bitmap; |
| bitmap.allocN32Pixels(1, 1); |
| std::optional<std::vector<uint8_t>> data = |
| gfx::JPEGCodec::Encode(bitmap, /*quality=*/100); |
| return std::string(base::as_string_view(data.value())); |
| } |
| |
| bool IsNudgeShown(const std::string& id) { |
| return Shell::Get()->anchored_nudge_manager()->IsNudgeShown(id); |
| } |
| |
| std::u16string_view GetNudgeText(const std::string& id) { |
| return Shell::Get()->anchored_nudge_manager()->GetNudgeBodyTextForTest(id); |
| } |
| |
| views::View* GetNudgeAnchorView(const std::string& id) { |
| return Shell::Get()->anchored_nudge_manager()->GetNudgeAnchorViewForTest(id); |
| } |
| |
| } // namespace |
| |
| constexpr char kVideoConferenceTrayMicrophoneUseWhileSWDisabledNudgeId[] = |
| "video_conference_tray_nudge_ids.microphone_use_while_sw_disabled"; |
| constexpr char kVideoConferenceTrayCameraUseWhileSWDisabledNudgeId[] = |
| "video_conference_tray_nudge_ids.camera_use_while_sw_disabled"; |
| const char16_t kTitle1[] = u"Title1"; |
| const char16_t kTitle2[] = u"Title2"; |
| |
| // Periodically checks the condition and move on with the rest of the code when |
| // the condition becomes true. Please tell me this is something you have been |
| // wanting for very long time. |
| #define WAIT_FOR_CONDITION(condition) \ |
| { \ |
| base::RunLoop run_loop; \ |
| CheckForConditionAndWaitMoreIfNeeded( \ |
| base::BindRepeating( \ |
| base::BindLambdaForTesting([&]() { return condition; })), \ |
| run_loop.QuitClosure()); \ |
| run_loop.Run(); \ |
| } |
| |
| // Periodically calls `condition` until it becomes true then calls |
| // `quit_closure`. |
| void CheckForConditionAndWaitMoreIfNeeded( |
| base::RepeatingCallback<bool()> condition, |
| base::OnceClosure quit_closure) { |
| if (condition.Run()) { |
| std::move(quit_closure).Run(); |
| return; |
| } |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask( |
| FROM_HERE, |
| base::BindOnce(&CheckForConditionAndWaitMoreIfNeeded, |
| std::move(condition), std::move(quit_closure)), |
| TestTimeouts::tiny_timeout()); |
| } |
| |
| // Helper for getting the VcTray. |
| ash::VideoConferenceTray* GetVcTray() { |
| return ash::StatusAreaWidgetTestHelper::GetStatusAreaWidget() |
| ->video_conference_tray(); |
| } |
| |
| // Simulates left click on the `button`. |
| void ClickButton(views::Button* button) { |
| ui::MouseEvent event(ui::EventType::kMousePressed, gfx::Point(), gfx::Point(), |
| ui::EventTimeForNow(), 0, 0); |
| views::test::ButtonTestApi(button).NotifyClick(event); |
| } |
| |
| // Parameter stands for whether in incognito mode; and whether in guest mode. |
| class VideoConferenceIntegrationTest |
| : public testing::WithParamInterface<std::tuple<bool, bool>>, |
| public WebRtcTestBase { |
| public: |
| VideoConferenceIntegrationTest() { |
| // kOnDeviceSpeechRecognition is to support live caption. |
| scoped_feature_list_.InitWithFeatures( |
| {ash::features::kVcStopAllScreenShare, |
| ash::features::kOnDeviceSpeechRecognition, |
| ash::features::kFeatureManagementVideoConference, |
| ash::features::kVcBackgroundReplace, |
| ash::features::kShowLiveCaptionInVideoConferenceTray}, |
| {}); |
| } |
| |
| ~VideoConferenceIntegrationTest() override = default; |
| |
| void SetUpOnMainThread() override { |
| is_incognito_mode_ = std::get<0>(GetParam()); |
| is_guest_mode_ = std::get<1>(GetParam()); |
| |
| WebRtcTestBase::SetUpOnMainThread(); |
| |
| ASSERT_TRUE(embedded_test_server()->Start()); |
| |
| // Create an incognito browser when parameter is true. |
| if (is_incognito_mode_) { |
| browser_ = Browser::Create(Browser::CreateParams( |
| browser()->profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true), |
| true)); |
| // This creates a blank page which is more consistent with normal mode. |
| ui_test_utils::NavigateToURLWithDispositionBlockUntilNavigationsComplete( |
| browser_, GURL("chrome://blank"), 1, |
| WindowOpenDisposition::NEW_FOREGROUND_TAB, |
| ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB | |
| ui_test_utils::BROWSER_TEST_WAIT_FOR_LOAD_STOP); |
| } else { |
| browser_ = browser(); |
| } |
| |
| // Enable test mode to mock the SetCameraEffects calls. |
| camera_effects_controller()->bypass_set_camera_effects_for_testing(true); |
| |
| camera_background_img_dir_ = browser()->profile()->GetPath().AppendASCII( |
| "camera_background_img_dir"); |
| camera_background_run_dir_ = browser()->profile()->GetPath().AppendASCII( |
| "camera_background_run_dir"); |
| camera_effects_controller()->set_camera_background_img_dir_for_testing( |
| camera_background_img_dir_); |
| camera_effects_controller()->set_camera_background_run_dir_for_testing( |
| camera_background_run_dir_); |
| |
| // Required for the VcBackgroundApp. |
| ash::SystemWebAppManager::Get(browser()->profile()) |
| ->InstallSystemAppsForTesting(); |
| } |
| |
| // Navigate to the url in a new tab. |
| content::WebContents* NavigateTo(const std::string& url_str) { |
| const GURL url(embedded_test_server()->GetURL(url_str)); |
| content::RenderFrameHost* main_rfh = ui_test_utils:: |
| NavigateToURLWithDispositionBlockUntilNavigationsComplete( |
| browser_, url, 1, WindowOpenDisposition::NEW_FOREGROUND_TAB, |
| ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB | |
| ui_test_utils::BROWSER_TEST_WAIT_FOR_LOAD_STOP); |
| content::WebContents* web_contents = |
| content::WebContents::FromRenderFrameHost(main_rfh); |
| return web_contents; |
| } |
| |
| // Allows or disallow permissions for `web_contents`. |
| void SetPermission(content::WebContents* web_contents, |
| ContentSettingsType type, |
| ContentSetting result) { |
| HostContentSettingsMapFactory::GetForProfile(browser_->profile()) |
| ->SetContentSettingDefaultScope(web_contents->GetURL(), GURL(), type, |
| result); |
| } |
| |
| void StartCamera(content::WebContents* web_contents) { |
| // Foreground is required for multiple tabs cases. |
| web_contents->GetDelegate()->ActivateContents(web_contents); |
| EXPECT_TRUE(content::ExecJs(web_contents, "startVideo();")); |
| } |
| |
| void StopCamera(content::WebContents* web_contents) { |
| // Foreground is required for multiple tabs cases. |
| web_contents->GetDelegate()->ActivateContents(web_contents); |
| EXPECT_TRUE(content::ExecJs(web_contents, "stopVideo();")); |
| } |
| |
| void StartMicrophone(content::WebContents* web_contents) { |
| // Foreground is required for multiple tabs cases. |
| web_contents->GetDelegate()->ActivateContents(web_contents); |
| EXPECT_TRUE(content::ExecJs(web_contents, "startAudio();")); |
| } |
| void StopMicrophone(content::WebContents* web_contents) { |
| // Foreground is required for multiple tabs cases. |
| web_contents->GetDelegate()->ActivateContents(web_contents); |
| EXPECT_TRUE(content::ExecJs(web_contents, "stopAudio();")); |
| } |
| |
| void StartScreenSharing(content::WebContents* web_contents) { |
| // Foreground is required for multiple tabs cases. |
| web_contents->GetDelegate()->ActivateContents(web_contents); |
| EXPECT_TRUE(content::ExecJs(web_contents, "startScreenSharing();")); |
| } |
| void StopScreenSharing(content::WebContents* web_contents) { |
| // Foreground is required for multiple tabs cases. |
| web_contents->GetDelegate()->ActivateContents(web_contents); |
| EXPECT_TRUE(content::ExecJs(web_contents, "stopScreenSharing();")); |
| } |
| |
| // Changes the title of the `web_contents` to be `title`. |
| void SetTitle(content::WebContents* web_contents, |
| const std::u16string& title) { |
| web_contents->GetController().GetLastCommittedEntry()->SetTitle(title); |
| } |
| |
| // Generates a background image with given id as name, and apply that as the |
| // camera background. |
| base::FilePath CreateAndApplyBackgroundImage(uint32_t id) { |
| base::RunLoop run_loop; |
| camera_effects_controller()->SetBackgroundImageFromContent( |
| SeaPenImage(CreateJpgBytes(), id), "", |
| base::BindLambdaForTesting([&](bool call_succeeded) { |
| EXPECT_TRUE(call_succeeded); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| return CameraEffectsController::SeaPenIdToRelativePath(id); |
| } |
| |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| // Flags use to automatically select the right desktop source and get |
| // around security restrictions. |
| // TODO(crbug.com/40274188): Use a less error-prone flag. |
| command_line->AppendSwitchASCII(::switches::kAutoSelectDesktopCaptureSource, |
| "Display"); |
| |
| // If in guest mode. |
| if (is_guest_mode_) { |
| command_line->AppendSwitch(ash::switches::kGuestSession); |
| command_line->AppendSwitchASCII(ash::switches::kLoginUser, |
| user_manager::kGuestUserName); |
| command_line->AppendSwitchASCII(ash::switches::kLoginProfile, |
| TestingProfile::kTestUserProfileDir); |
| command_line->AppendSwitch(::switches::kIncognito); |
| } |
| } |
| |
| // Returns all `ReturnToAppButton`s into a vector for easier check. |
| std::vector<ReturnToAppButton*> GetReturnToAppButtons() { |
| ReturnToAppPanel* return_to_app_panel = static_cast<ReturnToAppPanel*>( |
| GetVcTray()->GetBubbleView()->GetViewByID(BubbleViewID::kReturnToApp)); |
| |
| std::vector<ReturnToAppButton*> output; |
| for (views::View* button : |
| return_to_app_panel->container_view_->children()) { |
| output.push_back(static_cast<ReturnToAppButton*>(button)); |
| } |
| return output; |
| } |
| |
| // Returns the ReturnToAppButton with the given `title`. |
| ReturnToAppButton* FindReturnToAppButtonByTitle(const std::u16string& title) { |
| for (auto* bt : GetReturnToAppButtons()) { |
| if (bt->label()->GetText() == title) { |
| return bt; |
| } |
| } |
| |
| return nullptr; |
| } |
| |
| // Helper function that triggers the VcTray with |
| // (1) tab video_conference_demo.html |
| // (2) both camera and microphone permissions. |
| // (3) capturing state based the parameters. |
| // This function is to simplify test cases. |
| content::WebContents* TriggeringTray(bool use_camera, |
| bool use_microphone, |
| bool use_screen_sharing) { |
| // Open a tab. |
| content::WebContents* web_contents = |
| NavigateTo("/video_conference_demo.html"); |
| // Set permissions as allow. |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_CAMERA, |
| CONTENT_SETTING_ALLOW); |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_MIC, |
| CONTENT_SETTING_ALLOW); |
| |
| // Change title. |
| SetTitle(web_contents, kTitle1); |
| |
| if (use_camera) { |
| StartCamera(web_contents); |
| WAIT_FOR_CONDITION(camera_bt()->is_capturing()); |
| } |
| |
| if (use_microphone) { |
| StartMicrophone(web_contents); |
| WAIT_FOR_CONDITION(mic_bt()->is_capturing()); |
| } |
| |
| if (use_screen_sharing) { |
| StartScreenSharing(web_contents); |
| WAIT_FOR_CONDITION(share_bt()->is_capturing()); |
| } |
| |
| return web_contents; |
| } |
| |
| VideoConferenceTrayButton* camera_bt() { return GetVcTray()->camera_icon(); } |
| VideoConferenceTrayButton* mic_bt() { return GetVcTray()->audio_icon(); } |
| VideoConferenceTrayButton* share_bt() { |
| return GetVcTray()->screen_share_icon(); |
| } |
| |
| CameraEffectsController* camera_effects_controller() { |
| return Shell::Get()->camera_effects_controller(); |
| } |
| |
| protected: |
| raw_ptr<Browser, DanglingUntriaged> browser_ = nullptr; |
| |
| base::FilePath camera_background_img_dir_; |
| base::FilePath camera_background_run_dir_; |
| |
| bool is_guest_mode_ = false; |
| bool is_incognito_mode_ = false; |
| |
| base::test::ScopedFeatureList scoped_feature_list_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| , // Empty to simplify gtest output |
| VideoConferenceIntegrationTest, |
| ::testing::Values(std::make_tuple<bool, bool>(false, false), |
| std::make_tuple<bool, bool>(true, false), |
| std::make_tuple<bool, bool>(false, true))); |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| CaptureVideoShowsVcTray) { |
| // Trigger the VcTray with camera accessing. |
| content::WebContents* web_contents = |
| TriggeringTray(/*use_camera=*/true, |
| /*use_microphone=*/false, |
| /*use_screen_sharing=*/false); |
| |
| // camera_icon should be visible with green_dot. |
| EXPECT_TRUE(camera_bt()->GetVisible()); |
| EXPECT_TRUE(camera_bt()->is_capturing()); |
| EXPECT_TRUE(camera_bt()->show_privacy_indicator()); |
| |
| // audio_icon should be visible without green_dot. |
| EXPECT_TRUE(mic_bt()->GetVisible()); |
| EXPECT_FALSE(mic_bt()->is_capturing()); |
| EXPECT_FALSE(mic_bt()->show_privacy_indicator()); |
| |
| // screen_share_icon should be invisible. |
| EXPECT_FALSE(share_bt()->GetVisible()); |
| EXPECT_FALSE(share_bt()->is_capturing()); |
| EXPECT_FALSE(share_bt()->show_privacy_indicator()); |
| |
| // Stop camera and wait for is_capturing to populate. |
| StopCamera(web_contents); |
| WAIT_FOR_CONDITION(!camera_bt()->is_capturing()); |
| |
| // camera_icon should be visible without green_dot. |
| EXPECT_TRUE(camera_bt()->GetVisible()); |
| EXPECT_FALSE(camera_bt()->is_capturing()); |
| EXPECT_FALSE(camera_bt()->show_privacy_indicator()); |
| |
| // Close tab and wait for the tray to dispear. |
| web_contents->Close(); |
| WAIT_FOR_CONDITION(!GetVcTray()->GetVisible()); |
| // camera_icon should be invisible. |
| EXPECT_FALSE(camera_bt()->GetVisible()); |
| EXPECT_FALSE(camera_bt()->is_capturing()); |
| EXPECT_FALSE(camera_bt()->show_privacy_indicator()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| CaptureAudioShowsVcTray) { |
| // Trigger the VcTray with microphone accessing. |
| content::WebContents* web_contents = |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/true, |
| /*use_screen_sharing=*/false); |
| |
| // camera_icon should be visible without green_dot. |
| EXPECT_TRUE(camera_bt()->GetVisible()); |
| EXPECT_FALSE(camera_bt()->is_capturing()); |
| EXPECT_FALSE(camera_bt()->show_privacy_indicator()); |
| |
| // audio_icon should be visible with green_dot. |
| EXPECT_TRUE(mic_bt()->GetVisible()); |
| EXPECT_TRUE(mic_bt()->is_capturing()); |
| EXPECT_TRUE(mic_bt()->show_privacy_indicator()); |
| |
| // screen_share_icon should be invisible. |
| EXPECT_FALSE(share_bt()->GetVisible()); |
| EXPECT_FALSE(share_bt()->is_capturing()); |
| EXPECT_FALSE(share_bt()->show_privacy_indicator()); |
| |
| // Stop microphone and wait for is_capturing to populate. |
| StopMicrophone(web_contents); |
| WAIT_FOR_CONDITION(!mic_bt()->is_capturing()); |
| |
| // audio_icon should be visible without green_dot. |
| EXPECT_TRUE(mic_bt()->GetVisible()); |
| EXPECT_FALSE(mic_bt()->is_capturing()); |
| EXPECT_FALSE(mic_bt()->show_privacy_indicator()); |
| |
| // Close tab and wait for the tray to dispear. |
| web_contents->Close(); |
| WAIT_FOR_CONDITION(!GetVcTray()->GetVisible()); |
| // audio_icon should be invisible. |
| EXPECT_FALSE(mic_bt()->GetVisible()); |
| EXPECT_FALSE(mic_bt()->is_capturing()); |
| EXPECT_FALSE(mic_bt()->show_privacy_indicator()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| ScreenSharingShowsVcTray) { |
| // Trigger the VcTray with screen sharing. |
| content::WebContents* web_contents = |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/false, |
| /*use_screen_sharing=*/true); |
| |
| // camera_icon should be invisible. |
| EXPECT_TRUE(camera_bt()->GetVisible()); |
| EXPECT_FALSE(camera_bt()->is_capturing()); |
| EXPECT_FALSE(camera_bt()->show_privacy_indicator()); |
| |
| // audio_icon should be invisible with green_dot. |
| EXPECT_TRUE(mic_bt()->GetVisible()); |
| EXPECT_FALSE(mic_bt()->is_capturing()); |
| EXPECT_FALSE(mic_bt()->show_privacy_indicator()); |
| |
| // screen_share_icon should be visible. |
| EXPECT_TRUE(share_bt()->GetVisible()); |
| EXPECT_TRUE(share_bt()->is_capturing()); |
| EXPECT_TRUE(share_bt()->show_privacy_indicator()); |
| |
| // Stop microphone and wait for is_capturing to populate. |
| StopScreenSharing(web_contents); |
| WAIT_FOR_CONDITION(!share_bt()->is_capturing()); |
| |
| EXPECT_FALSE(share_bt()->GetVisible()); |
| EXPECT_FALSE(share_bt()->is_capturing()); |
| EXPECT_FALSE(share_bt()->show_privacy_indicator()); |
| |
| // VcTray should be invisible. |
| EXPECT_TRUE(GetVcTray()->GetVisible()); |
| |
| web_contents->Close(); |
| WAIT_FOR_CONDITION(!GetVcTray()->GetVisible()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| MicWithoutPermissionShouldNotShow) { |
| base::AddFeatureIdTagToTestResult( |
| "screenplay-92ebd14e-9017-4734-ae47-e9dc6afc6e87"); |
| |
| // Open a tab. |
| content::WebContents* web_contents = |
| NavigateTo("/video_conference_demo.html"); |
| |
| // Set permissions. |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_CAMERA, |
| CONTENT_SETTING_ALLOW); |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_MIC, |
| CONTENT_SETTING_BLOCK); |
| |
| // Start camera and wait for the tray to show. |
| StartCamera(web_contents); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Audio icon should not show because the permission is blocked. |
| EXPECT_TRUE(camera_bt()->GetVisible()); |
| EXPECT_FALSE(mic_bt()->GetVisible()); |
| EXPECT_FALSE(share_bt()->GetVisible()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| CameraWithoutPermissionShouldNotShow) { |
| base::AddFeatureIdTagToTestResult( |
| "screenplay-2d9bddf4-8d96-4304-a605-1140f9a0b45e"); |
| |
| // Open a tab. |
| content::WebContents* web_contents = |
| NavigateTo("/video_conference_demo.html"); |
| |
| // Set permissions. |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_CAMERA, |
| CONTENT_SETTING_BLOCK); |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_MIC, |
| CONTENT_SETTING_ALLOW); |
| |
| // Start microphone and wait for the tray to show. |
| StartMicrophone(web_contents); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Camera icon should not show because the permission is blocked. |
| EXPECT_FALSE(camera_bt()->GetVisible()); |
| EXPECT_TRUE(mic_bt()->GetVisible()); |
| EXPECT_FALSE(share_bt()->GetVisible()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| CameraMicWithoutPermissionShouldNotShow) { |
| // Open a tab. |
| content::WebContents* web_contents = |
| NavigateTo("/video_conference_demo.html"); |
| |
| // Set permissions. |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_CAMERA, |
| CONTENT_SETTING_BLOCK); |
| SetPermission(web_contents, ContentSettingsType::MEDIASTREAM_MIC, |
| CONTENT_SETTING_BLOCK); |
| |
| // Start screen sharing and wait for the tray to show. |
| StartScreenSharing(web_contents); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Both microphone and camera should not show. |
| EXPECT_FALSE(camera_bt()->GetVisible()); |
| EXPECT_FALSE(mic_bt()->GetVisible()); |
| EXPECT_TRUE(share_bt()->GetVisible()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| ClickOnTheMicOrCameraIconsShouldMute) { |
| base::AddFeatureIdTagToTestResult( |
| "screenplay-cc18f9a3-e46f-4192-b505-876975c5ef4b"); |
| |
| // Trigger the VcTray with microphone. |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/true, |
| /*use_screen_sharing=*/false); |
| |
| // Clicking on the mic icon should mute it. |
| ClickButton(mic_bt()); |
| WAIT_FOR_CONDITION(mic_bt()->toggled()); |
| EXPECT_FALSE(mic_bt()->show_privacy_indicator()); |
| |
| // Clicking on the mic icon again should unmute it. |
| ClickButton(mic_bt()); |
| WAIT_FOR_CONDITION(!mic_bt()->toggled()); |
| EXPECT_TRUE(mic_bt()->show_privacy_indicator()); |
| |
| // Clicking on the camera icon should mute it. |
| ClickButton(camera_bt()); |
| WAIT_FOR_CONDITION(camera_bt()->toggled()); |
| EXPECT_FALSE(camera_bt()->show_privacy_indicator()); |
| |
| // Clicking on the camera icon again should unmute it. |
| ClickButton(camera_bt()); |
| WAIT_FOR_CONDITION(!camera_bt()->toggled()); |
| EXPECT_FALSE(camera_bt()->show_privacy_indicator()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| OneTabReturnToAppInformation) { |
| // Trigger the VcTray with microphone. |
| content::WebContents* web_contents = |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/true, |
| /*use_screen_sharing=*/false); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // Chceck the button for title and capturing information. |
| // Only is_capturing_microphone should be true. |
| auto buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 1u); |
| EXPECT_FALSE(buttons[0]->is_capturing_camera()); |
| EXPECT_TRUE(buttons[0]->is_capturing_microphone()); |
| EXPECT_FALSE(buttons[0]->is_capturing_screen()); |
| EXPECT_EQ(buttons[0]->label()->GetText(), kTitle1); |
| |
| // We want to close the panel and open it every time. |
| GetVcTray()->CloseBubble(); |
| |
| // Start accessing camera. |
| StartCamera(web_contents); |
| WAIT_FOR_CONDITION(camera_bt()->show_privacy_indicator()); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // Chceck the button for title and capturing information. |
| // is_capturing_camera and is_capturing_microphone should be true. |
| buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 1u); |
| EXPECT_TRUE(buttons[0]->is_capturing_camera()); |
| EXPECT_TRUE(buttons[0]->is_capturing_microphone()); |
| EXPECT_FALSE(buttons[0]->is_capturing_screen()); |
| EXPECT_EQ(buttons[0]->label()->GetText(), kTitle1); |
| |
| // We want to close the panel and open it every time. |
| GetVcTray()->CloseBubble(); |
| |
| // Start screen sharing. |
| StartScreenSharing(web_contents); |
| WAIT_FOR_CONDITION(share_bt()->show_privacy_indicator()); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // Chceck the button for title and capturing information. |
| // All capturing should be true. |
| buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 1u); |
| EXPECT_TRUE(buttons[0]->is_capturing_camera()); |
| EXPECT_TRUE(buttons[0]->is_capturing_microphone()); |
| EXPECT_TRUE(buttons[0]->is_capturing_screen()); |
| EXPECT_EQ(buttons[0]->label()->GetText(), kTitle1); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, OneTabReturnToApp) { |
| // Trigger the VcTray with microphone. |
| content::WebContents* web_contents = |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/true, |
| /*use_screen_sharing=*/false); |
| |
| // Switch to the default tab at 0; this should make the `web_contents` hidden. |
| browser_->tab_strip_model()->ActivateTabAt(0); |
| WAIT_FOR_CONDITION(web_contents->GetVisibility() == |
| content::Visibility::HIDDEN); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // Click on the ReturnToApp button should make the `web_contents` visible |
| // again. |
| ClickButton(GetReturnToAppButtons()[0]); |
| WAIT_FOR_CONDITION(web_contents->GetVisibility() == |
| content::Visibility::VISIBLE); |
| |
| // We want to close the panel and open it every time. |
| GetVcTray()->CloseBubble(); |
| |
| // Minimize the browser window; this should make the `web_contents` hidden. |
| browser_->window()->Minimize(); |
| WAIT_FOR_CONDITION(web_contents->GetVisibility() == |
| content::Visibility::HIDDEN); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // Click on the ReturnToApp button should make the `web_contents` visible |
| // again. |
| ClickButton(GetReturnToAppButtons()[0]); |
| WAIT_FOR_CONDITION(web_contents->GetVisibility() == |
| content::Visibility::VISIBLE); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, UseWhileDisabled) { |
| base::AddFeatureIdTagToTestResult( |
| "screenplay-f583c1ff-db6f-460e-b1f2-ddec173359a6"); |
| base::AddFeatureIdTagToTestResult( |
| "screenplay-3042cdd9-978d-432c-8488-77684b09a9e4"); |
| |
| // Prevent "Speak-on-mute opt-in" nudge from showing so it doesn't cancel |
| // other shown nudges. |
| Shell::Get()->session_controller()->GetActivePrefService()->SetBoolean( |
| prefs::kShouldShowSpeakOnMuteOptInNudge, false); |
| |
| // Trigger the VcTray with microphone. |
| content::WebContents* web_contents = |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/true, |
| /*use_screen_sharing=*/false); |
| |
| auto* microphone_nudge_id = |
| kVideoConferenceTrayMicrophoneUseWhileSWDisabledNudgeId; |
| |
| // Stop microphone and wait for is_capturing to populate. |
| StopMicrophone(web_contents); |
| WAIT_FOR_CONDITION(!mic_bt()->is_capturing()); |
| |
| // Clicking on the mic icon should mute it. |
| ClickButton(mic_bt()); |
| WAIT_FOR_CONDITION(mic_bt()->toggled()); |
| |
| // Start accessing microphone should trigger UseWhileDisabled. |
| StartMicrophone(web_contents); |
| WAIT_FOR_CONDITION(IsNudgeShown(microphone_nudge_id)); |
| |
| // Check the nudge message and anchor view is as expected. |
| EXPECT_EQ( |
| GetNudgeText(microphone_nudge_id), |
| l10n_util::GetStringFUTF16( |
| IDS_ASH_VIDEO_CONFERENCE_TOAST_USE_WHILE_DISABLED, kTitle1, |
| l10n_util::GetStringUTF16(IDS_ASH_VIDEO_CONFERENCE_MICROPHONE_NAME))); |
| EXPECT_EQ(GetNudgeAnchorView(microphone_nudge_id), GetVcTray()->audio_icon()); |
| |
| // Remove current nudge for the next step. |
| Shell::Get()->anchored_nudge_manager()->Cancel(microphone_nudge_id); |
| WAIT_FOR_CONDITION(!IsNudgeShown(microphone_nudge_id)); |
| |
| auto* camera_nudge_id = kVideoConferenceTrayCameraUseWhileSWDisabledNudgeId; |
| |
| // Clicking on the camera icon should mute it. |
| ClickButton(camera_bt()); |
| WAIT_FOR_CONDITION(camera_bt()->toggled()); |
| |
| // Start accessing camera should trigger UseWhileDisabled. |
| StartCamera(web_contents); |
| WAIT_FOR_CONDITION(IsNudgeShown(camera_nudge_id)); |
| |
| // Check the nudge message and anchor view is as expected. |
| EXPECT_EQ( |
| GetNudgeText(camera_nudge_id), |
| l10n_util::GetStringFUTF16( |
| IDS_ASH_VIDEO_CONFERENCE_TOAST_USE_WHILE_DISABLED, kTitle1, |
| l10n_util::GetStringUTF16(IDS_ASH_VIDEO_CONFERENCE_CAMERA_NAME))); |
| EXPECT_EQ(GetNudgeAnchorView(camera_nudge_id), GetVcTray()->camera_icon()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| TwoTabsButtonInformation) { |
| // Open a tab. |
| content::WebContents* web_contents_1 = |
| NavigateTo("/video_conference_demo.html"); |
| // Set permissions as allow. |
| SetPermission(web_contents_1, ContentSettingsType::MEDIASTREAM_CAMERA, |
| CONTENT_SETTING_ALLOW); |
| SetPermission(web_contents_1, ContentSettingsType::MEDIASTREAM_MIC, |
| CONTENT_SETTING_ALLOW); |
| // Set title. |
| SetTitle(web_contents_1, kTitle1); |
| |
| // Open second tab. |
| content::WebContents* web_contents_2 = |
| NavigateTo("/video_conference_demo.html"); |
| // Set title. |
| SetTitle(web_contents_2, kTitle2); |
| |
| StartMicrophone(web_contents_1); |
| StartMicrophone(web_contents_2); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // There should be three buttons, the first one is the summary button. |
| auto buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 3u); |
| |
| // Button[0] is the summary button. |
| EXPECT_FALSE(buttons[0]->is_capturing_camera()); |
| EXPECT_TRUE(buttons[0]->is_capturing_microphone()); |
| EXPECT_FALSE(buttons[0]->is_capturing_screen()); |
| EXPECT_EQ(buttons[0]->label()->GetText(), u"Used by 2 apps"); |
| |
| // Check information of the button for web_contents_1. |
| const auto* bt_1 = FindReturnToAppButtonByTitle(kTitle1); |
| EXPECT_FALSE(bt_1->is_capturing_camera()); |
| EXPECT_TRUE(bt_1->is_capturing_microphone()); |
| EXPECT_FALSE(bt_1->is_capturing_screen()); |
| |
| // Check information of the button for web_contents_2. |
| const auto* bt_2 = FindReturnToAppButtonByTitle(kTitle2); |
| EXPECT_FALSE(bt_2->is_capturing_camera()); |
| EXPECT_TRUE(bt_2->is_capturing_microphone()); |
| EXPECT_FALSE(bt_2->is_capturing_screen()); |
| |
| // We want to close the panel and open it every time. |
| GetVcTray()->CloseBubble(); |
| StartCamera(web_contents_1); |
| StartScreenSharing(web_contents_2); |
| |
| // Wait for signals to populate. |
| WAIT_FOR_CONDITION(camera_bt()->show_privacy_indicator()); |
| WAIT_FOR_CONDITION(share_bt()->show_privacy_indicator()); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // There should be three buttons, the first one is the summary button. |
| buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 3u); |
| |
| // Button[0] is the summary button. |
| EXPECT_TRUE(buttons[0]->is_capturing_camera()); |
| EXPECT_TRUE(buttons[0]->is_capturing_microphone()); |
| EXPECT_TRUE(buttons[0]->is_capturing_screen()); |
| EXPECT_EQ(buttons[0]->label()->GetText(), u"Used by 2 apps"); |
| |
| // Check information of the button for web_contents_1. |
| bt_1 = FindReturnToAppButtonByTitle(kTitle1); |
| EXPECT_TRUE(bt_1->is_capturing_camera()); |
| EXPECT_TRUE(bt_1->is_capturing_microphone()); |
| EXPECT_FALSE(bt_1->is_capturing_screen()); |
| |
| // Check information of the button for web_contents_2. |
| bt_2 = FindReturnToAppButtonByTitle(kTitle2); |
| EXPECT_FALSE(bt_2->is_capturing_camera()); |
| EXPECT_TRUE(bt_2->is_capturing_microphone()); |
| EXPECT_TRUE(bt_2->is_capturing_screen()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, TwoTabsReturnToApp) { |
| // Open a tab. |
| content::WebContents* web_contents_1 = |
| NavigateTo("/video_conference_demo.html"); |
| // Set permissions as allow. |
| SetPermission(web_contents_1, ContentSettingsType::MEDIASTREAM_CAMERA, |
| CONTENT_SETTING_ALLOW); |
| SetPermission(web_contents_1, ContentSettingsType::MEDIASTREAM_MIC, |
| CONTENT_SETTING_ALLOW); |
| // Set title. |
| SetTitle(web_contents_1, kTitle1); |
| |
| // Open second tab. |
| content::WebContents* web_contents_2 = |
| NavigateTo("/video_conference_demo.html"); |
| // Set title. |
| SetTitle(web_contents_2, kTitle2); |
| |
| StartMicrophone(web_contents_1); |
| StartMicrophone(web_contents_2); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| auto buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 3u); |
| |
| // Verify that web_contents_2 is foregrounded and web_contents_1 is |
| // backgrounded. |
| EXPECT_EQ(web_contents_2->GetVisibility(), content::Visibility::VISIBLE); |
| EXPECT_NE(web_contents_1->GetVisibility(), content::Visibility::VISIBLE); |
| |
| // Click on web_contents_1 and expect the visibility to change. |
| ClickButton(FindReturnToAppButtonByTitle(kTitle1)); |
| WAIT_FOR_CONDITION(web_contents_1->GetVisibility() == |
| content::Visibility::VISIBLE); |
| EXPECT_NE(web_contents_2->GetVisibility(), content::Visibility::VISIBLE); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| ExpectedButtonsAreShown) { |
| // In order to set noise cancellation support, we need to call |
| // CrasAudioHandler::Get()->SetNoiseCancellationSupportedForTesting(true) |
| // But by the time it reaches here, the audio_effects_controller is already |
| // constructed based on the fact that the Noise Cancellation is not supported. |
| // The way to fix that is: |
| // (1) Unregister audio_effects_controller |
| // (2) SetNoiseCancellationSupportedForTesting(true) |
| // (3) Register audio_effects_controller again with |
| // OnActiveUserPrefServiceChanged. |
| auto* audio_effects_controller = Shell::Get()->audio_effects_controller(); |
| VideoConferenceTrayController::Get()->GetEffectsManager().UnregisterDelegate( |
| audio_effects_controller); |
| CrasAudioHandler::Get()->SetNoiseCancellationSupportedForTesting(true); |
| audio_effects_controller->OnActiveUserPrefServiceChanged( |
| g_browser_process->local_state()); |
| |
| // Trigger the VcTray with microphone. |
| TriggeringTray(/*use_camera=*/false, |
| /*use_microphone=*/true, |
| /*use_screen_sharing=*/false); |
| |
| // Wait for VcPanel to appear. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| bool found_live_caption_button = false; |
| bool found_noise_cancellation_buttion = false; |
| |
| auto* toggle_effects_view = GetVcTray()->GetBubbleView()->GetViewByID( |
| BubbleViewID::kToggleEffectsView); |
| |
| for (views::View* row : toggle_effects_view->children()) { |
| for (views::View* tile : row->children()) { |
| // Each tile is a button to click on; we want its label. |
| views::Label* label = static_cast<views::Label*>( |
| tile->GetViewByID(BubbleViewID::kToggleEffectLabel)); |
| |
| if (label->GetText() == |
| l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_LIVE_CAPTION)) { |
| found_live_caption_button = true; |
| } |
| |
| if (label->GetText() == |
| l10n_util::GetStringUTF16( |
| IDS_ASH_STATUS_TRAY_AUDIO_INPUT_NOISE_CANCELLATION)) { |
| found_noise_cancellation_buttion = true; |
| } |
| } |
| } |
| |
| EXPECT_TRUE(found_live_caption_button); |
| EXPECT_TRUE(found_noise_cancellation_buttion); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, StopAllScreenShare) { |
| // Open a tab. |
| content::WebContents* web_contents_1 = |
| NavigateTo("/video_conference_demo.html"); |
| |
| // Start the screen sharing. |
| StartScreenSharing(web_contents_1); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Get the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| |
| // Check that web_contents_1 is sharing screen. |
| auto buttons = GetReturnToAppButtons(); |
| EXPECT_EQ(buttons.size(), 1u); |
| EXPECT_FALSE(buttons[0]->is_capturing_camera()); |
| EXPECT_FALSE(buttons[0]->is_capturing_microphone()); |
| EXPECT_TRUE(buttons[0]->is_capturing_screen()); |
| |
| // Hide the ReturnToApp Panel. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| |
| // Click on the screen share button. |
| EXPECT_TRUE(share_bt()->is_capturing()); |
| ClickButton(share_bt()); |
| WAIT_FOR_CONDITION(!share_bt()->is_capturing()); |
| |
| // Check that web_contents_1 has stopped sharing screen. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| WAIT_FOR_CONDITION(GetVcTray()->GetBubbleView()->GetVisible()); |
| EXPECT_FALSE(GetReturnToAppButtons()[0]->is_capturing_screen()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| ImageButtonShouldActivateWebui) { |
| if (is_guest_mode_) { |
| GTEST_SKIP() << "Skip for guest mode."; |
| } |
| |
| // Trigger the VcTray with camera accessing. |
| TriggeringTray(/*use_camera=*/true, |
| /*use_microphone=*/false, |
| /*use_screen_sharing=*/false); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Wait until the VcBubble is visible. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| auto* buble_view = GetVcTray()->GetBubbleView(); |
| WAIT_FOR_CONDITION(buble_view->GetVisible()); |
| |
| views::View* background_image_button = |
| buble_view->GetViewByID(BubbleViewID::kBackgroundBlurImageButton); |
| |
| // Expect the image button to be visible. |
| EXPECT_TRUE(background_image_button->GetVisible()); |
| |
| // Expect the SetCameraBackgroundView to be invisible. |
| EXPECT_FALSE(buble_view->GetViewByID(BubbleViewID::kSetCameraBackgroundView) |
| ->GetVisible()); |
| |
| content::WebContentsAddedObserver web_contents_added_observer; |
| |
| // Clicking on the Image button should open the VcBackgroundApp. |
| ClickButton(views::AsViewClass<views::Button>(background_image_button)); |
| content::WebContents* new_contents = |
| web_contents_added_observer.GetWebContents(); |
| |
| EXPECT_EQ(GURL(vc_background_ui::kChromeUIVcBackgroundURL), |
| new_contents->GetVisibleURL()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| CreateWithAiButtonShouldActivateWebui) { |
| if (is_guest_mode_) { |
| GTEST_SKIP() << "Skip for guest mode."; |
| } |
| |
| CreateAndApplyBackgroundImage(123u); |
| |
| // Trigger the VcTray with camera accessing. |
| TriggeringTray(/*use_camera=*/true, |
| /*use_microphone=*/false, |
| /*use_screen_sharing=*/false); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Wait until the VcBubble is visible. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| auto* buble_view = GetVcTray()->GetBubbleView(); |
| WAIT_FOR_CONDITION(buble_view->GetVisible()); |
| |
| // SetCameraBackgroundView should be visible. |
| EXPECT_TRUE(buble_view->GetViewByID(BubbleViewID::kSetCameraBackgroundView) |
| ->GetVisible()); |
| |
| // Create with AI button should be visible. |
| views::View* create_with_ai_button = |
| buble_view->GetViewByID(BubbleViewID::kCreateWithAiButton); |
| EXPECT_TRUE(create_with_ai_button->GetVisible()); |
| |
| content::WebContentsAddedObserver web_contents_added_observer; |
| |
| // Clicking on the Create with AI button should open VcBackgroundApp. |
| ClickButton(views::AsViewClass<views::Button>(create_with_ai_button)); |
| content::WebContents* new_contents = |
| web_contents_added_observer.GetWebContents(); |
| |
| EXPECT_EQ(GURL(vc_background_ui::kChromeUIVcBackgroundURL), |
| new_contents->GetVisibleURL()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| ClickingOnBackgroundBlurHidesSetCameraBackgroundView) { |
| if (is_guest_mode_) { |
| GTEST_SKIP() << "Skip for guest mode."; |
| } |
| |
| CreateAndApplyBackgroundImage(123u); |
| |
| // Trigger the VcTray with camera accessing. |
| TriggeringTray(/*use_camera=*/true, |
| /*use_microphone=*/false, |
| /*use_screen_sharing=*/false); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Wait until the VcBubble is visible. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| auto* buble_view = GetVcTray()->GetBubbleView(); |
| WAIT_FOR_CONDITION(buble_view->GetVisible()); |
| |
| // SetCameraBackgroundView should be visible. |
| auto* set_camera_background_view = |
| buble_view->GetViewByID(BubbleViewID::kSetCameraBackgroundView); |
| EXPECT_TRUE(set_camera_background_view->GetVisible()); |
| |
| auto* background_image_button = views::AsViewClass<views::Button>( |
| buble_view->GetViewByID(BubbleViewID::kBackgroundBlurImageButton)); |
| |
| // Constructing the image button is async, we need wait until that completes. |
| WAIT_FOR_CONDITION(buble_view->GetViewByID(BubbleViewID::kBackgroundImage0) != |
| nullptr); |
| auto* first_background_image = views::AsViewClass<views::Button>( |
| buble_view->GetViewByID(BubbleViewID::kBackgroundImage0)); |
| |
| for (int button_id : {BubbleViewID::kBackgroundBlurOffButton, |
| BubbleViewID::kBackgroundBlurLightButton, |
| BubbleViewID::kBackgroundBlurFullButton}) { |
| // Clicking on background blur button should turn off background replace. |
| auto* button = |
| views::AsViewClass<views::Button>(buble_view->GetViewByID(button_id)); |
| ClickButton(button); |
| |
| WAIT_FOR_CONDITION(!set_camera_background_view->GetVisible()); |
| EXPECT_FALSE( |
| camera_effects_controller()->GetCameraEffects()->replace_enabled); |
| |
| // Clicking image button should set SetCameraBackgroundView visible. |
| ClickButton(background_image_button); |
| WAIT_FOR_CONDITION(set_camera_background_view->GetVisible()); |
| EXPECT_FALSE( |
| camera_effects_controller()->GetCameraEffects()->replace_enabled); |
| |
| // Clicking on image button should apply that as background. |
| // Setting background replace is async, so we can't directly check the |
| // replace_enabled; but wait for that becomes true. |
| ClickButton(first_background_image); |
| WAIT_FOR_CONDITION( |
| camera_effects_controller()->GetCameraEffects()->replace_enabled); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| ClickingOnBackgroundImageAppliesBackgroundReplace) { |
| if (is_guest_mode_) { |
| GTEST_SKIP() << "Skip for guest mode."; |
| } |
| |
| const base::FilePath image1 = CreateAndApplyBackgroundImage(123u); |
| const base::FilePath image2 = CreateAndApplyBackgroundImage(456u); |
| |
| // Trigger the VcTray with camera accessing. |
| TriggeringTray(/*use_camera=*/true, |
| /*use_microphone=*/false, |
| /*use_screen_sharing=*/false); |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| |
| // Wait until the VcBubble is visible. |
| ClickButton(GetVcTray()->toggle_bubble_button()); |
| auto* buble_view = GetVcTray()->GetBubbleView(); |
| WAIT_FOR_CONDITION(buble_view->GetVisible()); |
| |
| // Currently image2 should be set as background. |
| EXPECT_EQ( |
| camera_effects_controller()->GetCameraEffects()->background_filepath, |
| image2); |
| |
| // Constructing the image button is async, we need wait until that completes. |
| WAIT_FOR_CONDITION(buble_view->GetViewByID(BubbleViewID::kBackgroundImage0) != |
| nullptr); |
| WAIT_FOR_CONDITION(buble_view->GetViewByID(BubbleViewID::kBackgroundImage1) != |
| nullptr); |
| |
| auto* first_background_image = views::AsViewClass<views::Button>( |
| buble_view->GetViewByID(BubbleViewID::kBackgroundImage0)); |
| auto* second_background_image = views::AsViewClass<views::Button>( |
| buble_view->GetViewByID(BubbleViewID::kBackgroundImage1)); |
| |
| // Clicking on the second image will set image1 as background. |
| ClickButton(second_background_image); |
| // Setting background replace is async, so we can't directly check the |
| // background_filepath; but wait for that becomes true. |
| WAIT_FOR_CONDITION( |
| camera_effects_controller()->GetCameraEffects()->background_filepath == |
| image1); |
| |
| // Clicking on the first image will set image2 as background. |
| // Setting background replace is async, so we can't directly check the |
| // background_filepath; but wait for that becomes true. |
| ClickButton(first_background_image); |
| WAIT_FOR_CONDITION( |
| camera_effects_controller()->GetCameraEffects()->background_filepath == |
| image2); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| TrayTriggeredByCaptureCamera) { |
| ASSERT_EQ(1u, ash::WaitForCameraAvailabilityWithTimeout(base::Seconds(5))); |
| ash::CaptureModeTestApi test_api; |
| test_api.SelectCameraAtIndex(0); |
| test_api.StartForFullscreen(/*for_video=*/true); |
| ASSERT_TRUE(test_api.IsSessionActive()); |
| |
| // VcTray should be triggered. |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(VideoConferenceIntegrationTest, |
| TrayTriggeredByCaptureMicrophone) { |
| ASSERT_EQ(1u, ash::WaitForCameraAvailabilityWithTimeout(base::Seconds(5))); |
| ash::CaptureModeTestApi test_api; |
| test_api.SetAudioRecordingMode(AudioRecordingMode::kMicrophone); |
| test_api.StartForFullscreen(/*for_video=*/true); |
| ASSERT_TRUE(test_api.IsSessionActive()); |
| test_api.PerformCapture(); |
| test_api.FlushRecordingServiceForTesting(); |
| EXPECT_TRUE(test_api.IsVideoRecordingInProgress()); |
| |
| // VcTray should be triggered. |
| WAIT_FOR_CONDITION(GetVcTray()->GetVisible()); |
| } |
| |
| } // namespace ash::video_conference |
