| // 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 "third_party/blink/renderer/modules/mediastream/capture_controller.h" |
| |
| #include <tuple> |
| |
| #include "base/run_loop.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/gmock_callback_support.h" |
| #include "base/unguessable_token.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/common/input/web_mouse_wheel_event.h" |
| #include "third_party/blink/public/mojom/mediastream/media_stream.mojom-blink.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_promise_tester.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_testing.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_dom_exception.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_wheel_event_init.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_captured_wheel_action.h" |
| #include "third_party/blink/renderer/core/dom/document.h" |
| #include "third_party/blink/renderer/core/dom/dom_exception.h" |
| #include "third_party/blink/renderer/core/dom/events/native_event_listener.h" |
| #include "third_party/blink/renderer/core/event_type_names.h" |
| #include "third_party/blink/renderer/core/events/wheel_event.h" |
| #include "third_party/blink/renderer/core/execution_context/execution_context.h" |
| #include "third_party/blink/renderer/core/html/html_div_element.h" |
| #include "third_party/blink/renderer/core/html/html_element.h" |
| #include "third_party/blink/renderer/core/testing/page_test_base.h" |
| #include "third_party/blink/renderer/modules/mediastream/browser_capture_media_stream_track.h" |
| #include "third_party/blink/renderer/modules/mediastream/media_stream_video_track.h" |
| #include "third_party/blink/renderer/modules/mediastream/mock_media_stream_video_source.h" |
| #include "third_party/blink/renderer/modules/mediastream/mock_mojo_media_stream_dispatcher_host.h" |
| #include "third_party/blink/renderer/platform/bindings/exception_state.h" |
| #include "third_party/blink/renderer/platform/mediastream/media_stream_component_impl.h" |
| #include "third_party/blink/renderer/platform/testing/io_task_runner_testing_platform_support.h" |
| #include "third_party/blink/renderer/platform/testing/task_environment.h" |
| #include "third_party/blink/renderer/platform/testing/testing_platform_support.h" |
| #include "ui/gfx/geometry/point.h" |
| #include "ui/gfx/geometry/size.h" |
| |
| namespace blink { |
| |
| namespace { |
| |
| using SurfaceType = ::media::mojom::DisplayCaptureSurfaceType; |
| |
| using ::base::test::RunOnceCallback; |
| using ::base::test::RunOnceCallbackRepeatedly; |
| using ::testing::_; |
| using ::testing::Combine; |
| using ::testing::DoAll; |
| using ::testing::Invoke; |
| using ::testing::Mock; |
| using ::testing::SaveArgPointee; |
| using ::testing::StrictMock; |
| using ::testing::Values; |
| using ::testing::WithParamInterface; |
| using CscResult = ::blink::mojom::blink::CapturedSurfaceControlResult; |
| |
| enum class ScrollDirection { |
| kNone, |
| kForwards, |
| kBackwards, |
| }; |
| |
| enum class TestedZoomControlAPI { kIncrease, kDecrease, kReset }; |
| |
| mojom::blink::ZoomLevelAction ToZoomLevelAction(TestedZoomControlAPI input) { |
| switch (input) { |
| case TestedZoomControlAPI::kIncrease: |
| return mojom::blink::ZoomLevelAction::kIncrease; |
| case TestedZoomControlAPI::kDecrease: |
| return mojom::blink::ZoomLevelAction::kDecrease; |
| case TestedZoomControlAPI::kReset: |
| return mojom::blink::ZoomLevelAction::kReset; |
| } |
| NOTREACHED() << "Not a ZoomLevelAction."; |
| } |
| |
| class MockEventListener : public NativeEventListener { |
| public: |
| MOCK_METHOD(void, Invoke, (ExecutionContext*, Event*)); |
| }; |
| |
| // TODO(crbug.com/1505223): Avoid this helper's duplication throughout Blink. |
| bool IsDOMException(ScriptState* script_state, |
| const ScriptValue& value, |
| DOMExceptionCode code) { |
| DOMException* const dom_exception = |
| V8DOMException::ToWrappable(script_state->GetIsolate(), value.V8Value()); |
| return dom_exception && dom_exception->name() == DOMException(code).name(); |
| } |
| |
| bool IsDOMException(V8TestingScope& v8_scope, |
| const ScriptValue& value, |
| DOMExceptionCode code) { |
| return IsDOMException(v8_scope.GetScriptState(), value, code); |
| } |
| |
| // Note that we don't actually care what the message is. We use this as a way |
| // to validate the tests themselves against false-positives through |
| // failures on different code paths that yield the same DOMException. |
| String GetDOMExceptionMessage(ScriptState* script_state, |
| const ScriptValue& value) { |
| DOMException* const dom_exception = |
| V8DOMException::ToWrappable(script_state->GetIsolate(), value.V8Value()); |
| CHECK(dom_exception) << "Malformed test."; |
| return dom_exception->message(); |
| } |
| String GetDOMExceptionMessage(V8TestingScope& v8_scope, |
| const ScriptValue& value) { |
| return GetDOMExceptionMessage(v8_scope.GetScriptState(), value); |
| } |
| |
| MediaStreamTrack* MakeTrack( |
| ExecutionContext* execution_context, |
| SurfaceType display_surface, |
| int initial_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[0], |
| bool use_session_id = true) { |
| std::unique_ptr<MockMediaStreamVideoSource> media_stream_video_source = |
| base::WrapUnique(new ::testing::NiceMock<MockMediaStreamVideoSource>( |
| media::VideoCaptureFormat(gfx::Size(640, 480), 30.0, |
| media::PIXEL_FORMAT_I420), |
| true)); |
| |
| // Set the reported SurfaceType. |
| MediaStreamDevice device = media_stream_video_source->device(); |
| device.display_media_info = media::mojom::DisplayMediaInformation::New( |
| display_surface, |
| /*logical_surface=*/true, media::mojom::CursorCaptureType::NEVER, |
| /*capture_handle=*/nullptr, initial_zoom_level); |
| if (use_session_id) { |
| device.set_session_id(base::UnguessableToken::Create()); |
| } |
| media_stream_video_source->SetDevice(device); |
| |
| auto media_stream_video_track = std::make_unique<MediaStreamVideoTrack>( |
| media_stream_video_source.get(), |
| WebPlatformMediaStreamSource::ConstraintsOnceCallback(), |
| /*enabled=*/true); |
| |
| MediaStreamSource* const source = MakeGarbageCollected<MediaStreamSource>( |
| "id", MediaStreamSource::StreamType::kTypeVideo, "name", |
| /*remote=*/false, std::move(media_stream_video_source)); |
| |
| MediaStreamComponent* const component = |
| MakeGarbageCollected<MediaStreamComponentImpl>( |
| "component_id", source, std::move(media_stream_video_track)); |
| |
| switch (display_surface) { |
| case SurfaceType::BROWSER: |
| return MakeGarbageCollected<BrowserCaptureMediaStreamTrack>( |
| execution_context, component, |
| /*callback=*/base::DoNothing()); |
| case SurfaceType::WINDOW: |
| case SurfaceType::MONITOR: |
| return MakeGarbageCollected<MediaStreamTrackImpl>( |
| execution_context, component, |
| /*callback=*/base::DoNothing()); |
| } |
| NOTREACHED(); |
| } |
| |
| MediaStreamTrack* MakeTrack( |
| V8TestingScope& testing_scope, |
| SurfaceType display_surface, |
| int initial_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[0], |
| bool use_session_id = true) { |
| return MakeTrack(testing_scope.GetExecutionContext(), display_surface, |
| initial_zoom_level, use_session_id); |
| } |
| |
| class CaptureControllerTestSupport { |
| protected: |
| virtual ~CaptureControllerTestSupport() = default; |
| |
| MockMojoMediaStreamDispatcherHost& DispatcherHost() { |
| return mock_dispatcher_host_; |
| } |
| |
| CaptureController* MakeController(ExecutionContext* execution_context) { |
| auto* controller = |
| MakeGarbageCollected<CaptureController>(execution_context); |
| controller->SetMediaStreamDispatcherHostForTesting( |
| mock_dispatcher_host_.CreatePendingRemoteAndBind()); |
| return controller; |
| } |
| |
| private: |
| MockMojoMediaStreamDispatcherHost mock_dispatcher_host_; |
| ScopedTestingPlatformSupport<IOTaskRunnerTestingPlatformSupport> platform_; |
| }; |
| |
| class CaptureControllerBaseTest : public testing::Test, |
| public CaptureControllerTestSupport { |
| public: |
| ~CaptureControllerBaseTest() override = default; |
| |
| private: |
| test::TaskEnvironment task_environment_; |
| }; |
| |
| // Test suite for CaptureController functionality from the Captured Surface |
| // Control spec, focusing on reading the supported zoom levels. |
| class CaptureControllerGetSupportedZoomLevelsTest |
| : public CaptureControllerBaseTest { |
| public: |
| ~CaptureControllerGetSupportedZoomLevelsTest() override = default; |
| }; |
| |
| TEST_F(CaptureControllerGetSupportedZoomLevelsTest, |
| ExceptionRaisedIfControllerUnbound) { |
| V8TestingScope v8_scope; |
| DummyExceptionStateForTesting& exception_state = v8_scope.GetExceptionState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| // Note that this test avoids calling CaptureController::SetIsBound(). |
| |
| EXPECT_EQ(controller->getSupportedZoomLevels(exception_state), Vector<int>()); |
| EXPECT_TRUE(exception_state.HadException()); |
| EXPECT_EQ(exception_state.CodeAs<DOMExceptionCode>(), |
| DOMExceptionCode::kInvalidStateError); |
| } |
| |
| TEST_F(CaptureControllerGetSupportedZoomLevelsTest, |
| ExceptionRaisedIfNoVideoTrack) { |
| V8TestingScope v8_scope; |
| DummyExceptionStateForTesting& exception_state = v8_scope.GetExceptionState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| // Note that this test avoids calling CaptureController::SetVideoTrack(). |
| |
| EXPECT_EQ(controller->getSupportedZoomLevels(exception_state), Vector<int>()); |
| EXPECT_TRUE(exception_state.HadException()); |
| EXPECT_EQ(exception_state.CodeAs<DOMExceptionCode>(), |
| DOMExceptionCode::kInvalidStateError); |
| } |
| |
| TEST_F(CaptureControllerGetSupportedZoomLevelsTest, |
| CallSucceedsIfActivelyCapturingTabAndResultIsValid) { |
| V8TestingScope v8_scope; |
| DummyExceptionStateForTesting& exception_state = v8_scope.GetExceptionState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER, |
| /*initial_zoom_level=*/100); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| // Call to getSupportedZoomLevels() succeeds. |
| const Vector<int> supported_levels = |
| controller->getSupportedZoomLevels(exception_state); |
| EXPECT_FALSE(exception_state.HadException()); |
| |
| // The result is monotonically increasing. |
| for (wtf_size_t i = 1; i < supported_levels.size(); ++i) { |
| EXPECT_LT(supported_levels[i - 1], supported_levels[i]); |
| } |
| |
| // The value `100` appears in the result. (It is the default zoom level.) |
| EXPECT_THAT(controller->getSupportedZoomLevels(exception_state), |
| testing::Contains(100)); |
| } |
| |
| TEST_F(CaptureControllerGetSupportedZoomLevelsTest, |
| ExceptionRaisedIfCapturingWindow) { |
| V8TestingScope v8_scope; |
| DummyExceptionStateForTesting& exception_state = v8_scope.GetExceptionState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::WINDOW, |
| /*initial_zoom_level=*/100); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_EQ(controller->getSupportedZoomLevels(exception_state), Vector<int>()); |
| EXPECT_TRUE(exception_state.HadException()); |
| EXPECT_EQ(exception_state.CodeAs<DOMExceptionCode>(), |
| DOMExceptionCode::kNotSupportedError); |
| } |
| |
| TEST_F(CaptureControllerGetSupportedZoomLevelsTest, |
| ExceptionRaisedIfCapturingScreen) { |
| V8TestingScope v8_scope; |
| DummyExceptionStateForTesting& exception_state = v8_scope.GetExceptionState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::MONITOR, |
| /*initial_zoom_level=*/100); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_EQ(controller->getSupportedZoomLevels(exception_state), Vector<int>()); |
| EXPECT_TRUE(exception_state.HadException()); |
| EXPECT_EQ(exception_state.CodeAs<DOMExceptionCode>(), |
| DOMExceptionCode::kNotSupportedError); |
| } |
| |
| TEST_F(CaptureControllerGetSupportedZoomLevelsTest, |
| ExceptionRaisedIfTrackedEnded) { |
| V8TestingScope v8_scope; |
| DummyExceptionStateForTesting& exception_state = v8_scope.GetExceptionState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER, |
| /*initial_zoom_level=*/100); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| // Everything up to here still allowed for getSupportedZoomLevels() |
| // to be called successfully. |
| EXPECT_NE(controller->getSupportedZoomLevels(exception_state), Vector<int>()); |
| EXPECT_FALSE(exception_state.HadException()); |
| |
| // Ending the track cuts off access to getSupportedZoomLevels(). |
| track->stopTrack(v8_scope.GetExecutionContext()); // Ends the track. |
| |
| EXPECT_EQ(controller->getSupportedZoomLevels(exception_state), Vector<int>()); |
| EXPECT_TRUE(exception_state.HadException()); |
| EXPECT_EQ(exception_state.CodeAs<DOMExceptionCode>(), |
| DOMExceptionCode::kInvalidStateError); |
| } |
| |
| // Test suite for CaptureController functionality from the |
| // Captured Surface Control spec, focusing on the zoomLevel attribute. |
| class CaptureControllerZoomLevelAttributeTest |
| : public CaptureControllerBaseTest { |
| public: |
| ~CaptureControllerZoomLevelAttributeTest() override = default; |
| }; |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, |
| NoValueIfCaptureControllerNotBound) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| // Test avoids calling CaptureController::SetIsBound(). |
| |
| EXPECT_EQ(controller->zoomLevel(), std::nullopt); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, |
| NoValueIfCaptureControllerBoundButNoVideoTrack) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| // Test avoids calling CaptureController::SetVideoTrack(). |
| |
| EXPECT_EQ(controller->zoomLevel(), std::nullopt); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, |
| CorrectlyReportsInitialZoomLevel) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::BROWSER, |
| /*initial_zoom_level=*/ |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_EQ(controller->zoomLevel(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, CorrectlyUpdatesValue) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::BROWSER, |
| /*initial_zoom_level=*/ |
| CaptureController::getSupportedZoomLevelsForTabs()[0]); |
| controller->SetVideoTrack(track, "descriptor"); |
| ASSERT_EQ(controller->zoomLevel(), |
| CaptureController::getSupportedZoomLevelsForTabs()[0]); |
| |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| |
| EXPECT_EQ(controller->zoomLevel(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| // Note that the setup differs from that of CorrectlyReportsInitialZoomLevel |
| // only in the SurfaceType provided to MakeTrack(). |
| TEST_F(CaptureControllerZoomLevelAttributeTest, NoValueIfCapturingWindow) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::WINDOW, |
| /*initial_zoom_level=*/ |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_EQ(controller->zoomLevel(), std::nullopt); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| // Note that the setup differs from that of CorrectlyReportsInitialZoomLevel |
| // only in the SurfaceType provided to MakeTrack(). |
| TEST_F(CaptureControllerZoomLevelAttributeTest, NoValueIfCapturingMonitor) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::MONITOR, |
| /*initial_zoom_level=*/ |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_EQ(controller->zoomLevel(), std::nullopt); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, |
| ReportOldValueIfVideoTrackEndedWithoutUpdate) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| const int initial_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[1]; |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::BROWSER, initial_zoom_level); |
| controller->SetVideoTrack(track, "descriptor"); |
| ASSERT_EQ(controller->zoomLevel(), initial_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| |
| track->stopTrack(v8_scope.GetExecutionContext()); // Ends the track. |
| |
| EXPECT_EQ(controller->zoomLevel(), initial_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, |
| ReportOldValueIfVideoTrackEndedWithUpdate) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| const int initial_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[1]; |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::BROWSER, initial_zoom_level); |
| controller->SetVideoTrack(track, "descriptor"); |
| ASSERT_EQ(controller->zoomLevel(), initial_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| |
| const int new_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[2]; |
| ASSERT_NE(new_zoom_level, initial_zoom_level); |
| |
| track->Component()->Source()->OnZoomLevelChange(MediaStreamDevice(), |
| new_zoom_level); |
| ASSERT_EQ(controller->zoomLevel(), new_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| |
| track->stopTrack(v8_scope.GetExecutionContext()); // Ends the track. |
| |
| EXPECT_EQ(controller->zoomLevel(), new_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| TEST_F(CaptureControllerZoomLevelAttributeTest, |
| ZoomLevelUpdatesAfterTrackEndedGracefullyIgnored) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| const int original_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[1]; |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::BROWSER, original_zoom_level); |
| controller->SetVideoTrack(track, "descriptor"); |
| ASSERT_EQ(controller->zoomLevel(), original_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| |
| const int new_zoom_level = |
| CaptureController::getSupportedZoomLevelsForTabs()[2]; |
| ASSERT_NE(new_zoom_level, original_zoom_level); |
| |
| track->stopTrack(v8_scope.GetExecutionContext()); // Ends the track. |
| |
| // Should not really happen; nullified. |
| track->Component()->Source()->OnZoomLevelChange(MediaStreamDevice(), |
| new_zoom_level); |
| ASSERT_EQ(controller->zoomLevel(), original_zoom_level); |
| ASSERT_FALSE(v8_scope.GetExceptionState().HadException()); |
| } |
| |
| // Test suite for CaptureController functionality from the Captured Surface |
| // Control spec, focusing on OnCapturedZoomLevelChange events. |
| class CaptureControllerOnCapturedZoomLevelChangeTest |
| : public CaptureControllerBaseTest { |
| public: |
| ~CaptureControllerOnCapturedZoomLevelChangeTest() override = default; |
| }; |
| |
| TEST_F(CaptureControllerOnCapturedZoomLevelChangeTest, NoEventOnInit) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| |
| StrictMock<MockEventListener>* event_listener = |
| MakeGarbageCollected<StrictMock<MockEventListener>>(); |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(0); |
| controller->addEventListener(event_type_names::kZoomlevelchange, |
| event_listener); |
| |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| } |
| |
| TEST_F(CaptureControllerOnCapturedZoomLevelChangeTest, |
| EventWhenDifferentFromInitValue) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| StrictMock<MockEventListener>* event_listener = |
| MakeGarbageCollected<StrictMock<MockEventListener>>(); |
| controller->addEventListener(event_type_names::kZoomlevelchange, |
| event_listener); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(1); |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| } |
| |
| TEST_F(CaptureControllerOnCapturedZoomLevelChangeTest, |
| NoEventWhenSameAsInitValue) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| StrictMock<MockEventListener>* event_listener = |
| MakeGarbageCollected<StrictMock<MockEventListener>>(); |
| controller->addEventListener(event_type_names::kZoomlevelchange, |
| event_listener); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(0); |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[0]); |
| } |
| |
| TEST_F(CaptureControllerOnCapturedZoomLevelChangeTest, |
| EventWhenDifferentFromPreviousUpdate) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| StrictMock<MockEventListener>* event_listener = |
| MakeGarbageCollected<StrictMock<MockEventListener>>(); |
| controller->addEventListener(event_type_names::kZoomlevelchange, |
| event_listener); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(1); |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| Mock::VerifyAndClearExpectations(event_listener); |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(1); |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[0]); |
| } |
| |
| TEST_F(CaptureControllerOnCapturedZoomLevelChangeTest, |
| EventWhenSameAsPreviousUpdate) { |
| V8TestingScope v8_scope; |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| StrictMock<MockEventListener>* event_listener = |
| MakeGarbageCollected<StrictMock<MockEventListener>>(); |
| controller->addEventListener(event_type_names::kZoomlevelchange, |
| event_listener); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(1); |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| Mock::VerifyAndClearExpectations(event_listener); |
| EXPECT_CALL(*event_listener, Invoke(_, _)).Times(0); |
| track->Component()->Source()->OnZoomLevelChange( |
| MediaStreamDevice(), |
| CaptureController::getSupportedZoomLevelsForTabs()[1]); |
| } |
| |
| class CaptureControllerUpdateZoomLevelTest |
| : public CaptureControllerBaseTest, |
| public WithParamInterface<TestedZoomControlAPI> { |
| public: |
| CaptureControllerUpdateZoomLevelTest() : tested_action_(GetParam()) {} |
| ~CaptureControllerUpdateZoomLevelTest() override = default; |
| |
| ScriptPromise<IDLUndefined> CallTestedAPI(ScriptState* script_state, |
| CaptureController* controller) { |
| switch (tested_action_) { |
| case TestedZoomControlAPI::kIncrease: |
| return controller->increaseZoomLevel(script_state); |
| case TestedZoomControlAPI::kDecrease: |
| return controller->decreaseZoomLevel(script_state); |
| case TestedZoomControlAPI::kReset: |
| return controller->resetZoomLevel(script_state); |
| } |
| NOTREACHED(); |
| } |
| |
| protected: |
| const TestedZoomControlAPI tested_action_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(, |
| CaptureControllerUpdateZoomLevelTest, |
| Values(TestedZoomControlAPI::kIncrease, |
| TestedZoomControlAPI::kDecrease, |
| TestedZoomControlAPI::kReset)); |
| |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| UpdateZoomLevelFailsIfCaptureControllerNotBound) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| // Test avoids calling CaptureController::SetIsBound(). |
| |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kInvalidStateError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "getDisplayMedia() not called yet."); |
| } |
| |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| UpdateZoomLevelFailsIfCaptureControllerBoundButNoVideoTrack) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| // Test avoids calling CaptureController::SetVideoTrack(). |
| |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kInvalidStateError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "Capture-session not started."); |
| } |
| |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| UpdateZoomLevelFailsIfVideoTrackEnded) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| track->stopTrack(v8_scope.GetExecutionContext()); // Ends the track. |
| |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kInvalidStateError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "Video track ended."); |
| } |
| |
| TEST_P(CaptureControllerUpdateZoomLevelTest, UpdateZoomLevelSuccess) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_CALL(DispatcherHost(), |
| UpdateZoomLevel(_, ToZoomLevelAction(tested_action_), _)) |
| .WillOnce(RunOnceCallback<2>(CscResult::kSuccess)); |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsFulfilled()); |
| } |
| |
| // Note that the setup differs from that of UpdateZoomLevelSuccess only in the |
| // SurfaceType provided to MakeTrack(). |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| UpdateZoomLevelFailsIfCapturingWindow) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::WINDOW); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kNotSupportedError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "Action only supported for tab-capture."); |
| } |
| |
| // Note that the setup differs from that of UpdateZoomLevelSuccess only in the |
| // SurfaceType provided to MakeTrack(). |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| UpdateZoomLevelFailsIfCapturingMonitor) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::MONITOR); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kNotSupportedError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "Action only supported for tab-capture."); |
| } |
| |
| // Note that the setup differs from that of UpdateZoomLevelSuccess only in the |
| // simulated result from the browser process. |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| SimulatedFailureFromDispatcherHost) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = MakeTrack(v8_scope, SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| EXPECT_CALL(DispatcherHost(), UpdateZoomLevel(_, _, _)) |
| .WillOnce(RunOnceCallback<2>(CscResult::kUnknownError)); |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kUnknownError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "Unknown error."); |
| } |
| |
| TEST_P(CaptureControllerUpdateZoomLevelTest, |
| UpdateZoomLevelFailsWithoutSessionId) { |
| V8TestingScope v8_scope; |
| ScriptState* const script_state = v8_scope.GetScriptState(); |
| |
| CaptureController* controller = |
| MakeController(v8_scope.GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(v8_scope, SurfaceType::BROWSER, |
| CaptureController::getSupportedZoomLevelsForTabs()[0], |
| /*use_session_id=*/false); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| const ScriptPromise<IDLUndefined> promise = |
| CallTestedAPI(script_state, controller); |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(v8_scope, promise_tester.Value(), |
| DOMExceptionCode::kUnknownError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(v8_scope, promise_tester.Value()), |
| "Invalid capture"); |
| } |
| |
| class CaptureControllerForwardWheelTest : public PageTestBase, |
| public CaptureControllerTestSupport { |
| public: |
| ~CaptureControllerForwardWheelTest() override = default; |
| }; |
| |
| TEST_F(CaptureControllerForwardWheelTest, Success) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| EXPECT_CALL(DispatcherHost(), RequestCapturedSurfaceControlPermission(_, _)) |
| .WillOnce(RunOnceCallback<1>(CscResult::kSuccess)); |
| auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsFulfilled()); |
| |
| base::RunLoop run_loop; |
| EXPECT_CALL(DispatcherHost(), SendWheel(_, _)) |
| .WillOnce(Invoke(&run_loop, &base::RunLoop::Quit)); |
| element->DispatchEvent( |
| *WheelEvent::Create(event_type_names::kWheel, WheelEventInit::Create())); |
| run_loop.Run(); |
| |
| promise = controller->forwardWheel(script_state, nullptr); |
| ScriptPromiseTester promise_tester2(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsFulfilled()); |
| |
| auto* mock_listener = MakeGarbageCollected<MockEventListener>(); |
| element->addEventListener(event_type_names::kWheel, mock_listener); |
| base::RunLoop run_loop2; |
| EXPECT_CALL(DispatcherHost(), SendWheel(_, _)).Times(0); |
| EXPECT_CALL(*mock_listener, Invoke) |
| .WillOnce(Invoke(&run_loop2, &base::RunLoop::Quit)); |
| element->DispatchEvent( |
| *WheelEvent::Create(event_type_names::kWheel, WheelEventInit::Create())); |
| run_loop2.Run(); |
| } |
| |
| TEST_F(CaptureControllerForwardWheelTest, DropUntrustedEvent) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| EXPECT_CALL(DispatcherHost(), RequestCapturedSurfaceControlPermission(_, _)) |
| .WillOnce(RunOnceCallback<1>(CscResult::kSuccess)); |
| ScriptPromiseTester(script_state, |
| controller->forwardWheel(script_state, element)) |
| .WaitUntilSettled(); |
| |
| EXPECT_CALL(DispatcherHost(), SendWheel(_, _)).Times(0); |
| DummyExceptionStateForTesting exception_state; |
| // Events dispatched with dispatchEventForBindings are always untrusted. |
| element->dispatchEventForBindings( |
| WheelEvent::Create(event_type_names::kWheel, WheelEventInit::Create()), |
| exception_state); |
| |
| task_environment().RunUntilIdle(); |
| } |
| |
| TEST_F(CaptureControllerForwardWheelTest, SuccessWithNoElement) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| ScriptState::Scope scope(script_state); |
| |
| EXPECT_CALL(DispatcherHost(), RequestCapturedSurfaceControlPermission(_, _)) |
| .Times(0); |
| auto promise = controller->forwardWheel(script_state, nullptr); |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsFulfilled()); |
| } |
| |
| TEST_F(CaptureControllerForwardWheelTest, NoSessionId) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER, |
| /*initial_zoom_level=*/100, /*use_session_id=*/false); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(script_state, promise_tester.Value(), |
| DOMExceptionCode::kInvalidStateError)); |
| EXPECT_EQ(GetDOMExceptionMessage(script_state, promise_tester.Value()), |
| "Invalid capture."); |
| } |
| |
| TEST_F(CaptureControllerForwardWheelTest, NoTrack) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER, |
| /*initial_zoom_level=*/100, /*use_session_id=*/false); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(script_state, promise_tester.Value(), |
| DOMExceptionCode::kInvalidStateError)); |
| EXPECT_EQ(GetDOMExceptionMessage(script_state, promise_tester.Value()), |
| "Invalid capture."); |
| } |
| |
| TEST_F(CaptureControllerForwardWheelTest, StoppedTrack) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER, |
| /*initial_zoom_level=*/100, /*use_session_id=*/false); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| track->stopTrack(GetDocument().GetExecutionContext()); |
| auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(script_state, promise_tester.Value(), |
| DOMExceptionCode::kInvalidStateError)); |
| EXPECT_EQ(GetDOMExceptionMessage(script_state, promise_tester.Value()), |
| "Invalid capture."); |
| } |
| |
| class CaptureControllerForwardWheelBackendErrorTest |
| : public CaptureControllerForwardWheelTest, |
| public WithParamInterface<CscResult> { |
| public: |
| CaptureControllerForwardWheelBackendErrorTest() : error_(GetParam()) {} |
| ~CaptureControllerForwardWheelBackendErrorTest() override = default; |
| |
| protected: |
| const CscResult error_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(, |
| CaptureControllerForwardWheelBackendErrorTest, |
| Values(CscResult::kUnknownError, |
| CscResult::kNoPermissionError, |
| CscResult::kCapturerNotFoundError, |
| CscResult::kCapturedSurfaceNotFoundError, |
| CscResult::kDisallowedForSelfCaptureError, |
| CscResult::kCapturerNotFocusedError)); |
| |
| TEST_P(CaptureControllerForwardWheelBackendErrorTest, Test) { |
| ExecutionContext* execution_context = GetDocument().GetExecutionContext(); |
| CaptureController* controller = MakeController(execution_context); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| EXPECT_CALL(DispatcherHost(), SendWheel(_, _)).Times(0); |
| |
| ScriptState::Scope scope(script_state); |
| EXPECT_CALL(DispatcherHost(), RequestCapturedSurfaceControlPermission(_, _)) |
| .WillOnce(RunOnceCallback<1>(error_)); |
| const auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| |
| auto* mock_listener = MakeGarbageCollected<MockEventListener>(); |
| element->addEventListener(event_type_names::kWheel, mock_listener); |
| base::RunLoop run_loop; |
| |
| EXPECT_CALL(*mock_listener, Invoke) |
| .WillRepeatedly(Invoke(&run_loop, &base::RunLoop::Quit)); |
| element->DispatchEvent( |
| *WheelEvent::Create(event_type_names::kWheel, WheelEventInit::Create())); |
| run_loop.Run(); |
| } |
| |
| class CaptureControllerForwardWheelUnsupportedSurfacesTest |
| : public CaptureControllerForwardWheelTest, |
| public WithParamInterface<SurfaceType> { |
| public: |
| CaptureControllerForwardWheelUnsupportedSurfacesTest() |
| : surface_type_(GetParam()) {} |
| ~CaptureControllerForwardWheelUnsupportedSurfacesTest() override = default; |
| |
| protected: |
| const SurfaceType surface_type_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(, |
| CaptureControllerForwardWheelUnsupportedSurfacesTest, |
| Values(SurfaceType::WINDOW, SurfaceType::MONITOR)); |
| |
| TEST_P(CaptureControllerForwardWheelUnsupportedSurfacesTest, Fails) { |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), surface_type_); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLDivElement* element = MakeGarbageCollected<HTMLDivElement>(GetDocument()); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| ON_CALL(DispatcherHost(), RequestCapturedSurfaceControlPermission(_, _)) |
| .WillByDefault(RunOnceCallback<1>(CscResult::kSuccess)); |
| auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsRejected()); |
| EXPECT_TRUE(IsDOMException(script_state, promise_tester.Value(), |
| DOMExceptionCode::kNotSupportedError)); |
| |
| // Avoid false-positives through different error paths terminating in |
| // exception with the same code. |
| EXPECT_EQ(GetDOMExceptionMessage(script_state, promise_tester.Value()), |
| "Action only supported for tab-capture."); |
| } |
| |
| // Test the validation of forwarded wheel parameters. |
| using ScrollTestParams = |
| std::tuple<gfx::Point, gfx::Point, ScrollDirection, ScrollDirection>; |
| class CaptureControllerScrollParametersValidationTest |
| : public PageTestBase, |
| public CaptureControllerTestSupport, |
| public WithParamInterface<ScrollTestParams> { |
| public: |
| static constexpr int kDivWidth = 100; |
| static constexpr int kDivHeight = 200; |
| |
| static constexpr gfx::Point kDivAtOrigin = gfx::Point(0, 0); |
| static constexpr gfx::Point kDivAtOffset = gfx::Point(40, 80); |
| |
| static constexpr gfx::Point kTopLeft = gfx::Point(0, 0); |
| static constexpr gfx::Point kTopRight = gfx::Point(kDivWidth - 1, 0); |
| static constexpr gfx::Point kBottomLeft = gfx::Point(0, kDivHeight - 1); |
| static constexpr gfx::Point kBottomRight = |
| gfx::Point(kDivWidth - 1, kDivHeight - 1); |
| static constexpr gfx::Point kCenter = |
| gfx::Point((kDivWidth - 1) / 2, (kDivHeight - 1) / 2); |
| |
| CaptureControllerScrollParametersValidationTest() |
| : div_origin_(std::get<0>(GetParam())), |
| gesture_coordinates_(std::get<1>(GetParam())), |
| horizontal_scroll_direction_(std::get<2>(GetParam())), |
| vertical_scroll_direction_(std::get<3>(GetParam())) {} |
| ~CaptureControllerScrollParametersValidationTest() override = default; |
| |
| static std::string DescribeParams( |
| const testing::TestParamInfo<ScrollTestParams>& info) { |
| std::string result; |
| |
| // div_origin |
| for (const auto& named_param : |
| {std::make_pair(kDivAtOrigin, "DivAtOrigin"), |
| std::make_pair(kDivAtOffset, "DivAtOffset")}) { |
| if (std::get<0>(info.param) == named_param.first) { |
| result += named_param.second; |
| break; |
| } |
| } |
| |
| // gesture_coordinates |
| for (const auto& named_param : {std::make_pair(kTopLeft, "TopLeft"), |
| std::make_pair(kTopRight, "TopRight"), |
| std::make_pair(kBottomLeft, "BottomLeft"), |
| std::make_pair(kBottomRight, "BottomRight"), |
| std::make_pair(kCenter, "Center")}) { |
| if (std::get<1>(info.param) == named_param.first) { |
| result += std::string("GestureAt") + named_param.second; |
| break; |
| } |
| } |
| |
| // horizontal_scroll_direction |
| for (const auto& named_param : |
| {std::make_pair(ScrollDirection::kNone, "None"), |
| std::make_pair(ScrollDirection::kForwards, "Forwards"), |
| std::make_pair(ScrollDirection::kBackwards, "Backwards")}) { |
| if (std::get<2>(info.param) == named_param.first) { |
| result += std::string("HorizontalScroll") + named_param.second; |
| break; |
| } |
| } |
| |
| // vertical_scroll_direction |
| for (const auto& named_param : |
| {std::make_pair(ScrollDirection::kNone, "None"), |
| std::make_pair(ScrollDirection::kForwards, "Forwards"), |
| std::make_pair(ScrollDirection::kBackwards, "Backwards")}) { |
| if (std::get<3>(info.param) == named_param.first) { |
| result += std::string("VerticalScroll") + named_param.second; |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| protected: |
| gfx::Point div_origin() const { return div_origin_; } |
| |
| gfx::Point gesture_coordinates() const { return gesture_coordinates_; } |
| |
| int wheel_deltax_x() const { |
| return GetScrollValue(horizontal_scroll_direction_); |
| } |
| |
| int wheel_deltax_y() const { |
| return GetScrollValue(vertical_scroll_direction_); |
| } |
| |
| private: |
| static int GetScrollValue(ScrollDirection direction) { |
| switch (direction) { |
| case ScrollDirection::kNone: |
| return 0; |
| case ScrollDirection::kForwards: |
| return 10; |
| case ScrollDirection::kBackwards: |
| return -10; |
| } |
| } |
| |
| const gfx::Point div_origin_; |
| const gfx::Point gesture_coordinates_; |
| const ScrollDirection horizontal_scroll_direction_; |
| const ScrollDirection vertical_scroll_direction_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| , |
| CaptureControllerScrollParametersValidationTest, |
| Combine( |
| // div_origin_ |
| Values(CaptureControllerScrollParametersValidationTest::kDivAtOrigin, |
| CaptureControllerScrollParametersValidationTest::kDivAtOffset), |
| // gesture_coordinates_ |
| Values(CaptureControllerScrollParametersValidationTest::kTopLeft, |
| CaptureControllerScrollParametersValidationTest::kTopRight, |
| CaptureControllerScrollParametersValidationTest::kBottomLeft, |
| CaptureControllerScrollParametersValidationTest::kBottomRight, |
| CaptureControllerScrollParametersValidationTest::kCenter), |
| // horizontal_scroll_direction_ |
| Values(ScrollDirection::kNone, |
| ScrollDirection::kForwards, |
| ScrollDirection::kBackwards), |
| // vertical_scroll_direction_ |
| Values(ScrollDirection::kNone, |
| ScrollDirection::kForwards, |
| ScrollDirection::kBackwards)), |
| CaptureControllerScrollParametersValidationTest::DescribeParams); |
| |
| TEST_P(CaptureControllerScrollParametersValidationTest, ValidateCoordinates) { |
| SetHtmlInnerHTML(base::StringPrintf( |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="div" |
| style="position: absolute; left: %d; top: %d; |
| width: %dpx; height: %dpx;" /> |
| </body> |
| )HTML", |
| div_origin().x(), div_origin().x(), kDivWidth, kDivHeight)); |
| |
| CaptureController* controller = |
| MakeController(GetDocument().GetExecutionContext()); |
| controller->SetIsBound(true); |
| MediaStreamTrack* track = |
| MakeTrack(GetDocument().GetExecutionContext(), SurfaceType::BROWSER); |
| controller->SetVideoTrack(track, "descriptor"); |
| |
| HTMLElement* const element = reinterpret_cast<HTMLElement*>( |
| GetDocument().getElementById(AtomicString("div"))); |
| ScriptState* script_state = ToScriptStateForMainWorld(&GetFrame()); |
| |
| ScriptState::Scope scope(script_state); |
| EXPECT_CALL(DispatcherHost(), RequestCapturedSurfaceControlPermission(_, _)) |
| .WillOnce(RunOnceCallback<1>(CscResult::kSuccess)); |
| auto promise = controller->forwardWheel(script_state, element); |
| |
| ScriptPromiseTester promise_tester(script_state, promise); |
| promise_tester.WaitUntilSettled(); |
| EXPECT_TRUE(promise_tester.IsFulfilled()); |
| |
| mojom::blink::CapturedWheelAction dispatcher_action; |
| base::RunLoop run_loop; |
| EXPECT_CALL(DispatcherHost(), SendWheel(_, _)) |
| .WillOnce(DoAll(SaveArgPointee<1>(&dispatcher_action), |
| Invoke(&run_loop, &base::RunLoop::Quit))); |
| |
| // Deliver the wheel event. |
| WheelEventInit* const init = WheelEventInit::Create(); |
| init->setClientX(gesture_coordinates().x()); |
| init->setClientY(gesture_coordinates().y()); |
| init->setDeltaX(wheel_deltax_x()); |
| init->setDeltaY(wheel_deltax_y()); |
| WheelEvent* const wheel_event = |
| WheelEvent::Create(event_type_names::kWheel, init); |
| |
| element->DispatchEvent(*wheel_event); |
| run_loop.Run(); |
| |
| EXPECT_EQ(dispatcher_action.relative_x, |
| 1.0 * gesture_coordinates().x() / kDivWidth); |
| EXPECT_EQ(dispatcher_action.relative_y, |
| 1.0 * gesture_coordinates().y() / kDivHeight); |
| EXPECT_EQ(dispatcher_action.wheel_delta_x, -wheel_deltax_x()); |
| EXPECT_EQ(dispatcher_action.wheel_delta_y, -wheel_deltax_y()); |
| } |
| |
| } // namespace |
| } // namespace blink |
