| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/test_runner/mock_web_user_media_client.h" |
| |
| #include <stddef.h> |
| |
| #include "base/logging.h" |
| #include "base/macros.h" |
| #include "components/test_runner/web_test_delegate.h" |
| #include "third_party/WebKit/public/platform/WebMediaConstraints.h" |
| #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h" |
| #include "third_party/WebKit/public/platform/WebMediaStream.h" |
| #include "third_party/WebKit/public/platform/WebMediaStreamSource.h" |
| #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" |
| #include "third_party/WebKit/public/platform/WebMediaStreamTrackSourcesRequest.h" |
| #include "third_party/WebKit/public/platform/WebSourceInfo.h" |
| #include "third_party/WebKit/public/platform/WebVector.h" |
| #include "third_party/WebKit/public/web/WebDocument.h" |
| #include "third_party/WebKit/public/web/WebMediaDevicesRequest.h" |
| #include "third_party/WebKit/public/web/WebUserMediaRequest.h" |
| |
| using blink::WebMediaConstraints; |
| using blink::WebMediaDeviceInfo; |
| using blink::WebMediaDevicesRequest; |
| using blink::WebMediaStream; |
| using blink::WebMediaStreamSource; |
| using blink::WebMediaStreamTrack; |
| using blink::WebMediaStreamTrackSourcesRequest; |
| using blink::WebSourceInfo; |
| using blink::WebString; |
| using blink::WebUserMediaRequest; |
| using blink::WebVector; |
| |
| namespace test_runner { |
| |
| class UserMediaRequestTask : public WebMethodTask<MockWebUserMediaClient> { |
| public: |
| UserMediaRequestTask(MockWebUserMediaClient* object, |
| const WebUserMediaRequest& request, |
| const WebMediaStream result) |
| : WebMethodTask<MockWebUserMediaClient>(object), |
| request_(request), |
| result_(result) { |
| DCHECK(!result_.isNull()); |
| } |
| |
| void RunIfValid() override { request_.requestSucceeded(result_); } |
| |
| private: |
| WebUserMediaRequest request_; |
| WebMediaStream result_; |
| |
| DISALLOW_COPY_AND_ASSIGN(UserMediaRequestTask); |
| }; |
| |
| class UserMediaRequestConstraintFailedTask |
| : public WebMethodTask<MockWebUserMediaClient> { |
| public: |
| UserMediaRequestConstraintFailedTask(MockWebUserMediaClient* object, |
| const WebUserMediaRequest& request, |
| const WebString& constraint) |
| : WebMethodTask<MockWebUserMediaClient>(object), |
| request_(request), |
| constraint_(constraint) {} |
| |
| void RunIfValid() override { request_.requestFailedConstraint(constraint_); } |
| |
| private: |
| WebUserMediaRequest request_; |
| WebString constraint_; |
| |
| DISALLOW_COPY_AND_ASSIGN(UserMediaRequestConstraintFailedTask); |
| }; |
| |
| class UserMediaRequestPermissionDeniedTask |
| : public WebMethodTask<MockWebUserMediaClient> { |
| public: |
| UserMediaRequestPermissionDeniedTask(MockWebUserMediaClient* object, |
| const WebUserMediaRequest& request) |
| : WebMethodTask<MockWebUserMediaClient>(object), |
| request_(request) {} |
| |
| void RunIfValid() override { request_.requestFailed(); } |
| |
| private: |
| WebUserMediaRequest request_; |
| |
| DISALLOW_COPY_AND_ASSIGN(UserMediaRequestPermissionDeniedTask); |
| }; |
| |
| class MediaDevicesRequestTask : public WebMethodTask<MockWebUserMediaClient> { |
| public: |
| MediaDevicesRequestTask(MockWebUserMediaClient* object, |
| const WebMediaDevicesRequest& request, |
| const WebVector<WebMediaDeviceInfo>& result) |
| : WebMethodTask<MockWebUserMediaClient>(object), |
| request_(request), |
| result_(result) {} |
| |
| void RunIfValid() override { request_.requestSucceeded(result_); } |
| |
| private: |
| WebMediaDevicesRequest request_; |
| WebVector<WebMediaDeviceInfo> result_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MediaDevicesRequestTask); |
| }; |
| |
| class SourcesRequestTask : public WebMethodTask<MockWebUserMediaClient> { |
| public: |
| SourcesRequestTask(MockWebUserMediaClient* object, |
| const WebMediaStreamTrackSourcesRequest& request, |
| const WebVector<WebSourceInfo>& result) |
| : WebMethodTask<MockWebUserMediaClient>(object), |
| request_(request), |
| result_(result) {} |
| |
| void RunIfValid() override { request_.requestSucceeded(result_); } |
| |
| private: |
| WebMediaStreamTrackSourcesRequest request_; |
| WebVector<WebSourceInfo> result_; |
| |
| DISALLOW_COPY_AND_ASSIGN(SourcesRequestTask); |
| }; |
| |
| class MockExtraData : public WebMediaStream::ExtraData { |
| public: |
| int foo; |
| }; |
| |
| MockWebUserMediaClient::MockWebUserMediaClient(WebTestDelegate* delegate) |
| : delegate_(delegate) {} |
| |
| void MockWebUserMediaClient::requestUserMedia( |
| const WebUserMediaRequest& stream_request) { |
| DCHECK(!stream_request.isNull()); |
| WebUserMediaRequest request = stream_request; |
| |
| if (request.ownerDocument().isNull() || !request.ownerDocument().frame()) { |
| delegate_->PostTask( |
| new UserMediaRequestPermissionDeniedTask(this, request)); |
| return; |
| } |
| |
| WebMediaStream stream; |
| stream.initialize(WebVector<WebMediaStreamTrack>(), |
| WebVector<WebMediaStreamTrack>()); |
| stream.setExtraData(new MockExtraData()); |
| |
| if (request.audio() && |
| !delegate_->AddMediaStreamAudioSourceAndTrack(&stream)) { |
| WebMediaStreamSource source; |
| source.initialize("MockAudioDevice#1", |
| WebMediaStreamSource::TypeAudio, |
| "Mock audio device", |
| false /* remote */, |
| true /* readonly */); |
| WebMediaStreamTrack web_track; |
| web_track.initialize(source); |
| stream.addTrack(web_track); |
| } |
| |
| if (request.video() && |
| !delegate_->AddMediaStreamVideoSourceAndTrack(&stream)) { |
| WebMediaStreamSource source; |
| source.initialize("MockVideoDevice#1", |
| WebMediaStreamSource::TypeVideo, |
| "Mock video device", |
| false /* remote */, true /* readonly */); |
| WebMediaStreamTrack web_track; |
| web_track.initialize(source); |
| stream.addTrack(web_track); |
| } |
| |
| delegate_->PostTask(new UserMediaRequestTask(this, request, stream)); |
| } |
| |
| void MockWebUserMediaClient::cancelUserMediaRequest( |
| const WebUserMediaRequest&) { |
| } |
| |
| void MockWebUserMediaClient::requestMediaDevices( |
| const WebMediaDevicesRequest& request) { |
| struct { |
| const char* device_id; |
| WebMediaDeviceInfo::MediaDeviceKind kind; |
| const char* label; |
| const char* group_id; |
| } test_devices[] = { |
| { |
| "device1", |
| WebMediaDeviceInfo::MediaDeviceKindAudioInput, |
| "Built-in microphone", |
| "group1", |
| }, |
| { |
| "device2", |
| WebMediaDeviceInfo::MediaDeviceKindAudioOutput, |
| "Built-in speakers", |
| "group1", |
| }, |
| { |
| "device3", |
| WebMediaDeviceInfo::MediaDeviceKindVideoInput, |
| "Build-in webcam", |
| "group2", |
| }, |
| }; |
| |
| WebVector<WebMediaDeviceInfo> devices(arraysize(test_devices)); |
| for (size_t i = 0; i < arraysize(test_devices); ++i) { |
| devices[i].initialize(WebString::fromUTF8(test_devices[i].device_id), |
| test_devices[i].kind, |
| WebString::fromUTF8(test_devices[i].label), |
| WebString::fromUTF8(test_devices[i].group_id)); |
| } |
| |
| delegate_->PostTask(new MediaDevicesRequestTask(this, request, devices)); |
| } |
| |
| void MockWebUserMediaClient::cancelMediaDevicesRequest( |
| const WebMediaDevicesRequest&) { |
| } |
| |
| void MockWebUserMediaClient::requestSources( |
| const blink::WebMediaStreamTrackSourcesRequest& request) { |
| struct { |
| const char* id; |
| WebSourceInfo::SourceKind kind; |
| const char* label; |
| WebSourceInfo::VideoFacingMode facing; |
| } test_sources[] = { |
| { |
| "device1", |
| WebSourceInfo::SourceKindAudio, |
| "Built-in microphone", |
| WebSourceInfo::VideoFacingModeNone, |
| }, |
| { |
| "device2", |
| WebSourceInfo::SourceKindVideo, |
| "Build-in webcam", |
| WebSourceInfo::VideoFacingModeEnvironment, |
| }, |
| }; |
| |
| WebVector<WebSourceInfo> sources(arraysize(test_sources)); |
| for (size_t i = 0; i < arraysize(test_sources); ++i) { |
| sources[i].initialize(WebString::fromUTF8(test_sources[i].id), |
| test_sources[i].kind, |
| WebString::fromUTF8(test_sources[i].label), |
| test_sources[i].facing); |
| } |
| |
| delegate_->PostTask(new SourcesRequestTask(this, request, sources)); |
| } |
| |
| } // namespace test_runner |