diff options
Diffstat (limited to 'Source/WebCore/platform/mock')
44 files changed, 2635 insertions, 1042 deletions
diff --git a/Source/WebCore/platform/mock/DeviceMotionClientMock.cpp b/Source/WebCore/platform/mock/DeviceMotionClientMock.cpp deleted file mode 100644 index ecc4b13fd..000000000 --- a/Source/WebCore/platform/mock/DeviceMotionClientMock.cpp +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (C) 2012 Google Inc. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY - * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "config.h" -#include "DeviceMotionClientMock.h" - -#include "DeviceMotionController.h" - -namespace WebCore { - -DeviceMotionClientMock::DeviceMotionClientMock() - : m_controller(0) - , m_timer(this, &DeviceMotionClientMock::timerFired) - , m_isUpdating(false) -{ -} - -void DeviceMotionClientMock::setController(DeviceMotionController* controller) -{ - ASSERT(!m_controller); - m_controller = controller; - ASSERT(m_controller); -} - -void DeviceMotionClientMock::startUpdating() -{ - m_isUpdating = true; -} - -void DeviceMotionClientMock::stopUpdating() -{ - m_isUpdating = false; - m_timer.stop(); -} - -void DeviceMotionClientMock::setMotion(PassRefPtr<DeviceMotionData> motion) -{ - m_motion = motion; - if (m_isUpdating && !m_timer.isActive()) - m_timer.startOneShot(0); -} - -void DeviceMotionClientMock::timerFired(Timer<DeviceMotionClientMock>* timer) -{ - ASSERT_UNUSED(timer, timer == &m_timer); - m_timer.stop(); - m_controller->didChangeDeviceMotion(m_motion.get()); -} - -} // namespace WebCore diff --git a/Source/WebCore/platform/mock/DeviceMotionClientMock.h b/Source/WebCore/platform/mock/DeviceMotionClientMock.h deleted file mode 100644 index f2e0a981a..000000000 --- a/Source/WebCore/platform/mock/DeviceMotionClientMock.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (C) 2012 Google Inc. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY - * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef DeviceMotionClientMock_h -#define DeviceMotionClientMock_h - -#include "DeviceMotionClient.h" -#include "DeviceMotionData.h" -#include "Timer.h" - -#include <wtf/PassRefPtr.h> -#include <wtf/RefPtr.h> - -namespace WebCore { - -class DeviceMotionController; - -// A mock implementation of DeviceMotionClient used to test the feature in -// DumpRenderTree. Embedders should should configure the Page object to use this -// client when running DumpRenderTree. -class DeviceMotionClientMock : public DeviceMotionClient { -public: - DeviceMotionClientMock(); - - // DeviceMotionClient - virtual void setController(DeviceMotionController*) override; - virtual void startUpdating() override; - virtual void stopUpdating() override; - virtual DeviceMotionData* lastMotion() const override { return m_motion.get(); } - // mock is owned by the testing framework, which should handle deletion - virtual void deviceMotionControllerDestroyed() override { } - - void setMotion(PassRefPtr<DeviceMotionData>); - -private: - void timerFired(Timer<DeviceMotionClientMock>*); - - RefPtr<DeviceMotionData> m_motion; - DeviceMotionController* m_controller; - Timer<DeviceMotionClientMock> m_timer; - bool m_isUpdating; -}; - -} // namespace WebCore - -#endif // DeviceMotionClientMock_h diff --git a/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp b/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp index 9716a7e6a..af0a834c3 100644 --- a/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp +++ b/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp @@ -32,7 +32,7 @@ namespace WebCore { DeviceOrientationClientMock::DeviceOrientationClientMock() : m_controller(0) - , m_timer(this, &DeviceOrientationClientMock::timerFired) + , m_timer(*this, &DeviceOrientationClientMock::timerFired) , m_isUpdating(false) { } @@ -62,9 +62,8 @@ void DeviceOrientationClientMock::setOrientation(PassRefPtr<DeviceOrientationDat m_timer.startOneShot(0); } -void DeviceOrientationClientMock::timerFired(Timer<DeviceOrientationClientMock>& timer) +void DeviceOrientationClientMock::timerFired() { - ASSERT_UNUSED(timer, &timer == &m_timer); m_timer.stop(); m_controller->didChangeDeviceOrientation(m_orientation.get()); } diff --git a/Source/WebCore/platform/mock/DeviceOrientationClientMock.h b/Source/WebCore/platform/mock/DeviceOrientationClientMock.h index df85b7fc9..1384af2e6 100644 --- a/Source/WebCore/platform/mock/DeviceOrientationClientMock.h +++ b/Source/WebCore/platform/mock/DeviceOrientationClientMock.h @@ -42,23 +42,23 @@ class DeviceOrientationController; // client when running DumpRenderTree. class DeviceOrientationClientMock : public DeviceOrientationClient { public: - DeviceOrientationClientMock(); + WEBCORE_EXPORT DeviceOrientationClientMock(); // DeviceOrientationClient - virtual void setController(DeviceOrientationController*) override; - virtual void startUpdating() override; - virtual void stopUpdating() override; - virtual DeviceOrientationData* lastOrientation() const override { return m_orientation.get(); } - virtual void deviceOrientationControllerDestroyed() override { } + void setController(DeviceOrientationController*) override; + void startUpdating() override; + void stopUpdating() override; + DeviceOrientationData* lastOrientation() const override { return m_orientation.get(); } + void deviceOrientationControllerDestroyed() override { } - void setOrientation(PassRefPtr<DeviceOrientationData>); + WEBCORE_EXPORT void setOrientation(PassRefPtr<DeviceOrientationData>); private: - void timerFired(Timer<DeviceOrientationClientMock>&); + void timerFired(); RefPtr<DeviceOrientationData> m_orientation; DeviceOrientationController* m_controller; - Timer<DeviceOrientationClientMock> m_timer; + Timer m_timer; bool m_isUpdating; }; diff --git a/Source/WebCore/platform/mock/GeolocationClientMock.cpp b/Source/WebCore/platform/mock/GeolocationClientMock.cpp index 9901b66aa..b7cfb9be0 100644 --- a/Source/WebCore/platform/mock/GeolocationClientMock.cpp +++ b/Source/WebCore/platform/mock/GeolocationClientMock.cpp @@ -43,8 +43,8 @@ namespace WebCore { GeolocationClientMock::GeolocationClientMock() : m_controller(0) , m_hasError(false) - , m_controllerTimer(this, &GeolocationClientMock::controllerTimerFired) - , m_permissionTimer(this, &GeolocationClientMock::permissionTimerFired) + , m_controllerTimer(*this, &GeolocationClientMock::controllerTimerFired) + , m_permissionTimer(*this, &GeolocationClientMock::permissionTimerFired) , m_isActive(false) , m_permissionState(PermissionStateUnset) { @@ -109,9 +109,8 @@ void GeolocationClientMock::asyncUpdatePermission() m_permissionTimer.startOneShot(0); } -void GeolocationClientMock::permissionTimerFired(WebCore::Timer<GeolocationClientMock>* timer) +void GeolocationClientMock::permissionTimerFired() { - ASSERT_UNUSED(timer, timer == &m_permissionTimer); ASSERT(m_permissionState != PermissionStateUnset); bool allowed = m_permissionState == PermissionStateAllowed; GeolocationSet::iterator end = m_pendingPermission.end(); @@ -127,7 +126,7 @@ void GeolocationClientMock::permissionTimerFired(WebCore::Timer<GeolocationClien void GeolocationClientMock::reset() { - m_lastPosition = 0; + m_lastPosition = nullptr; clearError(); m_permissionState = PermissionStateUnset; } @@ -169,9 +168,8 @@ void GeolocationClientMock::asyncUpdateController() m_controllerTimer.startOneShot(0); } -void GeolocationClientMock::controllerTimerFired(Timer<GeolocationClientMock>* timer) +void GeolocationClientMock::controllerTimerFired() { - ASSERT_UNUSED(timer, timer == &m_controllerTimer); ASSERT(m_controller); if (m_lastPosition.get()) { diff --git a/Source/WebCore/platform/mock/GeolocationClientMock.h b/Source/WebCore/platform/mock/GeolocationClientMock.h index f380c1443..b13987729 100644 --- a/Source/WebCore/platform/mock/GeolocationClientMock.h +++ b/Source/WebCore/platform/mock/GeolocationClientMock.h @@ -60,20 +60,20 @@ public: int numberOfPendingPermissionRequests() const; // GeolocationClient - virtual void geolocationDestroyed(); - virtual void startUpdating(); - virtual void stopUpdating(); - virtual void setEnableHighAccuracy(bool); - virtual GeolocationPosition* lastPosition(); - virtual void requestPermission(Geolocation*); - virtual void cancelPermissionRequest(Geolocation*); + void geolocationDestroyed() override; + void startUpdating() override; + void stopUpdating() override; + void setEnableHighAccuracy(bool) override; + GeolocationPosition* lastPosition() override; + void requestPermission(Geolocation*) override; + void cancelPermissionRequest(Geolocation*) override; private: void asyncUpdateController(); - void controllerTimerFired(Timer<GeolocationClientMock>*); + void controllerTimerFired(); void asyncUpdatePermission(); - void permissionTimerFired(Timer<GeolocationClientMock>*); + void permissionTimerFired(); void clearError(); @@ -81,8 +81,8 @@ private: RefPtr<GeolocationPosition> m_lastPosition; bool m_hasError; String m_errorMessage; - Timer<GeolocationClientMock> m_controllerTimer; - Timer<GeolocationClientMock> m_permissionTimer; + Timer m_controllerTimer; + Timer m_permissionTimer; bool m_isActive; enum PermissionState { diff --git a/Source/WebCore/platform/mock/MediaConstraintsMock.cpp b/Source/WebCore/platform/mock/MediaConstraintsMock.cpp deleted file mode 100644 index db9389516..000000000 --- a/Source/WebCore/platform/mock/MediaConstraintsMock.cpp +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2012 Google Inc. All rights reserved. - * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "config.h" - -#if ENABLE(MEDIA_STREAM) - -#include "MediaConstraintsMock.h" - -#include "MediaConstraints.h" - -namespace WebCore { - -bool isSupported(const String& constraint) -{ - return notFound != constraint.find("_and_supported_"); -} - -bool isValid(const String& constraint) -{ - return isSupported(constraint) || notFound != constraint.find("valid_"); -} - -String MediaConstraintsMock::verifyConstraints(PassRefPtr<MediaConstraints> prpConstraints) -{ - RefPtr<MediaConstraints> constraints = prpConstraints; - - Vector<MediaConstraint> mandatoryConstraints; - constraints->getMandatoryConstraints(mandatoryConstraints); - if (mandatoryConstraints.size()) { - for (size_t i = 0; i < mandatoryConstraints.size(); ++i) { - const MediaConstraint& curr = mandatoryConstraints[i]; - if (!isSupported(curr.m_name) || curr.m_value != "1") - return curr.m_name; - } - } - - Vector<MediaConstraint> optionalConstraints; - constraints->getOptionalConstraints(optionalConstraints); - if (optionalConstraints.size()) { - for (size_t i = 0; i < optionalConstraints.size(); ++i) { - const MediaConstraint& curr = optionalConstraints[i]; - if (!isValid(curr.m_name) || curr.m_value != "0") - return curr.m_name; - } - } - - return emptyString(); -} - -} // namespace WebCore - -#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MediaPlaybackTargetMock.cpp b/Source/WebCore/platform/mock/MediaPlaybackTargetMock.cpp new file mode 100644 index 000000000..01ff3faad --- /dev/null +++ b/Source/WebCore/platform/mock/MediaPlaybackTargetMock.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MediaPlaybackTargetMock.h" + +#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) + +namespace WebCore { + +Ref<MediaPlaybackTarget> MediaPlaybackTargetMock::create(const String& name, MediaPlaybackTargetContext::State state) +{ + return adoptRef(*new MediaPlaybackTargetMock(name, state)); +} + +MediaPlaybackTargetMock::MediaPlaybackTargetMock(const String& name, MediaPlaybackTargetContext::State state) + : MediaPlaybackTarget() + , m_name(name) + , m_state(state) +{ +} + +MediaPlaybackTargetMock::~MediaPlaybackTargetMock() +{ +} + +const MediaPlaybackTargetContext& MediaPlaybackTargetMock::targetContext() const +{ + m_context = MediaPlaybackTargetContext(m_name, m_state); + return m_context; +} + +MediaPlaybackTargetMock* toMediaPlaybackTargetMock(MediaPlaybackTarget* rep) +{ + return const_cast<MediaPlaybackTargetMock*>(toMediaPlaybackTargetMock(const_cast<const MediaPlaybackTarget*>(rep))); +} + +const MediaPlaybackTargetMock* toMediaPlaybackTargetMock(const MediaPlaybackTarget* rep) +{ + ASSERT_WITH_SECURITY_IMPLICATION(rep->targetType() == MediaPlaybackTarget::Mock); + return static_cast<const MediaPlaybackTargetMock*>(rep); +} + +} // namespace WebCore + +#endif // ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) diff --git a/Source/WebCore/platform/mock/MediaPlaybackTargetMock.h b/Source/WebCore/platform/mock/MediaPlaybackTargetMock.h new file mode 100644 index 000000000..1dd97f12e --- /dev/null +++ b/Source/WebCore/platform/mock/MediaPlaybackTargetMock.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MediaPlaybackTargetMock_h +#define MediaPlaybackTargetMock_h + +#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) + +#include "MediaPlaybackTarget.h" +#include "MediaPlaybackTargetContext.h" +#include <wtf/text/WTFString.h> + +namespace WebCore { + +class MediaPlaybackTargetMock : public MediaPlaybackTarget { +public: + WEBCORE_EXPORT static Ref<MediaPlaybackTarget> create(const String&, MediaPlaybackTargetContext::State); + + virtual ~MediaPlaybackTargetMock(); + + TargetType targetType() const override { return Mock; } + + const MediaPlaybackTargetContext& targetContext() const override; + + bool hasActiveRoute() const override { return !m_name.isEmpty(); } + + String deviceName() const override { return m_name; } + + MediaPlaybackTargetContext::State state() const; + +protected: + MediaPlaybackTargetMock(const String&, MediaPlaybackTargetContext::State); + + String m_name; + MediaPlaybackTargetContext::State m_state { MediaPlaybackTargetContext::Unknown }; + mutable MediaPlaybackTargetContext m_context; +}; + +MediaPlaybackTargetMock* toMediaPlaybackTargetMock(MediaPlaybackTarget*); +const MediaPlaybackTargetMock* toMediaPlaybackTargetMock(const MediaPlaybackTarget*); + +} + +#endif // ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) + +#endif diff --git a/Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp b/Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp new file mode 100644 index 000000000..1a60ca24b --- /dev/null +++ b/Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MediaPlaybackTargetPickerMock.h" + +#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) + +#include "FloatRect.h" +#include "Logging.h" +#include "MediaPlaybackTargetMock.h" +#include "WebMediaSessionManager.h" + +using namespace WebCore; + +namespace WebCore { + +static const double timerInterval = 1.0 / 10.0; + +MediaPlaybackTargetPickerMock::MediaPlaybackTargetPickerMock(MediaPlaybackTargetPicker::Client& client) + : MediaPlaybackTargetPicker(client) + , m_timer(RunLoop::main(), this, &MediaPlaybackTargetPickerMock::timerFired) +{ + LOG(Media, "MediaPlaybackTargetPickerMock::MediaPlaybackTargetPickerMock"); +} + +MediaPlaybackTargetPickerMock::~MediaPlaybackTargetPickerMock() +{ + LOG(Media, "MediaPlaybackTargetPickerMock::~MediaPlaybackTargetPickerMock"); + setClient(nullptr); +} + +bool MediaPlaybackTargetPickerMock::externalOutputDeviceAvailable() +{ + LOG(Media, "MediaPlaybackTargetPickerMock::externalOutputDeviceAvailable"); + return m_state == MediaPlaybackTargetContext::OutputDeviceAvailable; +} + +Ref<MediaPlaybackTarget> MediaPlaybackTargetPickerMock::playbackTarget() +{ + LOG(Media, "MediaPlaybackTargetPickerMock::playbackTarget"); + return WebCore::MediaPlaybackTargetMock::create(m_deviceName, m_state); +} + +void MediaPlaybackTargetPickerMock::timerFired() +{ + m_showingMenu = false; + currentDeviceDidChange(); +} + +void MediaPlaybackTargetPickerMock::showPlaybackTargetPicker(const FloatRect&, bool checkActiveRoute) +{ + if (!client() || m_showingMenu) + return; + +#if LOG_DISABLED + UNUSED_PARAM(checkActiveRoute); +#endif + LOG(Media, "MediaPlaybackTargetPickerMock::showPlaybackTargetPicker - checkActiveRoute = %i", (int)checkActiveRoute); + + m_showingMenu = true; + m_timer.startOneShot(timerInterval); +} + +void MediaPlaybackTargetPickerMock::startingMonitoringPlaybackTargets() +{ + LOG(Media, "MediaPlaybackTargetPickerMock::startingMonitoringPlaybackTargets"); + + if (m_state == MediaPlaybackTargetContext::OutputDeviceAvailable) + availableDevicesDidChange(); + + if (!m_deviceName.isEmpty() && m_state != MediaPlaybackTargetContext::Unknown) + currentDeviceDidChange(); +} + +void MediaPlaybackTargetPickerMock::stopMonitoringPlaybackTargets() +{ + LOG(Media, "MediaPlaybackTargetPickerMock::stopMonitoringPlaybackTargets"); +} + +void MediaPlaybackTargetPickerMock::invalidatePlaybackTargets() +{ + LOG(Media, "MediaPlaybackTargetPickerMock::invalidatePlaybackTargets"); + setState(emptyString(), MediaPlaybackTargetContext::Unknown); +} + +void MediaPlaybackTargetPickerMock::setState(const String& deviceName, MediaPlaybackTargetContext::State state) +{ + LOG(Media, "MediaPlaybackTargetPickerMock::setState - name = %s, state = 0x%x", deviceName.utf8().data(), (unsigned)state); + + if (deviceName != m_deviceName && state != MediaPlaybackTargetContext::Unknown) { + m_deviceName = deviceName; + currentDeviceDidChange(); + } + + if (m_state != state) { + m_state = state; + availableDevicesDidChange(); + } +} + +} // namespace WebCore + +#endif // ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) diff --git a/Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.h b/Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.h new file mode 100644 index 000000000..35cc954b0 --- /dev/null +++ b/Source/WebCore/platform/mock/MediaPlaybackTargetPickerMock.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MediaPlaybackTargetPickerMock_h +#define MediaPlaybackTargetPickerMock_h + +#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) + +#include "MediaPlaybackTargetContext.h" +#include "MediaPlaybackTargetPicker.h" +#include <wtf/text/WTFString.h> + +namespace WebCore { + +class MediaPlaybackTargetPickerMock final : public MediaPlaybackTargetPicker { + WTF_MAKE_NONCOPYABLE(MediaPlaybackTargetPickerMock); +public: + explicit MediaPlaybackTargetPickerMock(MediaPlaybackTargetPicker::Client&); + + virtual ~MediaPlaybackTargetPickerMock(); + + void showPlaybackTargetPicker(const FloatRect&, bool checkActiveRoute) override; + void startingMonitoringPlaybackTargets() override; + void stopMonitoringPlaybackTargets() override; + void invalidatePlaybackTargets() override; + + void setState(const String&, MediaPlaybackTargetContext::State); + +private: + bool externalOutputDeviceAvailable() override; + Ref<MediaPlaybackTarget> playbackTarget() override; + + void timerFired(); + + String m_deviceName; + RunLoop::Timer<MediaPlaybackTargetPickerMock> m_timer; + MediaPlaybackTargetContext::State m_state { MediaPlaybackTargetContext::Unknown }; + bool m_showingMenu { false }; +}; + +} // namespace WebCore + +#endif // ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS) + +#endif // WebContextMenuProxyMac_h diff --git a/Source/WebCore/platform/mock/MockMediaEndpoint.cpp b/Source/WebCore/platform/mock/MockMediaEndpoint.cpp new file mode 100644 index 000000000..253b6e938 --- /dev/null +++ b/Source/WebCore/platform/mock/MockMediaEndpoint.cpp @@ -0,0 +1,342 @@ +/* + * Copyright (C) 2015 Ericsson AB. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(WEB_RTC) +#include "MockMediaEndpoint.h" + +#include "MediaEndpointSessionConfiguration.h" +#include "MediaPayload.h" +#include "MockRealtimeAudioSource.h" +#include "MockRealtimeVideoSource.h" +#include "RTCDataChannelHandlerMock.h" +#include "RealtimeMediaSource.h" +#include <wtf/MainThread.h> + +namespace WebCore { + +static const char* fingerprint = "8B:87:09:8A:5D:C2:F3:33:EF:C5:B1:F6:84:3A:3D:D6:A3:E2:9C:17:4C:E7:46:3B:1B:CE:84:98:DD:8E:AF:7B"; +static const char* fingerprintFunction = "sha-256"; + +std::unique_ptr<MediaEndpoint> MockMediaEndpoint::create(MediaEndpointClient& client) +{ + return std::unique_ptr<MediaEndpoint>(new MockMediaEndpoint(client)); +} + +MockMediaEndpoint::MockMediaEndpoint(MediaEndpointClient& client) + : m_client(client) + , m_iceCandidateTimer(*this, &MockMediaEndpoint::iceCandidateTimerFired) + , m_iceTransportTimer(*this, &MockMediaEndpoint::iceTransportTimerFired) + , m_unmuteTimer(*this, &MockMediaEndpoint::unmuteTimerFired) + , m_weakPtrFactory(this) +{ +} + +MockMediaEndpoint::~MockMediaEndpoint() +{ + stop(); +} + +std::unique_ptr<RTCDataChannelHandler> MockMediaEndpoint::createDataChannelHandler(const String& label, const RTCDataChannelInit& options) +{ + return std::make_unique<RTCDataChannelHandlerMock>(label, options); +} + +void MockMediaEndpoint::generateDtlsInfo() +{ + auto weakThis = m_weakPtrFactory.createWeakPtr(); + + callOnMainThread([weakThis] { + if (weakThis) + weakThis->m_client.gotDtlsFingerprint(fingerprint, fingerprintFunction); + }); +} + +MediaPayloadVector MockMediaEndpoint::getDefaultAudioPayloads() +{ + MediaPayloadVector payloads; + + MediaPayload payload1; + payload1.type = 111; + payload1.encodingName = "OPUS"; + payload1.clockRate = 48000; + payload1.channels = 2; + payloads.append(WTFMove(payload1)); + + MediaPayload payload2; + payload2.type = 8; + payload2.encodingName = "PCMA"; + payload2.clockRate = 8000; + payload2.channels = 1; + payloads.append(WTFMove(payload2)); + + MediaPayload payload3; + payload3.type = 0; + payload3.encodingName = "PCMU"; + payload3.clockRate = 8000; + payload3.channels = 1; + payloads.append(WTFMove(payload3)); + + return payloads; +} + +MediaPayloadVector MockMediaEndpoint::getDefaultVideoPayloads() +{ + MediaPayloadVector payloads; + + MediaPayload payload1; + payload1.type = 103; + payload1.encodingName = "H264"; + payload1.clockRate = 90000; + payload1.ccmfir = true; + payload1.nackpli = true; + payload1.addParameter("packetizationMode", 1); + payloads.append(WTFMove(payload1)); + + MediaPayload payload2; + payload2.type = 100; + payload2.encodingName = "VP8"; + payload2.clockRate = 90000; + payload2.ccmfir = true; + payload2.nackpli = true; + payload2.nack = true; + payloads.append(WTFMove(payload2)); + + MediaPayload payload3; + payload3.type = 120; + payload3.encodingName = "RTX"; + payload3.clockRate = 90000; + payload3.addParameter("apt", 100); + payload3.addParameter("rtxTime", 200); + payloads.append(WTFMove(payload3)); + + return payloads; +} + +MediaPayloadVector MockMediaEndpoint::filterPayloads(const MediaPayloadVector& remotePayloads, const MediaPayloadVector& defaultPayloads) +{ + MediaPayloadVector filteredPayloads; + + for (auto& remotePayload : remotePayloads) { + const MediaPayload* defaultPayload = nullptr; + for (auto& payload : defaultPayloads) { + if (payload.encodingName == remotePayload.encodingName.convertToASCIIUppercase()) { + defaultPayload = &payload; + break; + } + } + if (!defaultPayload) + continue; + + if (defaultPayload->parameters.contains("packetizationMode") && remotePayload.parameters.contains("packetizationMode") + && (defaultPayload->parameters.get("packetizationMode") != defaultPayload->parameters.get("packetizationMode"))) + continue; + + filteredPayloads.append(remotePayload); + } + + return filteredPayloads; +} + +MediaEndpoint::UpdateResult MockMediaEndpoint::updateReceiveConfiguration(MediaEndpointSessionConfiguration* configuration, bool isInitiator) +{ + UNUSED_PARAM(isInitiator); + + updateConfigurationMids(*configuration); + return UpdateResult::Success; +} + +MediaEndpoint::UpdateResult MockMediaEndpoint::updateSendConfiguration(MediaEndpointSessionConfiguration* configuration, const RealtimeMediaSourceMap& sendSourceMap, bool isInitiator) +{ + UNUSED_PARAM(sendSourceMap); + UNUSED_PARAM(isInitiator); + + updateConfigurationMids(*configuration); + return UpdateResult::Success; +} + +void MockMediaEndpoint::addRemoteCandidate(const IceCandidate& candidate, const String& mid, const String& ufrag, const String& password) +{ + UNUSED_PARAM(candidate); + UNUSED_PARAM(mid); + UNUSED_PARAM(ufrag); + UNUSED_PARAM(password); +} + +Ref<RealtimeMediaSource> MockMediaEndpoint::createMutedRemoteSource(const String& mid, RealtimeMediaSource::Type type) +{ + RefPtr<RealtimeMediaSource> source; + + switch (type) { + case RealtimeMediaSource::Audio: source = MockRealtimeAudioSource::createMuted("remote audio"); break; + case RealtimeMediaSource::Video: source = MockRealtimeVideoSource::createMuted("remote video"); break; + case RealtimeMediaSource::None: + ASSERT_NOT_REACHED(); + } + + m_mutedRemoteSources.set(mid, source); + return *source; +} + +void MockMediaEndpoint::replaceSendSource(RealtimeMediaSource& newSource, const String& mid) +{ + UNUSED_PARAM(newSource); + UNUSED_PARAM(mid); +} + +void MockMediaEndpoint::replaceMutedRemoteSourceMid(const String& oldMid, const String& newMid) +{ + RefPtr<RealtimeMediaSource> remoteSource = m_mutedRemoteSources.take(oldMid); + m_mutedRemoteSources.set(newMid, WTFMove(remoteSource)); +} + +void MockMediaEndpoint::stop() +{ +} + +void MockMediaEndpoint::emulatePlatformEvent(const String& action) +{ + if (action == "dispatch-fake-ice-candidates") + dispatchFakeIceCandidates(); + else if (action == "step-ice-transport-states") + stepIceTransportStates(); + else if (action == "unmute-remote-sources-by-mid") + unmuteRemoteSourcesByMid(); +} + +void MockMediaEndpoint::updateConfigurationMids(const MediaEndpointSessionConfiguration& configuration) +{ + Vector<String> mids; + for (auto& mediaDescription : configuration.mediaDescriptions()) + mids.append(mediaDescription.mid); + m_mids.swap(mids); +} + +void MockMediaEndpoint::dispatchFakeIceCandidates() +{ + m_fakeIceCandidates.append({ "host", "1", 1, "UDP", 2013266431, "192.168.0.100", 38838, { }, { }, 0 }); + m_fakeIceCandidates.append({ "host", "2", 1, "TCP", 1019216383, "192.168.0.100", 9, "active", { }, 0 }); + m_fakeIceCandidates.append({ "srflx", "3", 1, "UDP", 1677722111, "172.18.0.1", 47989, { }, "192.168.0.100", 47989 }); + + // Reverse order to use takeLast() while keeping the above order + m_fakeIceCandidates.reverse(); + + m_iceCandidateTimer.startOneShot(0); +} + +void MockMediaEndpoint::iceCandidateTimerFired() +{ + if (m_mids.isEmpty()) + return; + + if (!m_fakeIceCandidates.isEmpty()) { + m_client.gotIceCandidate(m_mids[0], m_fakeIceCandidates.takeLast()); + m_iceCandidateTimer.startOneShot(0); + } else + m_client.doneGatheringCandidates(m_mids[0]); +} + +void MockMediaEndpoint::stepIceTransportStates() +{ + if (m_mids.size() != 3) { + LOG_ERROR("The 'step-ice-transport-states' action requires 3 transceivers"); + return; + } + + // Should go to: + // 'checking' + m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Checking)); + m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Checking)); + m_iceTransportStateChanges.append(std::make_pair(m_mids[2], MediaEndpoint::IceTransportState::Checking)); + + // 'connected' + m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Connected)); + m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Completed)); + m_iceTransportStateChanges.append(std::make_pair(m_mids[2], MediaEndpoint::IceTransportState::Closed)); + + // 'completed' + m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Completed)); + + // 'failed' + m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Failed)); + + // 'disconnected' + m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Disconnected)); + m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Closed)); + + // 'new' + m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Closed)); + + // Reverse order to use takeLast() while keeping the above order + m_iceTransportStateChanges.reverse(); + + m_iceTransportTimer.startOneShot(0); +} + +void MockMediaEndpoint::iceTransportTimerFired() +{ + if (m_iceTransportStateChanges.isEmpty() || m_mids.size() != 3) + return; + + auto stateChange = m_iceTransportStateChanges.takeLast(); + m_client.iceTransportStateChanged(stateChange.first, stateChange.second); + + m_iceTransportTimer.startOneShot(0); +} + +void MockMediaEndpoint::unmuteRemoteSourcesByMid() +{ + if (m_mids.isEmpty()) + return; + + // Looking up each source by its mid, instead of simply iterating over the list of muted sources, + // emulates remote media arriving on a media description with a specific mid (RTCRtpTransceiver). + + // Copy values in reverse order to maintain the original order while using takeLast() + for (int i = m_mids.size() - 1; i >= 0; --i) + m_midsOfSourcesToUnmute.append(m_mids[i]); + + m_unmuteTimer.startOneShot(0); +} + +void MockMediaEndpoint::unmuteTimerFired() +{ + RefPtr<RealtimeMediaSource> source = m_mutedRemoteSources.get(m_midsOfSourcesToUnmute.takeLast()); + if (source) + source->setMuted(false); + + if (!m_midsOfSourcesToUnmute.isEmpty()) + m_unmuteTimer.startOneShot(0); +} + +} // namespace WebCore + +#endif // ENABLE(WEB_RTC) diff --git a/Source/WebCore/platform/mock/MockMediaEndpoint.h b/Source/WebCore/platform/mock/MockMediaEndpoint.h new file mode 100644 index 000000000..7359c8d48 --- /dev/null +++ b/Source/WebCore/platform/mock/MockMediaEndpoint.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2015 Ericsson AB. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#if ENABLE(WEB_RTC) + +#include "MediaEndpoint.h" +#include "Timer.h" + +namespace WebCore { + +class MockMediaEndpoint final : public MediaEndpoint { +public: + WEBCORE_EXPORT static std::unique_ptr<MediaEndpoint> create(MediaEndpointClient&); + + MockMediaEndpoint(MediaEndpointClient&); + ~MockMediaEndpoint(); + + void setConfiguration(MediaEndpointConfiguration&&) final { }; + + void generateDtlsInfo() final; + MediaPayloadVector getDefaultAudioPayloads() final; + MediaPayloadVector getDefaultVideoPayloads() final; + MediaPayloadVector filterPayloads(const MediaPayloadVector& remotePayloads, const MediaPayloadVector& defaultPayloads) final; + + UpdateResult updateReceiveConfiguration(MediaEndpointSessionConfiguration*, bool isInitiator) final; + UpdateResult updateSendConfiguration(MediaEndpointSessionConfiguration*, const RealtimeMediaSourceMap&, bool isInitiator) final; + + void addRemoteCandidate(const IceCandidate&, const String& mid, const String& ufrag, const String& password) final; + + Ref<RealtimeMediaSource> createMutedRemoteSource(const String& mid, RealtimeMediaSource::Type) final; + void replaceSendSource(RealtimeMediaSource&, const String& mid) final; + void replaceMutedRemoteSourceMid(const String& oldMid, const String& newMid) final; + + void stop() final; + + void emulatePlatformEvent(const String& action) final; + +private: + void updateConfigurationMids(const MediaEndpointSessionConfiguration&); + + std::unique_ptr<RTCDataChannelHandler> createDataChannelHandler(const String&, const RTCDataChannelInit&) final; + + void dispatchFakeIceCandidates(); + void iceCandidateTimerFired(); + + void stepIceTransportStates(); + void iceTransportTimerFired(); + + void unmuteRemoteSourcesByMid(); + void unmuteTimerFired(); + + MediaEndpointClient& m_client; + Vector<String> m_mids; + HashMap<String, RefPtr<RealtimeMediaSource>> m_mutedRemoteSources; + + Vector<IceCandidate> m_fakeIceCandidates; + Timer m_iceCandidateTimer; + + Vector<std::pair<String, MediaEndpoint::IceTransportState>> m_iceTransportStateChanges; + Timer m_iceTransportTimer; + + Vector<String> m_midsOfSourcesToUnmute; + Timer m_unmuteTimer; + + WeakPtrFactory<MockMediaEndpoint> m_weakPtrFactory; +}; + +} // namespace WebCore + +#endif // ENABLE(WEB_RTC) diff --git a/Source/WebCore/platform/mock/MockMediaStreamCenter.cpp b/Source/WebCore/platform/mock/MockMediaStreamCenter.cpp deleted file mode 100644 index 20cb1ab8b..000000000 --- a/Source/WebCore/platform/mock/MockMediaStreamCenter.cpp +++ /dev/null @@ -1,220 +0,0 @@ -/* - * Copyright (C) 2013 Google Inc. All rights reserved. - * Copyright (C) 2013 Apple Computer, Inc. All rights reserved. - * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY - * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "config.h" - -#if ENABLE(MEDIA_STREAM) - -#include "MockMediaStreamCenter.h" - -#include "MediaConstraintsMock.h" -#include "MediaStream.h" -#include "MediaStreamCreationClient.h" -#include "MediaStreamPrivate.h" -#include "MediaStreamSource.h" -#include "MediaStreamSourceCapabilities.h" -#include "MediaStreamTrack.h" -#include "MediaStreamTrackSourcesRequestClient.h" -#include <wtf/NeverDestroyed.h> - -namespace WebCore { - -class MockSource : public MediaStreamSource { -public: - MockSource(const AtomicString& id, const AtomicString& name, MediaStreamSource::Type type) - : MediaStreamSource(id, type, name) - { - } - - virtual ~MockSource() { } - - virtual RefPtr<MediaStreamSourceCapabilities> capabilities() const { return m_capabilities; } - virtual const MediaStreamSourceStates& states() { return m_currentStates; } - - RefPtr<MediaStreamSourceCapabilities> m_capabilities; - MediaStreamSourceStates m_currentStates; -}; - -typedef HashMap<String, RefPtr<MockSource>> MockSourceMap; - -static MockSourceMap& mockSourceMap() -{ - DEFINE_STATIC_LOCAL(MockSourceMap, mockSourceMap, ()); - return mockSourceMap; -} - -static const AtomicString& mockAudioSourceID() -{ - static NeverDestroyed<AtomicString> id("239c24b1-2b15-11e3-8224-0800200c9a66", AtomicString::ConstructFromLiteral); - return id; -} - -static const AtomicString& mockVideoSourceID() -{ - static NeverDestroyed<AtomicString> id("239c24b0-2b15-11e3-8224-0800200c9a66", AtomicString::ConstructFromLiteral); - return id; -} - -static void initializeMockSources() -{ - RefPtr<MockSource> mockSource1 = adoptRef(new MockSource(mockVideoSourceID(), "Mock video device", MediaStreamSource::Video)); - mockSource1->m_capabilities = MediaStreamSourceCapabilities::create(); - mockSource1->m_capabilities->setSourceId(mockSource1->id()); - mockSource1->m_capabilities->addSourceType(MediaStreamSourceStates::Camera); - mockSource1->m_capabilities->addSourceType(MediaStreamSourceStates::Microphone); - mockSource1->m_capabilities->addFacingMode(MediaStreamSourceStates::User); - mockSource1->m_capabilities->addFacingMode(MediaStreamSourceStates::Environment); - mockSource1->m_capabilities->setWidthRange(MediaStreamSourceCapabilityRange(320UL, 1920UL, true)); - mockSource1->m_capabilities->setHeightRange(MediaStreamSourceCapabilityRange(240UL, 1080UL, true)); - mockSource1->m_capabilities->setFrameRateRange(MediaStreamSourceCapabilityRange(15.0f, 60.0f, true)); - mockSource1->m_capabilities->setAspectRatioRange(MediaStreamSourceCapabilityRange(4 / 3.0f, 16 / 9.0f, true)); - mockSource1->m_capabilities->setVolumeRange(MediaStreamSourceCapabilityRange(10UL, 90UL, true)); - - mockSource1->m_currentStates.setSourceType(MediaStreamSourceStates::Camera); - mockSource1->m_currentStates.setSourceId(mockSource1->id()); - mockSource1->m_currentStates.setFacingMode(MediaStreamSourceStates::User); - mockSource1->m_currentStates.setWidth(1920); - mockSource1->m_currentStates.setHeight(1080); - mockSource1->m_currentStates.setFrameRate(30); - mockSource1->m_currentStates.setAspectRatio(16 / 9.0f); - mockSource1->m_currentStates.setVolume(70); - String mockSource1id = mockSource1->id(); - mockSourceMap().add(mockSource1id, mockSource1.release()); - - RefPtr<MockSource> mockSource2 = adoptRef(new MockSource(mockAudioSourceID(), "Mock audio device", MediaStreamSource::Audio)); - mockSource2->m_capabilities = MediaStreamSourceCapabilities::create(); - mockSource2->m_capabilities->setSourceId(mockSource2->id()); - mockSource2->m_capabilities->setVolumeRange(MediaStreamSourceCapabilityRange(0UL, 100UL, true)); - - mockSource2->m_currentStates.setSourceType(MediaStreamSourceStates::Microphone); - mockSource2->m_currentStates.setSourceId(mockSource2->id()); - mockSource2->m_currentStates.setVolume(50); - String mockSource2id = mockSource2->id(); - mockSourceMap().add(mockSource2id, mockSource2.release()); -} - -void MockMediaStreamCenter::registerMockMediaStreamCenter() -{ - DEFINE_STATIC_LOCAL(MockMediaStreamCenter, center, ()); - static bool registered = false; - if (!registered) { - registered = true; - MediaStreamCenter::setSharedStreamCenter(¢er); - initializeMockSources(); - } -} - -void MockMediaStreamCenter::validateRequestConstraints(PassRefPtr<MediaStreamCreationClient> prpQueryClient, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints) -{ - RefPtr<MediaStreamCreationClient> client = prpQueryClient; - - ASSERT(client); - - if (audioConstraints) { - String invalidQuery = MediaConstraintsMock::verifyConstraints(audioConstraints); - if (!invalidQuery.isEmpty()) { - client->constraintsInvalid(invalidQuery); - return; - } - } - - if (videoConstraints) { - String invalidQuery = MediaConstraintsMock::verifyConstraints(videoConstraints); - if (!invalidQuery.isEmpty()) { - client->constraintsInvalid(invalidQuery); - return; - } - } - - client->constraintsValidated(); -} - -void MockMediaStreamCenter::createMediaStream(PassRefPtr<MediaStreamCreationClient> prpQueryClient, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints) -{ - RefPtr<MediaStreamCreationClient> client = prpQueryClient; - - ASSERT(client); - - Vector<RefPtr<MediaStreamSource>> audioSources; - Vector<RefPtr<MediaStreamSource>> videoSources; - MockSourceMap& map = mockSourceMap(); - - if (audioConstraints) { - String invalidQuery = MediaConstraintsMock::verifyConstraints(audioConstraints); - if (!invalidQuery.isEmpty()) { - client->failedToCreateStreamWithConstraintsError(invalidQuery); - return; - } - - MockSourceMap::iterator it = map.find(mockAudioSourceID()); - ASSERT(it != map.end()); - - RefPtr<MediaStreamSource> audioSource = it->value; - audioSource->reset(); - audioSource->setReadyState(MediaStreamSource::Live); - audioSources.append(audioSource.release()); - } - - if (videoConstraints) { - String invalidQuery = MediaConstraintsMock::verifyConstraints(videoConstraints); - if (!invalidQuery.isEmpty()) { - client->failedToCreateStreamWithConstraintsError(invalidQuery); - return; - } - - MockSourceMap::iterator it = map.find(mockVideoSourceID()); - ASSERT(it != map.end()); - - RefPtr<MediaStreamSource> videoSource = it->value; - videoSource->reset(); - videoSource->setReadyState(MediaStreamSource::Live); - videoSources.append(videoSource.release()); - } - - client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources)); -} - -bool MockMediaStreamCenter::getMediaStreamTrackSources(PassRefPtr<MediaStreamTrackSourcesRequestClient> prpClient) -{ - RefPtr<MediaStreamTrackSourcesRequestClient> requestClient = prpClient; - Vector<RefPtr<TrackSourceInfo>> sources; - - MockSourceMap& map = mockSourceMap(); - MockSourceMap::iterator end = map.end(); - for (MockSourceMap::iterator it = map.begin(); it != end; ++it) { - MockSource* source = it->value.get(); - - sources.append(TrackSourceInfo::create(source->id(), source->type() == MediaStreamSource::Video ? TrackSourceInfo::Video : TrackSourceInfo::Audio, source->name())); - } - - requestClient->didCompleteRequest(sources); - return true; -} - -} // namespace WebCore - -#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MockRealtimeAudioSource.cpp b/Source/WebCore/platform/mock/MockRealtimeAudioSource.cpp new file mode 100644 index 000000000..53a60ebb8 --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeAudioSource.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Google Inc. nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MockRealtimeAudioSource.h" + +#if ENABLE(MEDIA_STREAM) +#include "Logging.h" +#include "MediaConstraints.h" +#include "NotImplemented.h" +#include "RealtimeMediaSourceSettings.h" +#include "UUID.h" + +namespace WebCore { + +#if !PLATFORM(MAC) && !PLATFORM(IOS) +RefPtr<MockRealtimeAudioSource> MockRealtimeAudioSource::create(const String& name, const MediaConstraints* constraints) +{ + auto source = adoptRef(new MockRealtimeAudioSource(name)); + if (constraints && source->applyConstraints(*constraints)) + source = nullptr; + + return source; +} + +RefPtr<MockRealtimeAudioSource> MockRealtimeAudioSource::createMuted(const String& name) +{ + auto source = adoptRef(new MockRealtimeAudioSource(name)); + source->m_muted = true; + return source; +} +#endif + +MockRealtimeAudioSource::MockRealtimeAudioSource(const String& name) + : MockRealtimeMediaSource(createCanonicalUUIDString(), RealtimeMediaSource::Audio, name) + , m_timer(RunLoop::current(), this, &MockRealtimeAudioSource::tick) +{ +} + +void MockRealtimeAudioSource::updateSettings(RealtimeMediaSourceSettings& settings) +{ + settings.setVolume(volume()); + settings.setEchoCancellation(echoCancellation()); + settings.setSampleRate(44100); +} + +void MockRealtimeAudioSource::initializeCapabilities(RealtimeMediaSourceCapabilities& capabilities) +{ + capabilities.setVolume(CapabilityValueOrRange(0.0, 1.0)); + capabilities.setEchoCancellation(RealtimeMediaSourceCapabilities::EchoCancellation::ReadWrite); + capabilities.setSampleRate(CapabilityValueOrRange(44100, 44100)); +} + +void MockRealtimeAudioSource::initializeSupportedConstraints(RealtimeMediaSourceSupportedConstraints& supportedConstraints) +{ + supportedConstraints.setSupportsVolume(true); + supportedConstraints.setSupportsEchoCancellation(true); + supportedConstraints.setSupportsSampleRate(true); +} + +void MockRealtimeAudioSource::startProducingData() +{ + MockRealtimeMediaSource::startProducingData(); + + m_startTime = monotonicallyIncreasingTime(); + m_timer.startRepeating(std::chrono::milliseconds(renderInterval())); +} + +void MockRealtimeAudioSource::stopProducingData() +{ + MockRealtimeMediaSource::stopProducingData(); + m_timer.stop(); + m_elapsedTime += monotonicallyIncreasingTime() - m_startTime; + m_startTime = NAN; +} + +double MockRealtimeAudioSource::elapsedTime() +{ + if (std::isnan(m_startTime)) + return m_elapsedTime; + + return m_elapsedTime + (monotonicallyIncreasingTime() - m_startTime); +} + +void MockRealtimeAudioSource::tick() +{ + if (std::isnan(m_lastRenderTime)) + m_lastRenderTime = monotonicallyIncreasingTime(); + + double now = monotonicallyIncreasingTime(); + double delta = now - m_lastRenderTime; + m_lastRenderTime = now; + render(delta); +} + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MockRealtimeAudioSource.h b/Source/WebCore/platform/mock/MockRealtimeAudioSource.h new file mode 100644 index 000000000..b7e000866 --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeAudioSource.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2015-2017 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#if ENABLE(MEDIA_STREAM) + +#include "FontCascade.h" +#include "ImageBuffer.h" +#include "MockRealtimeMediaSource.h" +#include <wtf/RunLoop.h> + +namespace WebCore { + +class MockRealtimeAudioSource : public MockRealtimeMediaSource { +public: + + static RefPtr<MockRealtimeAudioSource> create(const String&, const MediaConstraints*); + static RefPtr<MockRealtimeAudioSource> createMuted(const String& name); + + virtual ~MockRealtimeAudioSource() = default; + +protected: + MockRealtimeAudioSource(const String& name = ASCIILiteral("Mock audio device")); + + void startProducingData() final; + void stopProducingData() final; + + virtual void render(double) { } + + double elapsedTime(); + static int renderInterval() { return 60; } + +private: + + bool applyVolume(double) override { return true; } + bool applySampleRate(int) override { return true; } + bool applySampleSize(int) override { return true; } + bool applyEchoCancellation(bool) override { return true; } + + void updateSettings(RealtimeMediaSourceSettings&) override; + void initializeCapabilities(RealtimeMediaSourceCapabilities&) override; + void initializeSupportedConstraints(RealtimeMediaSourceSupportedConstraints&) override; + + void tick(); + + RunLoop::Timer<MockRealtimeAudioSource> m_timer; + double m_startTime { NAN }; + double m_lastRenderTime { NAN }; + double m_elapsedTime { 0 }; +}; + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MockRealtimeMediaSource.cpp b/Source/WebCore/platform/mock/MockRealtimeMediaSource.cpp new file mode 100644 index 000000000..2e03255a9 --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeMediaSource.cpp @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Google Inc. nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MockRealtimeMediaSource.h" + +#if ENABLE(MEDIA_STREAM) +#include "CaptureDevice.h" +#include "Logging.h" +#include "MediaConstraints.h" +#include "NotImplemented.h" +#include "RealtimeMediaSourceSettings.h" +#include <math.h> +#include <wtf/CurrentTime.h> +#include <wtf/NeverDestroyed.h> +#include <wtf/text/StringView.h> + +namespace WebCore { + +const AtomicString& MockRealtimeMediaSource::mockAudioSourcePersistentID() +{ + static NeverDestroyed<AtomicString> id("239c24b1-2b15-11e3-8224-0800200c9a66", AtomicString::ConstructFromLiteral); + return id; +} + +const AtomicString& MockRealtimeMediaSource::mockVideoSourcePersistentID() +{ + static NeverDestroyed<AtomicString> id("239c24b0-2b15-11e3-8224-0800200c9a66", AtomicString::ConstructFromLiteral); + return id; +} + +const AtomicString& MockRealtimeMediaSource::mockAudioSourceName() +{ + static NeverDestroyed<AtomicString> name("Mock audio device", AtomicString::ConstructFromLiteral); + return name; +} + +const AtomicString& MockRealtimeMediaSource::mockVideoSourceName() +{ + static NeverDestroyed<AtomicString> name("Mock video device", AtomicString::ConstructFromLiteral); + return name; +} + +CaptureDevice MockRealtimeMediaSource::audioDeviceInfo() +{ + static NeverDestroyed<CaptureDevice> deviceInfo(mockAudioSourcePersistentID(), CaptureDevice::DeviceType::Audio, mockAudioSourceName(), ""); + return deviceInfo; +} + +CaptureDevice MockRealtimeMediaSource::videoDeviceInfo() +{ + static NeverDestroyed<CaptureDevice> deviceInfo(mockVideoSourcePersistentID(), CaptureDevice::DeviceType::Video, mockVideoSourceName(), ""); + return deviceInfo; +} + + +MockRealtimeMediaSource::MockRealtimeMediaSource(const String& id, RealtimeMediaSource::Type type, const String& name) + : BaseRealtimeMediaSourceClass(id, type, name) +{ + if (type == RealtimeMediaSource::Audio) + setPersistentID(mockAudioSourcePersistentID()); + else + setPersistentID(mockVideoSourcePersistentID()); +} + +void MockRealtimeMediaSource::initializeCapabilities() +{ + m_capabilities = RealtimeMediaSourceCapabilities::create(supportedConstraints()); + m_capabilities->setDeviceId(id()); + initializeCapabilities(*m_capabilities.get()); +} + +RefPtr<RealtimeMediaSourceCapabilities> MockRealtimeMediaSource::capabilities() const +{ + if (!m_capabilities) + const_cast<MockRealtimeMediaSource&>(*this).initializeCapabilities(); + return m_capabilities; +} + +void MockRealtimeMediaSource::initializeSettings() +{ + if (m_currentSettings.deviceId().isEmpty()) { + m_currentSettings.setSupportedConstraits(supportedConstraints()); + m_currentSettings.setDeviceId(id()); + } + + updateSettings(m_currentSettings); +} + +const RealtimeMediaSourceSettings& MockRealtimeMediaSource::settings() const +{ + const_cast<MockRealtimeMediaSource&>(*this).initializeSettings(); + return m_currentSettings; +} + +RealtimeMediaSourceSupportedConstraints& MockRealtimeMediaSource::supportedConstraints() +{ + if (m_supportedConstraints.supportsDeviceId()) + return m_supportedConstraints; + + m_supportedConstraints.setSupportsDeviceId(true); + initializeSupportedConstraints(m_supportedConstraints); + + return m_supportedConstraints; +} + +void MockRealtimeMediaSource::startProducingData() +{ + m_isProducingData = true; + setMuted(false); +} + +void MockRealtimeMediaSource::stopProducingData() +{ + m_isProducingData = false; + setMuted(true); +} + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MockRealtimeMediaSource.h b/Source/WebCore/platform/mock/MockRealtimeMediaSource.h new file mode 100644 index 000000000..ddfda1e4e --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeMediaSource.h @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MockRealtimeMediaSource_h +#define MockRealtimeMediaSource_h + +#if ENABLE(MEDIA_STREAM) + +#include "RealtimeMediaSource.h" + +#if USE(OPENWEBRTC) +#include "RealtimeMediaSourceOwr.h" +#endif + +namespace WebCore { + +class CaptureDevice; + +#if USE(OPENWEBRTC) +using BaseRealtimeMediaSourceClass = RealtimeMediaSourceOwr; +#else +using BaseRealtimeMediaSourceClass = RealtimeMediaSource; +#endif + +class MockRealtimeMediaSource : public BaseRealtimeMediaSourceClass { +public: + virtual ~MockRealtimeMediaSource() { } + + static const AtomicString& mockAudioSourcePersistentID(); + static const AtomicString& mockAudioSourceName(); + + static const AtomicString& mockVideoSourcePersistentID(); + static const AtomicString& mockVideoSourceName(); + + static CaptureDevice audioDeviceInfo(); + static CaptureDevice videoDeviceInfo(); + +protected: + MockRealtimeMediaSource(const String& id, Type, const String& name); + + virtual void updateSettings(RealtimeMediaSourceSettings&) = 0; + virtual void initializeCapabilities(RealtimeMediaSourceCapabilities&) = 0; + virtual void initializeSupportedConstraints(RealtimeMediaSourceSupportedConstraints&) = 0; + + void startProducingData() override; + void stopProducingData() override; + + RefPtr<RealtimeMediaSourceCapabilities> capabilities() const override; + const RealtimeMediaSourceSettings& settings() const override; + + MediaConstraints& constraints() { return *m_constraints.get(); } + RealtimeMediaSourceSupportedConstraints& supportedConstraints(); + +private: + void initializeCapabilities(); + void initializeSettings(); + bool isProducingData() const override { return m_isProducingData; } + + RealtimeMediaSourceSettings m_currentSettings; + RealtimeMediaSourceSupportedConstraints m_supportedConstraints; + RefPtr<RealtimeMediaSourceCapabilities> m_capabilities; + RefPtr<MediaConstraints> m_constraints; + bool m_isProducingData { false }; +}; + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) + +#endif // MockRealtimeMediaSource_h diff --git a/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp b/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp new file mode 100644 index 000000000..bda24d5ea --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2013 Google Inc. All rights reserved. + * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MockRealtimeMediaSourceCenter.h" + +#if ENABLE(MEDIA_STREAM) + +#include "CaptureDevice.h" +#include "Logging.h" +#include "MediaStream.h" +#include "MediaStreamPrivate.h" +#include "MediaStreamTrack.h" +#include "MockRealtimeAudioSource.h" +#include "MockRealtimeMediaSource.h" +#include "MockRealtimeVideoSource.h" +#include "RealtimeMediaSource.h" +#include "RealtimeMediaSourceCapabilities.h" +#include "UUID.h" +#include <wtf/NeverDestroyed.h> + +namespace WebCore { + +void MockRealtimeMediaSourceCenter::setMockRealtimeMediaSourceCenterEnabled(bool enabled) +{ + static NeverDestroyed<MockRealtimeMediaSourceCenter> center; + static bool active = false; + if (active != enabled) { + active = enabled; + RealtimeMediaSourceCenter::setSharedStreamCenterOverride(enabled ? ¢er.get() : nullptr); + } +} + +MockRealtimeMediaSourceCenter::MockRealtimeMediaSourceCenter() +{ + m_supportedConstraints.setSupportsWidth(true); + m_supportedConstraints.setSupportsHeight(true); + m_supportedConstraints.setSupportsAspectRatio(true); + m_supportedConstraints.setSupportsFrameRate(true); + m_supportedConstraints.setSupportsFacingMode(true); + m_supportedConstraints.setSupportsVolume(true); + m_supportedConstraints.setSupportsDeviceId(true); +} + +void MockRealtimeMediaSourceCenter::validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, const MediaConstraints& audioConstraints, const MediaConstraints& videoConstraints) +{ + Vector<String> audioSourceIds; + Vector<String> videoSourceIds; + String invalidConstraint; + + if (audioConstraints.isValid()) { + auto audioSource = MockRealtimeAudioSource::create(MockRealtimeMediaSource::mockAudioSourceName(), nullptr); + if (!audioSource->supportsConstraints(audioConstraints, invalidConstraint)) { + if (invalidHandler) + invalidHandler(invalidConstraint); + return; + } + + audioSourceIds.append(MockRealtimeMediaSource::mockAudioSourcePersistentID()); + } + + if (videoConstraints.isValid()) { + auto videoSource = MockRealtimeVideoSource::create(MockRealtimeMediaSource::mockVideoSourceName(), nullptr); + if (!videoSource->supportsConstraints(videoConstraints, invalidConstraint)) { + if (invalidHandler) + invalidHandler(invalidConstraint); + return; + } + + + videoSourceIds.append(MockRealtimeMediaSource::mockVideoSourcePersistentID()); + } + + validHandler(WTFMove(audioSourceIds), WTFMove(videoSourceIds)); +} + +void MockRealtimeMediaSourceCenter::createMediaStream(NewMediaStreamHandler completionHandler, const String& audioDeviceID, const String& videoDeviceID, const MediaConstraints* audioConstraints, const MediaConstraints* videoConstraints) +{ + Vector<Ref<RealtimeMediaSource>> audioSources; + Vector<Ref<RealtimeMediaSource>> videoSources; + + if (audioDeviceID == MockRealtimeMediaSource::mockAudioSourcePersistentID()) { + auto source = MockRealtimeAudioSource::create(MockRealtimeMediaSource::mockAudioSourceName(), audioConstraints); + if (source) + audioSources.append(source.releaseNonNull()); + } + + if (videoDeviceID == MockRealtimeMediaSource::mockVideoSourcePersistentID()) { + auto source = MockRealtimeVideoSource::create(MockRealtimeMediaSource::mockVideoSourceName(), videoConstraints); + if (source) + videoSources.append(source.releaseNonNull()); + } + + if (videoSources.isEmpty() && audioSources.isEmpty()) + completionHandler(nullptr); + else + completionHandler(MediaStreamPrivate::create(audioSources, videoSources)); +} + +Vector<CaptureDevice> MockRealtimeMediaSourceCenter::getMediaStreamDevices() +{ + Vector<CaptureDevice> sources; + + sources.append(MockRealtimeMediaSource::audioDeviceInfo()); + sources.append(MockRealtimeMediaSource::videoDeviceInfo()); + + return sources; +} + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MockMediaStreamCenter.h b/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h index 741695d78..b5f76452a 100644 --- a/Source/WebCore/platform/mock/MockMediaStreamCenter.h +++ b/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h @@ -1,6 +1,6 @@ /* * Copyright (C) 2013 Google Inc. All rights reserved. - * Copyright (C) 2013 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2013 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -11,10 +11,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -24,29 +24,30 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MockMediaStreamCenter_h -#define MockMediaStreamCenter_h +#ifndef MockRealtimeMediaSourceCenter_h +#define MockRealtimeMediaSourceCenter_h #if ENABLE(MEDIA_STREAM) -#include "MediaStreamCenter.h" +#include "RealtimeMediaSourceCenter.h" namespace WebCore { -class MockMediaStreamCenter final : public MediaStreamCenter { +class MockRealtimeMediaSourceCenter final : public RealtimeMediaSourceCenter { public: - static void registerMockMediaStreamCenter(); - - virtual void validateRequestConstraints(PassRefPtr<MediaStreamCreationClient>, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints); - virtual void createMediaStream(PassRefPtr<MediaStreamCreationClient>, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints); - virtual bool getMediaStreamTrackSources(PassRefPtr<MediaStreamTrackSourcesRequestClient>) override; + WEBCORE_EXPORT static void setMockRealtimeMediaSourceCenterEnabled(bool); private: - MockMediaStreamCenter() { } + friend NeverDestroyed<MockRealtimeMediaSourceCenter>; + MockRealtimeMediaSourceCenter(); + + void validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, const MediaConstraints& audioConstraints, const MediaConstraints& videoConstraints) final; + Vector<CaptureDevice> getMediaStreamDevices() final; + void createMediaStream(NewMediaStreamHandler, const String& audioDeviceID, const String& videoDeviceID, const MediaConstraints* audioConstraints, const MediaConstraints* videoConstraints) final; }; } -#endif // MockMediaStreamCenter_h +#endif // MockRealtimeMediaSourceCenter_h #endif diff --git a/Source/WebCore/platform/mock/MockRealtimeVideoSource.cpp b/Source/WebCore/platform/mock/MockRealtimeVideoSource.cpp new file mode 100644 index 000000000..da39e4ef9 --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeVideoSource.cpp @@ -0,0 +1,382 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Google Inc. nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MockRealtimeVideoSource.h" + +#if ENABLE(MEDIA_STREAM) +#include "GraphicsContext.h" +#include "ImageBuffer.h" +#include "IntRect.h" +#include "Logging.h" +#include "MediaConstraints.h" +#include "NotImplemented.h" +#include "PlatformLayer.h" +#include "RealtimeMediaSourceSettings.h" +#include "UUID.h" +#include <math.h> +#include <wtf/CurrentTime.h> +#include <wtf/text/StringView.h> + +namespace WebCore { + +#if !PLATFORM(MAC) && !PLATFORM(IOS) +RefPtr<MockRealtimeVideoSource> MockRealtimeVideoSource::create(const String& name, const MediaConstraints* constraints) +{ + auto source = adoptRef(new MockRealtimeVideoSource(name)); + if (constraints && source->applyConstraints(*constraints)) + source = nullptr; + + return source; +} + +RefPtr<MockRealtimeVideoSource> MockRealtimeVideoSource::createMuted(const String& name) +{ + auto source = adoptRef(new MockRealtimeVideoSource(name)); + source->m_muted = true; + return source; +} +#endif + +MockRealtimeVideoSource::MockRealtimeVideoSource(const String& name) + : MockRealtimeMediaSource(createCanonicalUUIDString(), RealtimeMediaSource::Video, name) + , m_timer(RunLoop::current(), this, &MockRealtimeVideoSource::generateFrame) +{ + setFrameRate(30); + m_dashWidths.reserveInitialCapacity(2); + m_dashWidths.uncheckedAppend(6); + m_dashWidths.uncheckedAppend(6); +} + +void MockRealtimeVideoSource::startProducingData() +{ + MockRealtimeMediaSource::startProducingData(); + if (size().isEmpty()) { + setWidth(640); + setHeight(480); + } + + m_startTime = monotonicallyIncreasingTime(); + m_timer.startRepeating(std::chrono::milliseconds(lround(1000 / frameRate()))); +} + +void MockRealtimeVideoSource::stopProducingData() +{ + MockRealtimeMediaSource::stopProducingData(); + m_timer.stop(); + m_elapsedTime += monotonicallyIncreasingTime() - m_startTime; + m_startTime = NAN; +} + +double MockRealtimeVideoSource::elapsedTime() +{ + if (std::isnan(m_startTime)) + return m_elapsedTime; + + return m_elapsedTime + (monotonicallyIncreasingTime() - m_startTime); +} + +void MockRealtimeVideoSource::updateSettings(RealtimeMediaSourceSettings& settings) +{ + settings.setFacingMode(facingMode()); + settings.setFrameRate(frameRate()); + IntSize size = this->size(); + settings.setWidth(size.width()); + settings.setHeight(size.height()); + if (aspectRatio()) + settings.setAspectRatio(aspectRatio()); +} + +void MockRealtimeVideoSource::initializeCapabilities(RealtimeMediaSourceCapabilities& capabilities) +{ + capabilities.addFacingMode(RealtimeMediaSourceSettings::User); + capabilities.addFacingMode(RealtimeMediaSourceSettings::Environment); + capabilities.setWidth(CapabilityValueOrRange(320, 1920)); + capabilities.setHeight(CapabilityValueOrRange(240, 1080)); + capabilities.setFrameRate(CapabilityValueOrRange(15.0, 60.0)); + capabilities.setAspectRatio(CapabilityValueOrRange(4 / 3.0, 16 / 9.0)); +} + +void MockRealtimeVideoSource::initializeSupportedConstraints(RealtimeMediaSourceSupportedConstraints& supportedConstraints) +{ + supportedConstraints.setSupportsWidth(true); + supportedConstraints.setSupportsHeight(true); + supportedConstraints.setSupportsAspectRatio(true); + supportedConstraints.setSupportsFrameRate(true); + supportedConstraints.setSupportsFacingMode(true); +} + +bool MockRealtimeVideoSource::applyFrameRate(double rate) +{ + if (m_timer.isActive()) + m_timer.startRepeating(std::chrono::milliseconds(lround(1000 / rate))); + + updateSampleBuffer(); + return true; +} + +bool MockRealtimeVideoSource::applySize(const IntSize& size) +{ + m_baseFontSize = size.height() * .08; + FontCascadeDescription fontDescription; + fontDescription.setOneFamily("Courier"); + fontDescription.setSpecifiedSize(m_baseFontSize); + fontDescription.setComputedSize(m_baseFontSize); + fontDescription.setWeight(FontWeight500); + + m_timeFont = FontCascade(fontDescription, 0, 0); + m_timeFont.update(nullptr); + + m_bipBopFontSize = m_baseFontSize * 2.5; + fontDescription.setSpecifiedSize(m_bipBopFontSize); + fontDescription.setComputedSize(m_bipBopFontSize); + m_bipBopFont = FontCascade(fontDescription, 0, 0); + m_bipBopFont.update(nullptr); + + m_statsFontSize = m_baseFontSize * .5; + fontDescription.setSpecifiedSize(m_statsFontSize); + fontDescription.setComputedSize(m_statsFontSize); + m_statsFont = FontCascade(fontDescription, 0, 0); + m_statsFont.update(nullptr); + + m_imageBuffer = nullptr; + + return true; +} + +void MockRealtimeVideoSource::drawAnimation(GraphicsContext& context) +{ + float radius = size().width() * .09; + FloatPoint location(size().width() * .8, size().height() * .3); + + m_path.clear(); + m_path.moveTo(location); + m_path.addArc(location, radius, 0, 2 * piFloat, false); + m_path.closeSubpath(); + context.setFillColor(Color::white); + context.setFillRule(RULE_NONZERO); + context.fillPath(m_path); + + float endAngle = piFloat * (((fmod(m_frameNumber, frameRate()) + 0.5) * (2.0 / frameRate())) + 1); + m_path.clear(); + m_path.moveTo(location); + m_path.addArc(location, radius, 1.5 * piFloat, endAngle, false); + m_path.closeSubpath(); + context.setFillColor(Color::gray); + context.setFillRule(RULE_NONZERO); + context.fillPath(m_path); +} + +void MockRealtimeVideoSource::drawBoxes(GraphicsContext& context) +{ + static const RGBA32 magenta = 0xffff00ff; + static const RGBA32 yellow = 0xffffff00; + static const RGBA32 blue = 0xff0000ff; + static const RGBA32 red = 0xffff0000; + static const RGBA32 green = 0xff008000; + static const RGBA32 cyan = 0xFF00FFFF; + + IntSize size = this->size(); + float boxSize = size.width() * .035; + float boxTop = size.height() * .6; + + m_path.clear(); + FloatRect frameRect(2, 2, size.width() - 3, size.height() - 3); + context.setStrokeColor(Color::white); + context.setStrokeThickness(3); + context.setLineDash(m_dashWidths, 0); + m_path.addRect(frameRect); + m_path.closeSubpath(); + context.strokePath(m_path); + + context.setLineDash(DashArray(), 0); + m_path.clear(); + m_path.moveTo(FloatPoint(0, boxTop + boxSize)); + m_path.addLineTo(FloatPoint(size.width(), boxTop + boxSize)); + m_path.closeSubpath(); + context.setStrokeColor(Color::white); + context.setStrokeThickness(2); + context.strokePath(m_path); + + context.setStrokeThickness(1); + float boxLeft = boxSize; + m_path.clear(); + for (unsigned i = 0; i < boxSize / 4; i++) { + m_path.moveTo(FloatPoint(boxLeft + 4 * i, boxTop)); + m_path.addLineTo(FloatPoint(boxLeft + 4 * i, boxTop + boxSize)); + } + boxLeft += boxSize + 2; + for (unsigned i = 0; i < boxSize / 4; i++) { + m_path.moveTo(FloatPoint(boxLeft, boxTop + 4 * i)); + m_path.addLineTo(FloatPoint(boxLeft + boxSize - 1, boxTop + 4 * i)); + } + context.setStrokeThickness(3); + boxLeft += boxSize + 2; + for (unsigned i = 0; i < boxSize / 8; i++) { + m_path.moveTo(FloatPoint(boxLeft + 8 * i, boxTop)); + m_path.addLineTo(FloatPoint(boxLeft + 8 * i, boxTop + boxSize - 1)); + } + boxLeft += boxSize + 2; + for (unsigned i = 0; i < boxSize / 8; i++) { + m_path.moveTo(FloatPoint(boxLeft, boxTop + 8 * i)); + m_path.addLineTo(FloatPoint(boxLeft + boxSize - 1, boxTop + 8 * i)); + } + + boxTop += boxSize + 2; + boxLeft = boxSize; + Color boxColors[] = { Color::white, yellow, cyan, green, magenta, red, blue }; + for (unsigned i = 0; i < sizeof(boxColors) / sizeof(boxColors[0]); i++) { + context.fillRect(FloatRect(boxLeft, boxTop, boxSize + 1, boxSize + 1), boxColors[i]); + boxLeft += boxSize + 1; + } + context.strokePath(m_path); +} + +void MockRealtimeVideoSource::drawText(GraphicsContext& context) +{ + unsigned milliseconds = lround(elapsedTime() * 1000); + unsigned seconds = milliseconds / 1000 % 60; + unsigned minutes = seconds / 60 % 60; + unsigned hours = minutes / 60 % 60; + + IntSize size = this->size(); + FloatPoint timeLocation(size.width() * .05, size.height() * .15); + context.setFillColor(Color::white); + context.setTextDrawingMode(TextModeFill); + String string = String::format("%02u:%02u:%02u.%03u", hours, minutes, seconds, milliseconds % 1000); + context.drawText(m_timeFont, TextRun((StringView(string))), timeLocation); + + string = String::format("%06u", m_frameNumber++); + timeLocation.move(0, m_baseFontSize); + context.drawText(m_timeFont, TextRun((StringView(string))), timeLocation); + + FloatPoint statsLocation(size.width() * .65, size.height() * .75); + string = String::format("Frame rate: %ffps", frameRate()); + context.drawText(m_statsFont, TextRun((StringView(string))), statsLocation); + + string = String::format("Size: %u x %u", size.width(), size.height()); + statsLocation.move(0, m_statsFontSize); + context.drawText(m_statsFont, TextRun((StringView(string))), statsLocation); + + const char* camera; + switch (facingMode()) { + case RealtimeMediaSourceSettings::User: + camera = "User facing"; + break; + case RealtimeMediaSourceSettings::Environment: + camera = "Environment facing"; + break; + case RealtimeMediaSourceSettings::Left: + camera = "Left facing"; + break; + case RealtimeMediaSourceSettings::Right: + camera = "Right facing"; + break; + case RealtimeMediaSourceSettings::Unknown: + camera = "Unknown"; + break; + } + string = String::format("Camera: %s", camera); + statsLocation.move(0, m_statsFontSize); + context.drawText(m_statsFont, TextRun((StringView(string))), statsLocation); + + FloatPoint bipBopLocation(size.width() * .6, size.height() * .6); + unsigned frameMod = m_frameNumber % 60; + if (frameMod <= 15) { + context.setFillColor(Color::gray); + String bip(ASCIILiteral("Bip")); + context.drawText(m_bipBopFont, TextRun(StringView(bip)), bipBopLocation); + } else if (frameMod > 30 && frameMod <= 45) { + context.setFillColor(Color::white); + String bop(ASCIILiteral("Bop")); + context.drawText(m_bipBopFont, TextRun(StringView(bop)), bipBopLocation); + } +} + +void MockRealtimeVideoSource::generateFrame() +{ + ImageBuffer* buffer = imageBuffer(); + if (!buffer) + return; + + GraphicsContext& context = buffer->context(); + GraphicsContextStateSaver stateSaver(context); + + IntSize size = this->size(); + FloatRect frameRect(FloatPoint(), size); + context.fillRect(FloatRect(FloatPoint(), size), Color::black); + + if (!m_muted && m_enabled) { + drawText(context); + drawAnimation(context); + drawBoxes(context); + } + + updateSampleBuffer(); +} + +ImageBuffer* MockRealtimeVideoSource::imageBuffer() const +{ + if (m_imageBuffer) + return m_imageBuffer.get(); + + m_imageBuffer = ImageBuffer::create(size(), Unaccelerated); + if (!m_imageBuffer) + return nullptr; + + m_imageBuffer->context().setImageInterpolationQuality(InterpolationDefault); + m_imageBuffer->context().setStrokeThickness(1); + + return m_imageBuffer.get(); +} + +void MockRealtimeVideoSource::paintCurrentFrameInContext(GraphicsContext& context, const FloatRect& rect) +{ + if (context.paintingDisabled() || !imageBuffer()) + return; + + GraphicsContextStateSaver stateSaver(context); + context.setImageInterpolationQuality(InterpolationLow); + IntRect paintRect(IntPoint(0, 0), IntSize(rect.width(), rect.height())); + + context.drawImage(*m_imageBuffer->copyImage(DontCopyBackingStore), rect); +} + +RefPtr<Image> MockRealtimeVideoSource::currentFrameImage() +{ + if (!imageBuffer()) + return nullptr; + + return m_imageBuffer->copyImage(DontCopyBackingStore); +} + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/MockRealtimeVideoSource.h b/Source/WebCore/platform/mock/MockRealtimeVideoSource.h new file mode 100644 index 000000000..78d8f8f26 --- /dev/null +++ b/Source/WebCore/platform/mock/MockRealtimeVideoSource.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MockRealtimeVideoSource_h +#define MockRealtimeVideoSource_h + +#if ENABLE(MEDIA_STREAM) + +#include "FontCascade.h" +#include "ImageBuffer.h" +#include "MockRealtimeMediaSource.h" +#include <wtf/RunLoop.h> + +namespace WebCore { + +class FloatRect; +class GraphicsContext; + +class MockRealtimeVideoSource : public MockRealtimeMediaSource { +public: + + static RefPtr<MockRealtimeVideoSource> create(const String&, const MediaConstraints*); + static RefPtr<MockRealtimeVideoSource> createMuted(const String& name); + + virtual ~MockRealtimeVideoSource() { } + +protected: + MockRealtimeVideoSource(const String&); + virtual void updateSampleBuffer() { } + + ImageBuffer* imageBuffer() const; + + double elapsedTime(); + +private: + void updateSettings(RealtimeMediaSourceSettings&) override; + void initializeCapabilities(RealtimeMediaSourceCapabilities&) override; + void initializeSupportedConstraints(RealtimeMediaSourceSupportedConstraints&) override; + + void startProducingData() final; + void stopProducingData() final; + + void drawAnimation(GraphicsContext&); + void drawText(GraphicsContext&); + void drawBoxes(GraphicsContext&); + + bool applySize(const IntSize&) override; + bool applyFrameRate(double) override; + bool applyFacingMode(RealtimeMediaSourceSettings::VideoFacingMode) override { return true; } + bool applyAspectRatio(double) override { return true; } + + RefPtr<Image> currentFrameImage() override; + void paintCurrentFrameInContext(GraphicsContext&, const FloatRect&) override; + + void generateFrame(); + + float m_baseFontSize { 0 }; + FontCascade m_timeFont; + + float m_bipBopFontSize { 0 }; + FontCascade m_bipBopFont; + + float m_statsFontSize { 0 }; + FontCascade m_statsFont; + + mutable std::unique_ptr<ImageBuffer> m_imageBuffer; + + Path m_path; + DashArray m_dashWidths; + + double m_startTime { NAN }; + double m_elapsedTime { 0 }; + + unsigned m_frameNumber { 0 }; + + RunLoop::Timer<MockRealtimeVideoSource> m_timer; +}; + +} // namespace WebCore + +#endif // ENABLE(MEDIA_STREAM) + +#endif // MockRealtimeVideoSource_h diff --git a/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp new file mode 100644 index 000000000..f3bc71c0f --- /dev/null +++ b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2013 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "PlatformSpeechSynthesizerMock.h" +#include "PlatformSpeechSynthesisUtterance.h" + +#if ENABLE(SPEECH_SYNTHESIS) + +namespace WebCore { + +PlatformSpeechSynthesizerMock::PlatformSpeechSynthesizerMock(PlatformSpeechSynthesizerClient* client) + : PlatformSpeechSynthesizer(client) + , m_speakingFinishedTimer(*this, &PlatformSpeechSynthesizerMock::speakingFinished) +{ +} + +PlatformSpeechSynthesizerMock::~PlatformSpeechSynthesizerMock() +{ +} + +void PlatformSpeechSynthesizerMock::speakingFinished() +{ + ASSERT(m_utterance.get()); + RefPtr<PlatformSpeechSynthesisUtterance> protect(m_utterance); + m_utterance = nullptr; + + client()->didFinishSpeaking(*protect); +} + +void PlatformSpeechSynthesizerMock::initializeVoiceList() +{ + m_voiceList.append(PlatformSpeechSynthesisVoice::create(String("mock.voice.bruce"), String("bruce"), String("en-US"), true, true)); + m_voiceList.append(PlatformSpeechSynthesisVoice::create(String("mock.voice.clark"), String("clark"), String("en-US"), true, false)); + m_voiceList.append(PlatformSpeechSynthesisVoice::create(String("mock.voice.logan"), String("logan"), String("fr-CA"), true, true)); +} + +void PlatformSpeechSynthesizerMock::speak(RefPtr<PlatformSpeechSynthesisUtterance>&& utterance) +{ + ASSERT(!m_utterance); + m_utterance = WTFMove(utterance); + client()->didStartSpeaking(*m_utterance); + + // Fire a fake word and then sentence boundary event. + client()->boundaryEventOccurred(*m_utterance, SpeechWordBoundary, 0); + client()->boundaryEventOccurred(*m_utterance, SpeechSentenceBoundary, m_utterance->text().length()); + + // Give the fake speech job some time so that pause and other functions have time to be called. + m_speakingFinishedTimer.startOneShot(.1); +} + +void PlatformSpeechSynthesizerMock::cancel() +{ + if (!m_utterance) + return; + + m_speakingFinishedTimer.stop(); + client()->speakingErrorOccurred(*m_utterance); + m_utterance = nullptr; +} + +void PlatformSpeechSynthesizerMock::pause() +{ + client()->didPauseSpeaking(*m_utterance); +} + +void PlatformSpeechSynthesizerMock::resume() +{ + client()->didResumeSpeaking(*m_utterance); +} + +} // namespace WebCore + +#endif // ENABLE(SPEECH_SYNTHESIS) diff --git a/Source/WebCore/platform/mock/mediasource/MockTracks.cpp b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h index 8f8840d84..9921fbd4a 100644 --- a/Source/WebCore/platform/mock/mediasource/MockTracks.cpp +++ b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -10,18 +10,49 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "config.h" -#include "MockTracks.h" +#ifndef PlatformSpeechSynthesizerMock_h +#define PlatformSpeechSynthesizerMock_h + +#if ENABLE(SPEECH_SYNTHESIS) + +#include "PlatformSpeechSynthesizer.h" +#include "Timer.h" + +namespace WebCore { + +class PlatformSpeechSynthesizerMock : public PlatformSpeechSynthesizer { +public: + explicit PlatformSpeechSynthesizerMock(PlatformSpeechSynthesizerClient*); + + virtual ~PlatformSpeechSynthesizerMock(); + virtual void speak(RefPtr<PlatformSpeechSynthesisUtterance>&&); + virtual void pause(); + virtual void resume(); + virtual void cancel(); + +private: + virtual void initializeVoiceList(); + void speakingFinished(); + + Timer m_speakingFinishedTimer; + RefPtr<PlatformSpeechSynthesisUtterance> m_utterance; +}; + +} // namespace WebCore + +#endif // ENABLE(SPEECH_SYNTHESIS) + +#endif // PlatformSpeechSynthesizer_h diff --git a/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.cpp b/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.cpp index d1c522527..8985e5c9f 100644 --- a/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.cpp +++ b/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.cpp @@ -25,7 +25,7 @@ #include "config.h" -#if ENABLE(MEDIA_STREAM) +#if ENABLE(WEB_RTC) #include "RTCDataChannelHandlerMock.h" @@ -37,11 +37,6 @@ namespace WebCore { RTCDataChannelHandlerMock::RTCDataChannelHandlerMock(const String& label, const RTCDataChannelInit& init) : m_label(label) , m_protocol(init.protocol) - , m_maxRetransmitTime(init.maxRetransmitTime) - , m_maxRetransmits(init.maxRetransmits) - , m_id(init.id) - , m_ordered(init.ordered) - , m_negotiated(init.negotiated) { } @@ -75,4 +70,4 @@ void RTCDataChannelHandlerMock::close() } // namespace WebCore -#endif // ENABLE(MEDIA_STREAM) +#endif // ENABLE(WEB_RTC) diff --git a/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.h b/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.h index 0f02ff2ed..9303487e6 100644 --- a/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.h +++ b/Source/WebCore/platform/mock/RTCDataChannelHandlerMock.h @@ -23,13 +23,11 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef RTCDataChannelHandlerMock_h -#define RTCDataChannelHandlerMock_h +#pragma once -#if ENABLE(MEDIA_STREAM) +#if ENABLE(WEB_RTC) #include "RTCDataChannelHandler.h" -#include "RTCPeerConnectionHandler.h" #include "TimerEventBasedMock.h" namespace WebCore { @@ -37,37 +35,21 @@ namespace WebCore { class RTCDataChannelHandlerMock final : public RTCDataChannelHandler, public TimerEventBasedMock { public: RTCDataChannelHandlerMock(const String&, const RTCDataChannelInit&); - virtual ~RTCDataChannelHandlerMock() { } - virtual void setClient(RTCDataChannelHandlerClient*) override; - - virtual String label() override { return m_label; } - virtual bool ordered() override { return m_ordered; } - virtual unsigned short maxRetransmitTime() override { return m_maxRetransmitTime; } - virtual unsigned short maxRetransmits() override { return m_maxRetransmits; } - virtual String protocol() override { return m_protocol; } - virtual bool negotiated() override { return m_negotiated; } - virtual unsigned short id() override { return m_id; } - virtual unsigned long bufferedAmount() override { return 0; } +private: + void setClient(RTCDataChannelHandlerClient*) final; - virtual bool sendStringData(const String&) override; - virtual bool sendRawData(const char*, size_t) override; - virtual void close() override; + bool sendStringData(const String&) final; + bool sendRawData(const char*, size_t) final; + void close() final; + size_t bufferedAmount() const final { return 0; } -private: RTCDataChannelHandlerClient* m_client; String m_label; String m_protocol; - unsigned short m_maxRetransmitTime; - unsigned short m_maxRetransmits; - unsigned short m_id; - bool m_ordered; - bool m_negotiated; }; } // namespace WebCore -#endif // ENABLE(MEDIA_STREAM) - -#endif // RTCDataChannelHandlerMock_h +#endif // ENABLE(WEB_RTC) diff --git a/Source/WebCore/platform/mock/RTCNotifiersMock.cpp b/Source/WebCore/platform/mock/RTCNotifiersMock.cpp index 09a215676..d667d174b 100644 --- a/Source/WebCore/platform/mock/RTCNotifiersMock.cpp +++ b/Source/WebCore/platform/mock/RTCNotifiersMock.cpp @@ -25,7 +25,7 @@ #include "config.h" -#if ENABLE(MEDIA_STREAM) +#if ENABLE(WEB_RTC) #include "RTCNotifiersMock.h" @@ -114,4 +114,4 @@ void DataChannelStateNotifier::fire() } // namespace WebCore -#endif // ENABLE(MEDIA_STREAM) +#endif // ENABLE(WEB_RTC) diff --git a/Source/WebCore/platform/mock/RTCNotifiersMock.h b/Source/WebCore/platform/mock/RTCNotifiersMock.h index 014dfb58d..f3351d99e 100644 --- a/Source/WebCore/platform/mock/RTCNotifiersMock.h +++ b/Source/WebCore/platform/mock/RTCNotifiersMock.h @@ -26,7 +26,7 @@ #ifndef RTCNotifiersMock_h #define RTCNotifiersMock_h -#if ENABLE(MEDIA_STREAM) +#if ENABLE(WEB_RTC) #include "RTCDataChannelHandlerClient.h" #include "RTCPeerConnectionHandlerClient.h" @@ -111,6 +111,6 @@ private: } // namespace WebCore -#endif // ENABLE(MEDIA_STREAM) +#endif // ENABLE(WEB_RTC) #endif // RTCNotifiersMock_h diff --git a/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.cpp b/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.cpp deleted file mode 100644 index cae318625..000000000 --- a/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.cpp +++ /dev/null @@ -1,203 +0,0 @@ -/* - * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "config.h" - -#if ENABLE(MEDIA_STREAM) - -#include "RTCPeerConnectionHandlerMock.h" - -#include "MediaConstraintsMock.h" -#include "NotImplemented.h" -#include "RTCDTMFSenderHandler.h" -#include "RTCDataChannelHandler.h" -#include "RTCDataChannelHandlerMock.h" -#include "RTCNotifiersMock.h" -#include "RTCSessionDescriptionRequest.h" -#include "RTCVoidRequest.h" -#include <wtf/text/CString.h> - -namespace WebCore { - -std::unique_ptr<RTCPeerConnectionHandler> RTCPeerConnectionHandlerMock::create(RTCPeerConnectionHandlerClient* client) -{ - return std::make_unique<RTCPeerConnectionHandlerMock>(client); -} - -RTCPeerConnectionHandlerMock::RTCPeerConnectionHandlerMock(RTCPeerConnectionHandlerClient* client) - : m_client(client) -{ -} - -bool RTCPeerConnectionHandlerMock::initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints> constraints) -{ - String invalidQuery = MediaConstraintsMock::verifyConstraints(constraints); - if (!invalidQuery.isEmpty()) - return false; - - RefPtr<IceConnectionNotifier> notifier = adoptRef(new IceConnectionNotifier(m_client, RTCPeerConnectionHandlerClient::IceConnectionStateCompleted, RTCPeerConnectionHandlerClient::IceGatheringStateComplete)); - m_timerEvents.append(adoptRef(new TimerEvent(this, notifier))); - return true; -} - -void RTCPeerConnectionHandlerMock::createOffer(PassRefPtr<RTCSessionDescriptionRequest> request, PassRefPtr<MediaConstraints> constraints) -{ - String succeedValue; - RefPtr<SessionRequestNotifier> notifier; - if (constraints->getMandatoryConstraintValue("succeed", succeedValue) && succeedValue == "false") - notifier = adoptRef(new SessionRequestNotifier(request, 0, RTCPeerConnectionHandler::incompatibleConstraintsErrorName())); - else - notifier = adoptRef(new SessionRequestNotifier(request, RTCSessionDescriptionDescriptor::create("offer", "local"))); - - m_timerEvents.append(adoptRef(new TimerEvent(this, notifier))); -} - -void RTCPeerConnectionHandlerMock::createAnswer(PassRefPtr<RTCSessionDescriptionRequest> request, PassRefPtr<MediaConstraints> constraints) -{ - RefPtr<SessionRequestNotifier> notifier; - // We can only create an answer if we have already had an offer and the remote session description is stored. - String succeedValue; - if (constraints->getMandatoryConstraintValue("succeed", succeedValue) && succeedValue == "false") - notifier = adoptRef(new SessionRequestNotifier(request, 0, RTCPeerConnectionHandler::incompatibleConstraintsErrorName())); - else - notifier = adoptRef(new SessionRequestNotifier(request, RTCSessionDescriptionDescriptor::create("answer", "local"))); - - m_timerEvents.append(adoptRef(new TimerEvent(this, notifier))); -} - -RTCPeerConnectionHandlerClient::SignalingState RTCPeerConnectionHandlerMock::signalingStateFromSDP(RTCSessionDescriptionDescriptor* descriptor) -{ - if (descriptor->type() == "offer" && descriptor->sdp() == "local") - return RTCPeerConnectionHandlerClient::SignalingStateHaveLocalOffer; - if (descriptor->type() == "offer" && descriptor->sdp() == "remote") - return RTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer; - if (descriptor->type() == "pranswer" && descriptor->sdp() == "local") - return RTCPeerConnectionHandlerClient::SignalingStateHaveLocalPrAnswer; - if (descriptor->type() == "pranswer" && descriptor->sdp() == "remote") - return RTCPeerConnectionHandlerClient::SignalingStateHaveRemotePrAnswer; - - return RTCPeerConnectionHandlerClient::SignalingStateStable; -} - -void RTCPeerConnectionHandlerMock::setLocalDescription(PassRefPtr<RTCVoidRequest> request, PassRefPtr<RTCSessionDescriptionDescriptor> descriptor) -{ - RefPtr<VoidRequestNotifier> voidNotifier; - RefPtr<SignalingStateNotifier> signalingNotifier; - if (!descriptor.get() || descriptor->sdp() != "local") - voidNotifier = adoptRef(new VoidRequestNotifier(request, false, RTCPeerConnectionHandler::internalErrorName())); - else { - m_localSessionDescription = descriptor; - signalingNotifier = adoptRef(new SignalingStateNotifier(m_client, signalingStateFromSDP(m_localSessionDescription.get()))); - voidNotifier = adoptRef(new VoidRequestNotifier(request, true)); - m_timerEvents.append(adoptRef(new TimerEvent(this, signalingNotifier))); - } - - m_timerEvents.append(adoptRef(new TimerEvent(this, voidNotifier))); -} - -void RTCPeerConnectionHandlerMock::setRemoteDescription(PassRefPtr<RTCVoidRequest> request, PassRefPtr<RTCSessionDescriptionDescriptor> descriptor) -{ - RefPtr<VoidRequestNotifier> voidNotifier; - RefPtr<SignalingStateNotifier> signalingNotifier; - if (!descriptor.get() || descriptor->sdp() != "remote") - voidNotifier = adoptRef(new VoidRequestNotifier(request, false, RTCPeerConnectionHandler::internalErrorName())); - else { - m_remoteSessionDescription = descriptor; - signalingNotifier = adoptRef(new SignalingStateNotifier(m_client, signalingStateFromSDP(m_remoteSessionDescription.get()))); - voidNotifier = adoptRef(new VoidRequestNotifier(request, true)); - m_timerEvents.append(adoptRef(new TimerEvent(this, signalingNotifier))); - } - - m_timerEvents.append(adoptRef(new TimerEvent(this, voidNotifier))); -} - -PassRefPtr<RTCSessionDescriptionDescriptor> RTCPeerConnectionHandlerMock::localDescription() -{ - return m_localSessionDescription; -} - -PassRefPtr<RTCSessionDescriptionDescriptor> RTCPeerConnectionHandlerMock::remoteDescription() -{ - return m_remoteSessionDescription; -} - -bool RTCPeerConnectionHandlerMock::updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) -{ - return true; -} - -bool RTCPeerConnectionHandlerMock::addIceCandidate(PassRefPtr<RTCVoidRequest> request, PassRefPtr<RTCIceCandidateDescriptor>) -{ - RefPtr<VoidRequestNotifier> notifier = adoptRef(new VoidRequestNotifier(request, true)); - m_timerEvents.append(adoptRef(new TimerEvent(this, notifier))); - return true; -} - -bool RTCPeerConnectionHandlerMock::addStream(PassRefPtr<MediaStreamPrivate>, PassRefPtr<MediaConstraints> constraints) -{ - String invalidQuery = MediaConstraintsMock::verifyConstraints(constraints); - if (!invalidQuery.isEmpty()) - return false; - - // Spec states that every time a stream is added, a negotiationneeded event must be fired. - m_client->negotiationNeeded(); - return true; -} - -void RTCPeerConnectionHandlerMock::removeStream(PassRefPtr<MediaStreamPrivate>) -{ - // Spec states that every time a stream is removed, a negotiationneeded event must be fired. - m_client->negotiationNeeded(); -} - -void RTCPeerConnectionHandlerMock::getStats(PassRefPtr<RTCStatsRequest>) -{ - // Current tests does not support getUserMedia and this function requires it. - // Once WebKit has test support to getUserMedia, this must be fixed. - notImplemented(); -} - -std::unique_ptr<RTCDataChannelHandler> RTCPeerConnectionHandlerMock::createDataChannel(const String& label, const RTCDataChannelInit& init) -{ - RefPtr<RemoteDataChannelNotifier> notifier = adoptRef(new RemoteDataChannelNotifier(m_client)); - m_timerEvents.append(adoptRef(new TimerEvent(this, notifier))); - return std::make_unique<RTCDataChannelHandlerMock>(label, init); -} - -std::unique_ptr<RTCDTMFSenderHandler> RTCPeerConnectionHandlerMock::createDTMFSender(PassRefPtr<MediaStreamSource>) -{ - // Requires a mock implementation of RTCDTMFSenderHandler. - // This must be implemented once the mock implementation of RTCDataChannelHandler is ready. - notImplemented(); - return nullptr; -} - -void RTCPeerConnectionHandlerMock::stop() -{ -} - -} // namespace WebCore - -#endif // ENABLE(MEDIA_STREAM) diff --git a/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.h b/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.h deleted file mode 100644 index 4de3539b4..000000000 --- a/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef RTCPeerConnectionHandlerMock_h -#define RTCPeerConnectionHandlerMock_h - -#if ENABLE(MEDIA_STREAM) - -#include "RTCPeerConnectionHandler.h" -#include "RTCPeerConnectionHandlerClient.h" -#include "RTCSessionDescriptionDescriptor.h" -#include "TimerEventBasedMock.h" - -namespace WebCore { - -class RTCPeerConnectionHandlerMock final : public RTCPeerConnectionHandler, public TimerEventBasedMock { -public: - static std::unique_ptr<RTCPeerConnectionHandler> create(RTCPeerConnectionHandlerClient*); - - virtual ~RTCPeerConnectionHandlerMock() { } - - virtual bool initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) override; - - virtual void createOffer(PassRefPtr<RTCSessionDescriptionRequest>, PassRefPtr<MediaConstraints>) override; - virtual void createAnswer(PassRefPtr<RTCSessionDescriptionRequest>, PassRefPtr<MediaConstraints>) override; - virtual void setLocalDescription(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCSessionDescriptionDescriptor>) override; - virtual void setRemoteDescription(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCSessionDescriptionDescriptor>) override; - virtual PassRefPtr<RTCSessionDescriptionDescriptor> localDescription() override; - virtual PassRefPtr<RTCSessionDescriptionDescriptor> remoteDescription() override; - virtual bool updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) override; - virtual bool addIceCandidate(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCIceCandidateDescriptor>) override; - virtual bool addStream(PassRefPtr<MediaStreamPrivate>, PassRefPtr<MediaConstraints>) override; - virtual void removeStream(PassRefPtr<MediaStreamPrivate>) override; - virtual void getStats(PassRefPtr<RTCStatsRequest>) override; - virtual std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String& label, const RTCDataChannelInit&) override; - virtual std::unique_ptr<RTCDTMFSenderHandler> createDTMFSender(PassRefPtr<MediaStreamSource>) override; - virtual void stop() override; - - explicit RTCPeerConnectionHandlerMock(RTCPeerConnectionHandlerClient*); - -private: - RTCPeerConnectionHandlerClient::SignalingState signalingStateFromSDP(RTCSessionDescriptionDescriptor*); - RTCPeerConnectionHandlerClient* m_client; - - RefPtr<RTCSessionDescriptionDescriptor> m_localSessionDescription; - RefPtr<RTCSessionDescriptionDescriptor> m_remoteSessionDescription; -}; - -} // namespace WebCore - -#endif // ENABLE(MEDIA_STREAM) - -#endif // RTCPeerConnectionHandlerMock_h diff --git a/Source/WebCore/platform/mock/ScrollAnimatorMock.cpp b/Source/WebCore/platform/mock/ScrollAnimatorMock.cpp new file mode 100644 index 000000000..c0803810e --- /dev/null +++ b/Source/WebCore/platform/mock/ScrollAnimatorMock.cpp @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2016 Igalia S.L. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ScrollAnimatorMock.h" + +#include "ScrollableArea.h" +#include <wtf/text/StringBuilder.h> + +namespace WebCore { + +ScrollAnimatorMock::ScrollAnimatorMock(ScrollableArea& scrollableArea, std::function<void(const String&)>&& logger) + : ScrollAnimator(scrollableArea) + , m_logger(WTFMove(logger)) +{ +} + +ScrollAnimatorMock::~ScrollAnimatorMock() +{ +} + +void ScrollAnimatorMock::didAddVerticalScrollbar(Scrollbar* scrollbar) +{ + m_verticalScrollbar = scrollbar; + m_logger("didAddVerticalScrollbar"); + ScrollAnimator::didAddVerticalScrollbar(scrollbar); +} + +void ScrollAnimatorMock::didAddHorizontalScrollbar(Scrollbar* scrollbar) +{ + m_horizontalScrollbar = scrollbar; + m_logger("didAddHorizontalScrollbar"); + ScrollAnimator::didAddHorizontalScrollbar(scrollbar); +} + +void ScrollAnimatorMock::willRemoveVerticalScrollbar(Scrollbar* scrollbar) +{ + m_logger("willRemoveVerticalScrollbar"); + ScrollAnimator::willRemoveVerticalScrollbar(scrollbar); + m_verticalScrollbar = nullptr; +} + +void ScrollAnimatorMock::willRemoveHorizontalScrollbar(Scrollbar* scrollbar) +{ + m_logger("willRemoveHorizontalScrollbar"); + ScrollAnimator::willRemoveHorizontalScrollbar(scrollbar); + m_horizontalScrollbar = nullptr; +} + +void ScrollAnimatorMock::mouseEnteredContentArea() +{ + m_logger("mouseEnteredContentArea"); + ScrollAnimator::mouseEnteredContentArea(); +} + +void ScrollAnimatorMock::mouseMovedInContentArea() +{ + m_logger("mouseMovedInContentArea"); + ScrollAnimator::mouseMovedInContentArea(); +} + +void ScrollAnimatorMock::mouseExitedContentArea() +{ + m_logger("mouseExitedContentArea"); + ScrollAnimator::mouseExitedContentArea(); +} + +void ScrollAnimatorMock::mouseEnteredScrollbar(Scrollbar* scrollbar) const +{ + StringBuilder message; + message.appendLiteral("mouseEntered"); + if (scrollbar == m_verticalScrollbar) + message.appendLiteral("Vertical"); + else if (scrollbar == m_horizontalScrollbar) + message.appendLiteral("Horizontal"); + else + message.appendLiteral("Unknown"); + message.appendLiteral("Scrollbar"); + m_logger(message.toString()); + ScrollAnimator::mouseEnteredScrollbar(scrollbar); +} + +void ScrollAnimatorMock::mouseExitedScrollbar(Scrollbar* scrollbar) const +{ + StringBuilder message; + message.appendLiteral("mouseExited"); + if (scrollbar == m_verticalScrollbar) + message.appendLiteral("Vertical"); + else if (scrollbar == m_horizontalScrollbar) + message.appendLiteral("Horizontal"); + else + message.appendLiteral("Unknown"); + message.appendLiteral("Scrollbar"); + m_logger(message.toString()); + ScrollAnimator::mouseExitedScrollbar(scrollbar); +} + +void ScrollAnimatorMock::mouseIsDownInScrollbar(Scrollbar* scrollbar, bool isPressed) const +{ + StringBuilder message; + message.appendLiteral("mouseIs"); + if (isPressed) + message.appendLiteral("Down"); + else + message.appendLiteral("Up"); + message.appendLiteral("In"); + if (scrollbar == m_verticalScrollbar) + message.appendLiteral("Vertical"); + else if (scrollbar == m_horizontalScrollbar) + message.appendLiteral("Horizontal"); + else + message.appendLiteral("Unknown"); + message.appendLiteral("Scrollbar"); + m_logger(message.toString()); + ScrollAnimator::mouseIsDownInScrollbar(scrollbar, isPressed); +} + +} // namespace WebCore diff --git a/Source/WebCore/platform/mock/ScrollAnimatorMock.h b/Source/WebCore/platform/mock/ScrollAnimatorMock.h new file mode 100644 index 000000000..85dc4f6ed --- /dev/null +++ b/Source/WebCore/platform/mock/ScrollAnimatorMock.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2016 Igalia S.L. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ScrollAnimatorMock_h +#define ScrollAnimatorMock_h + +#include "ScrollAnimator.h" + +namespace WebCore { + +// A Mock implementation of ScrollAnimator used to test the scroll events +// received by the scroll animator. Tests can enable this scroll animator using +// the internal setting enableMockScrollAnimator. +class ScrollAnimatorMock final : public ScrollAnimator { +public: + ScrollAnimatorMock(ScrollableArea&, std::function<void(const String&)>&&); + virtual ~ScrollAnimatorMock(); + +#if ENABLE(RUBBER_BANDING) + bool allowsHorizontalStretching(const PlatformWheelEvent&) override { return false; } + bool allowsVerticalStretching(const PlatformWheelEvent&) override { return false; } + IntSize stretchAmount() override { return IntSize(); } + bool pinnedInDirection(const FloatSize&) override { return false; } + bool canScrollHorizontally() override { return false; } + bool canScrollVertically() override { return false; } + bool shouldRubberBandInDirection(ScrollDirection) override { return false; } + void immediateScrollBy(const FloatSize&) override { } + void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) override { } + void adjustScrollPositionToBoundsIfNecessary() override { } +#endif + +private: + void didAddVerticalScrollbar(Scrollbar*) override; + void didAddHorizontalScrollbar(Scrollbar*) override; + void willRemoveVerticalScrollbar(Scrollbar*) override; + void willRemoveHorizontalScrollbar(Scrollbar*) override; + void mouseEnteredContentArea() override; + void mouseMovedInContentArea() override; + void mouseExitedContentArea() override; + void mouseEnteredScrollbar(Scrollbar*) const override; + void mouseExitedScrollbar(Scrollbar*) const override; + void mouseIsDownInScrollbar(Scrollbar*, bool) const override; + + std::function<void(const String&)> m_logger; + Scrollbar* m_verticalScrollbar { nullptr }; + Scrollbar* m_horizontalScrollbar { nullptr }; +}; + +} // namespace WebCore + +#endif // ScrollAnimatorMock_h diff --git a/Source/WebCore/platform/mock/ScrollbarThemeMock.cpp b/Source/WebCore/platform/mock/ScrollbarThemeMock.cpp index 6de91ccb8..171dfd5c0 100644 --- a/Source/WebCore/platform/mock/ScrollbarThemeMock.cpp +++ b/Source/WebCore/platform/mock/ScrollbarThemeMock.cpp @@ -27,14 +27,16 @@ #include "ScrollbarThemeMock.h" #include "Scrollbar.h" +// FIXME: This is a layering violation. +#include "Settings.h" namespace WebCore { -static int cScrollbarThickness[] = { 15, 11 }; +static const int cScrollbarThickness[] = { 15, 11 }; -IntRect ScrollbarThemeMock::trackRect(ScrollbarThemeClient* scrollbar, bool) +IntRect ScrollbarThemeMock::trackRect(Scrollbar& scrollbar, bool) { - return scrollbar->frameRect(); + return scrollbar.frameRect(); } int ScrollbarThemeMock::scrollbarThickness(ScrollbarControlSize controlSize) @@ -42,15 +44,22 @@ int ScrollbarThemeMock::scrollbarThickness(ScrollbarControlSize controlSize) return cScrollbarThickness[controlSize]; } -void ScrollbarThemeMock::paintTrackBackground(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& trackRect) +void ScrollbarThemeMock::paintTrackBackground(GraphicsContext& context, Scrollbar& scrollbar, const IntRect& trackRect) { - context->fillRect(trackRect, scrollbar->enabled() ? Color::lightGray : Color(0xFFE0E0E0), ColorSpaceDeviceRGB); + context.fillRect(trackRect, scrollbar.enabled() ? Color::lightGray : Color(0xFFE0E0E0)); } -void ScrollbarThemeMock::paintThumb(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& thumbRect) +void ScrollbarThemeMock::paintThumb(GraphicsContext& context, Scrollbar& scrollbar, const IntRect& thumbRect) { - if (scrollbar->enabled()) - context->fillRect(thumbRect, Color::darkGray, ColorSpaceDeviceRGB); + if (scrollbar.enabled()) + context.fillRect(thumbRect, Color::darkGray); +} + +bool ScrollbarThemeMock::usesOverlayScrollbars() const +{ + // FIXME: This is a layering violation, but ScrollbarThemeMock is also created depending on settings in platform layer, + // we should fix it in both places. + return Settings::usesOverlayScrollbars(); } } diff --git a/Source/WebCore/platform/mock/ScrollbarThemeMock.h b/Source/WebCore/platform/mock/ScrollbarThemeMock.h index 6333841ab..7fd039214 100644 --- a/Source/WebCore/platform/mock/ScrollbarThemeMock.h +++ b/Source/WebCore/platform/mock/ScrollbarThemeMock.h @@ -33,21 +33,23 @@ namespace WebCore { // Scrollbar theme used in image snapshots, to eliminate appearance differences between platforms. class ScrollbarThemeMock : public ScrollbarThemeComposite { public: - virtual int scrollbarThickness(ScrollbarControlSize = RegularScrollbar); + int scrollbarThickness(ScrollbarControlSize = RegularScrollbar) override; protected: - virtual bool hasButtons(ScrollbarThemeClient*) { return false; } - virtual bool hasThumb(ScrollbarThemeClient*) { return true; } + bool hasButtons(Scrollbar&) override { return false; } + bool hasThumb(Scrollbar&) override { return true; } - virtual IntRect backButtonRect(ScrollbarThemeClient*, ScrollbarPart, bool /*painting*/ = false) { return IntRect(); } - virtual IntRect forwardButtonRect(ScrollbarThemeClient*, ScrollbarPart, bool /*painting*/ = false) { return IntRect(); } - virtual IntRect trackRect(ScrollbarThemeClient*, bool painting = false); - - virtual void paintTrackBackground(GraphicsContext*, ScrollbarThemeClient*, const IntRect&); - virtual void paintThumb(GraphicsContext*, ScrollbarThemeClient*, const IntRect&); + IntRect backButtonRect(Scrollbar&, ScrollbarPart, bool /*painting*/ = false) override { return IntRect(); } + IntRect forwardButtonRect(Scrollbar&, ScrollbarPart, bool /*painting*/ = false) override { return IntRect(); } + IntRect trackRect(Scrollbar&, bool painting = false) override; + void paintTrackBackground(GraphicsContext&, Scrollbar&, const IntRect&) override; + void paintThumb(GraphicsContext&, Scrollbar&, const IntRect&) override; + int maxOverlapBetweenPages() override { return 40; } + + bool usesOverlayScrollbars() const override; private: - virtual bool isMockTheme() const { return true; } + bool isMockTheme() const override { return true; } }; } diff --git a/Source/WebCore/platform/mock/MediaConstraintsMock.h b/Source/WebCore/platform/mock/TimerEventBasedMock.h index 1c96c619b..de0e8a9fd 100644 --- a/Source/WebCore/platform/mock/MediaConstraintsMock.h +++ b/Source/WebCore/platform/mock/TimerEventBasedMock.h @@ -1,6 +1,5 @@ /* - * Copyright (C) 2012 Google Inc. All rights reserved. - * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). + * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies). * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -24,25 +23,68 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MediaConstraintsMock_h -#define MediaConstraintsMock_h +#ifndef TimerEventBasedMock_h +#define TimerEventBasedMock_h -#if ENABLE(MEDIA_STREAM) +#if ENABLE(WEB_RTC) +#include "Timer.h" #include <wtf/PassRefPtr.h> -#include <wtf/text/WTFString.h> +#include <wtf/RefCounted.h> +#include <wtf/RefPtr.h> +#include <wtf/Vector.h> namespace WebCore { -class MediaConstraints; +class TimerEvent; -class MediaConstraintsMock { +class MockNotifier : public RefCounted<MockNotifier> { public: - static String verifyConstraints(PassRefPtr<MediaConstraints>); + virtual ~MockNotifier() { } + virtual void fire() = 0; +}; + +class TimerEventBasedMock { +public: + void removeEvent(PassRefPtr<TimerEvent> event) + { + size_t pos = m_timerEvents.find(event); + m_timerEvents.remove(pos); + } + +protected: + Vector<RefPtr<TimerEvent> > m_timerEvents; +}; + +class TimerEvent : public RefCounted<TimerEvent> { +public: + TimerEvent(TimerEventBasedMock* mock, PassRefPtr<MockNotifier> notifier) + : m_mock(mock) + , m_timer(*this, &TimerEvent::timerFired) + , m_notifier(notifier) + { + m_timer.startOneShot(0.5); + } + + virtual ~TimerEvent() + { + m_mock = nullptr; + } + + void timerFired() + { + m_notifier->fire(); + m_mock->removeEvent(this); + } + +private: + TimerEventBasedMock* m_mock; + Timer m_timer; + RefPtr<MockNotifier> m_notifier; }; } // namespace WebCore -#endif // MockMediaConstraints_h +#endif // ENABLE(WEB_RTC) -#endif // ENABLE(MEDIA_STREAM) +#endif // TimerEventBasedMock_h diff --git a/Source/WebCore/platform/mock/mediasource/MockBox.cpp b/Source/WebCore/platform/mock/mediasource/MockBox.cpp index 286e81b49..c8b134e51 100644 --- a/Source/WebCore/platform/mock/mediasource/MockBox.cpp +++ b/Source/WebCore/platform/mock/mediasource/MockBox.cpp @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -28,9 +28,13 @@ #if ENABLE(MEDIA_SOURCE) +#include <JavaScriptCore/HeapInlines.h> +#include <JavaScriptCore/JSCJSValueInlines.h> +#include <JavaScriptCore/TypedArrayInlines.h> #include <runtime/ArrayBuffer.h> #include <runtime/DataView.h> #include <runtime/Int8Array.h> +#include <wtf/NeverDestroyed.h> #include <wtf/text/StringBuilder.h> namespace WebCore { @@ -76,7 +80,7 @@ MockTrackBox::MockTrackBox(ArrayBuffer* data) const String& MockTrackBox::type() { - DEFINE_STATIC_LOCAL(String, trak, (ASCIILiteral("trak"))); + static NeverDestroyed<String> trak(ASCIILiteral("trak")); return trak; } @@ -105,14 +109,14 @@ MockInitializationBox::MockInitializationBox(ArrayBuffer* data) const String& MockInitializationBox::type() { - DEFINE_STATIC_LOCAL(String, init, (ASCIILiteral("init"))); + static NeverDestroyed<String> init(ASCIILiteral("init")); return init; } MockSampleBox::MockSampleBox(ArrayBuffer* data) : MockBox(data) { - ASSERT(m_length == 29); + ASSERT(m_length == 30); RefPtr<JSC::DataView> view = JSC::DataView::create(data, 0, data->byteLength()); int32_t timeScale = view->get<int32_t>(8, true); @@ -128,11 +132,12 @@ MockSampleBox::MockSampleBox(ArrayBuffer* data) m_trackID = view->get<int32_t>(24, true); m_flags = view->get<uint8_t>(28, true); + m_generation = view->get<uint8_t>(29, true); } const String& MockSampleBox::type() { - DEFINE_STATIC_LOCAL(String, smpl, (ASCIILiteral("smpl"))); + static NeverDestroyed<String> smpl(ASCIILiteral("smpl")); return smpl; } diff --git a/Source/WebCore/platform/mock/mediasource/MockBox.h b/Source/WebCore/platform/mock/mediasource/MockBox.h index 6ddc21c47..2cc530fe3 100644 --- a/Source/WebCore/platform/mock/mediasource/MockBox.h +++ b/Source/WebCore/platform/mock/mediasource/MockBox.h @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -117,6 +117,7 @@ protected: // 4 bytes : signed : duration time value // 4 bytes : signed : track ID // 1 byte : unsigned : flags +// 1 byte : unsigned : generation // class MockSampleBox final : public MockBox { public: @@ -128,17 +129,33 @@ public: MediaTime duration() const { return m_duration; } int32_t trackID() const { return m_trackID; } uint8_t flags() const { return m_flags; } + uint8_t generation() const { return m_generation; } + void offsetTimestampsBy(const MediaTime& offset) + { + m_presentationTimestamp += offset; + m_decodeTimestamp += offset; + } + void setTimestamps(const MediaTime& presentationTimestamp, const MediaTime& decodeTimestamp) + { + m_presentationTimestamp = presentationTimestamp; + m_decodeTimestamp = decodeTimestamp; + } + + void clearFlag(uint8_t flag) { m_flags &= ~flag; } + void setFlag(uint8_t flag) { m_flags |= flag; } enum { IsSync = 1 << 0, IsCorrupted = 1 << 1, IsDropped = 1 << 2, IsDelayed = 1 << 3, + IsNonDisplaying = 1 << 4, }; bool isSync() const { return m_flags & IsSync; } bool isCorrupted() const { return m_flags & IsCorrupted; } bool isDropped() const { return m_flags & IsDropped; } bool isDelayed() const { return m_flags & IsDelayed; } + bool isNonDisplaying() const { return m_flags & IsNonDisplaying; } protected: MediaTime m_presentationTimestamp; @@ -146,6 +163,7 @@ protected: MediaTime m_duration; int32_t m_trackID; uint8_t m_flags; + uint8_t m_generation; }; } diff --git a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.cpp b/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.cpp index e0fc51c9f..4e40c8e73 100644 --- a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.cpp +++ b/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013-2015 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -28,12 +28,11 @@ #if ENABLE(MEDIA_SOURCE) -#include "ExceptionCodePlaceholder.h" -#include "HTMLMediaSource.h" #include "MediaPlayer.h" +#include "MediaSourcePrivateClient.h" #include "MockMediaSourcePrivate.h" -#include <wtf/Functional.h> #include <wtf/MainThread.h> +#include <wtf/NeverDestroyed.h> #include <wtf/text/WTFString.h> namespace WebCore { @@ -41,28 +40,25 @@ namespace WebCore { // MediaPlayer Enigne Support void MockMediaPlayerMediaSource::registerMediaEngine(MediaEngineRegistrar registrar) { - registrar(create, getSupportedTypes, supportsType, 0, 0, 0); + registrar([](MediaPlayer* player) { return std::make_unique<MockMediaPlayerMediaSource>(player); }, getSupportedTypes, + supportsType, 0, 0, 0, 0); } -PassOwnPtr<MediaPlayerPrivateInterface> MockMediaPlayerMediaSource::create(MediaPlayer* player) +static const HashSet<String, ASCIICaseInsensitiveHash>& mimeTypeCache() { - return adoptPtr(new MockMediaPlayerMediaSource(player)); -} - -static HashSet<String> mimeTypeCache() -{ - DEFINE_STATIC_LOCAL(HashSet<String>, cache, ()); + static NeverDestroyed<HashSet<String, ASCIICaseInsensitiveHash>> cache; static bool isInitialized = false; if (!isInitialized) { isInitialized = true; - cache.add(ASCIILiteral("video/mock")); + cache.get().add(ASCIILiteral("video/mock")); + cache.get().add(ASCIILiteral("audio/mock")); } return cache; } -void MockMediaPlayerMediaSource::getSupportedTypes(HashSet<String>& supportedTypes) +void MockMediaPlayerMediaSource::getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& supportedTypes) { supportedTypes = mimeTypeCache(); } @@ -72,7 +68,7 @@ MediaPlayer::SupportsType MockMediaPlayerMediaSource::supportsType(const MediaEn if (!parameters.isMediaSource) return MediaPlayer::IsNotSupported; - if (!mimeTypeCache().contains(parameters.type)) + if (parameters.type.isEmpty() || !mimeTypeCache().contains(parameters.type)) return MediaPlayer::IsNotSupported; if (parameters.codecs.isEmpty()) @@ -84,10 +80,10 @@ MediaPlayer::SupportsType MockMediaPlayerMediaSource::supportsType(const MediaEn MockMediaPlayerMediaSource::MockMediaPlayerMediaSource(MediaPlayer* player) : m_player(player) , m_currentTime(MediaTime::zeroTime()) - , m_duration(0) , m_readyState(MediaPlayer::HaveNothing) , m_networkState(MediaPlayer::Empty) , m_playing(false) + , m_seekCompleted(true) { } @@ -100,11 +96,9 @@ void MockMediaPlayerMediaSource::load(const String&) ASSERT_NOT_REACHED(); } -void MockMediaPlayerMediaSource::load(const String&, PassRefPtr<HTMLMediaSource> source) +void MockMediaPlayerMediaSource::load(const String&, MediaSourcePrivateClient* source) { - m_mediaSource = source; - m_mediaSourcePrivate = MockMediaSourcePrivate::create(this); - m_mediaSource->setPrivateAndOpen(*m_mediaSourcePrivate); + m_mediaSourcePrivate = MockMediaSourcePrivate::create(this, source); } void MockMediaPlayerMediaSource::cancelLoad() @@ -114,7 +108,9 @@ void MockMediaPlayerMediaSource::cancelLoad() void MockMediaPlayerMediaSource::play() { m_playing = 1; - callOnMainThread(bind(&MockMediaPlayerMediaSource::advanceCurrentTime, this)); + callOnMainThread([this] { + advanceCurrentTime(); + }); } void MockMediaPlayerMediaSource::pause() @@ -122,9 +118,9 @@ void MockMediaPlayerMediaSource::pause() m_playing = 0; } -IntSize MockMediaPlayerMediaSource::naturalSize() const +FloatSize MockMediaPlayerMediaSource::naturalSize() const { - return IntSize(); + return FloatSize(); } bool MockMediaPlayerMediaSource::hasVideo() const @@ -143,7 +139,7 @@ void MockMediaPlayerMediaSource::setVisible(bool) bool MockMediaPlayerMediaSource::seeking() const { - return false; + return !m_seekCompleted; } bool MockMediaPlayerMediaSource::paused() const @@ -161,14 +157,17 @@ MediaPlayer::ReadyState MockMediaPlayerMediaSource::readyState() const return m_readyState; } -double MockMediaPlayerMediaSource::maxTimeSeekableDouble() const +MediaTime MockMediaPlayerMediaSource::maxMediaTimeSeekable() const { return m_duration; } -PassRefPtr<TimeRanges> MockMediaPlayerMediaSource::buffered() const +std::unique_ptr<PlatformTimeRanges> MockMediaPlayerMediaSource::buffered() const { - return m_mediaSource ? m_mediaSource->buffered() : TimeRanges::create(); + if (m_mediaSourcePrivate) + return m_mediaSourcePrivate->buffered(); + + return std::make_unique<PlatformTimeRanges>(); } bool MockMediaPlayerMediaSource::didLoadingProgress() const @@ -180,45 +179,54 @@ void MockMediaPlayerMediaSource::setSize(const IntSize&) { } -void MockMediaPlayerMediaSource::paint(GraphicsContext*, const IntRect&) +void MockMediaPlayerMediaSource::paint(GraphicsContext&, const FloatRect&) { } -double MockMediaPlayerMediaSource::currentTimeDouble() const +MediaTime MockMediaPlayerMediaSource::currentMediaTime() const { - return m_currentTime.toDouble(); + return m_currentTime; } -double MockMediaPlayerMediaSource::durationDouble() const +MediaTime MockMediaPlayerMediaSource::durationMediaTime() const { - return m_duration; + return m_mediaSourcePrivate ? m_mediaSourcePrivate->duration() : MediaTime::zeroTime(); } -void MockMediaPlayerMediaSource::seekWithTolerance(double time, double negativeTolerance, double positiveTolerance) +void MockMediaPlayerMediaSource::seekWithTolerance(const MediaTime& time, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance) { if (!negativeTolerance && !positiveTolerance) { - m_currentTime = MediaTime::createWithDouble(time); - m_mediaSourcePrivate->seekToTime(MediaTime::createWithDouble(time)); + m_currentTime = time; + m_mediaSourcePrivate->seekToTime(time); } else - m_currentTime = m_mediaSourcePrivate->seekToTime(MediaTime::createWithDouble(time), MediaTime::createWithDouble(negativeTolerance), MediaTime::createWithDouble(positiveTolerance)); - m_player->timeChanged(); + m_currentTime = m_mediaSourcePrivate->seekToTime(time, negativeTolerance, positiveTolerance); - if (m_playing) - callOnMainThread(bind(&MockMediaPlayerMediaSource::advanceCurrentTime, this)); + if (m_seekCompleted) { + m_player->timeChanged(); + + if (m_playing) + callOnMainThread([this] { + advanceCurrentTime(); + }); + } } void MockMediaPlayerMediaSource::advanceCurrentTime() { - RefPtr<TimeRanges> buffered = this->buffered(); - size_t pos = buffered->find(m_currentTime.toDouble()); + if (!m_mediaSourcePrivate) + return; + + auto buffered = m_mediaSourcePrivate->buffered(); + size_t pos = buffered->find(m_currentTime); if (pos == notFound) return; - m_currentTime = MediaTime::createWithDouble(std::min(m_duration, buffered->end(pos, IGNORE_EXCEPTION))); + bool ignoreError; + m_currentTime = std::min(m_duration, buffered->end(pos, ignoreError)); m_player->timeChanged(); } -void MockMediaPlayerMediaSource::updateDuration(double duration) +void MockMediaPlayerMediaSource::updateDuration(const MediaTime& duration) { if (m_duration == duration) return; @@ -245,6 +253,25 @@ void MockMediaPlayerMediaSource::setNetworkState(MediaPlayer::NetworkState netwo m_player->networkStateChanged(); } +void MockMediaPlayerMediaSource::waitForSeekCompleted() +{ + m_seekCompleted = false; +} + +void MockMediaPlayerMediaSource::seekCompleted() +{ + if (m_seekCompleted) + return; + m_seekCompleted = true; + + m_player->timeChanged(); + + if (m_playing) + callOnMainThread([this] { + advanceCurrentTime(); + }); +} + unsigned long MockMediaPlayerMediaSource::totalVideoFrames() { return m_mediaSourcePrivate ? m_mediaSourcePrivate->totalVideoFrames() : 0; @@ -260,9 +287,9 @@ unsigned long MockMediaPlayerMediaSource::corruptedVideoFrames() return m_mediaSourcePrivate ? m_mediaSourcePrivate->corruptedVideoFrames() : 0; } -double MockMediaPlayerMediaSource::totalFrameDelay() +MediaTime MockMediaPlayerMediaSource::totalFrameDelay() { - return m_mediaSourcePrivate ? m_mediaSourcePrivate->totalFrameDelay() : 0; + return m_mediaSourcePrivate ? m_mediaSourcePrivate->totalFrameDelay() : MediaTime::zeroTime(); } } diff --git a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h b/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h index cd8d794ab..d03e4a06e 100644 --- a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h +++ b/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -38,59 +38,63 @@ class MockMediaSourcePrivate; class MockMediaPlayerMediaSource : public MediaPlayerPrivateInterface { public: + explicit MockMediaPlayerMediaSource(MediaPlayer*); + // MediaPlayer Engine Support - static void registerMediaEngine(MediaEngineRegistrar); - static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*); - static void getSupportedTypes(HashSet<String>& types); + WEBCORE_EXPORT static void registerMediaEngine(MediaEngineRegistrar); + static void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types); static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&); virtual ~MockMediaPlayerMediaSource(); void advanceCurrentTime(); - void updateDuration(double); + void updateDuration(const MediaTime&); - virtual MediaPlayer::ReadyState readyState() const override; + MediaPlayer::ReadyState readyState() const override; void setReadyState(MediaPlayer::ReadyState); void setNetworkState(MediaPlayer::NetworkState); + void waitForSeekCompleted(); + void seekCompleted(); private: - MockMediaPlayerMediaSource(MediaPlayer*); - // MediaPlayerPrivate Overrides - virtual void load(const String& url) override; - virtual void load(const String& url, PassRefPtr<HTMLMediaSource>) override; - virtual void cancelLoad() override; - virtual void play() override; - virtual void pause() override; - virtual IntSize naturalSize() const override; - virtual bool hasVideo() const override; - virtual bool hasAudio() const override; - virtual void setVisible(bool) override; - virtual bool seeking() const override; - virtual bool paused() const override; - virtual MediaPlayer::NetworkState networkState() const override; - virtual double maxTimeSeekableDouble() const override; - virtual PassRefPtr<TimeRanges> buffered() const override; - virtual bool didLoadingProgress() const override; - virtual void setSize(const IntSize&) override; - virtual void paint(GraphicsContext*, const IntRect&) override; - virtual double currentTimeDouble() const override; - virtual double durationDouble() const override; - virtual void seekWithTolerance(double time, double, double) override; - virtual unsigned long totalVideoFrames() override; - virtual unsigned long droppedVideoFrames() override; - virtual unsigned long corruptedVideoFrames() override; - virtual double totalFrameDelay() override; + void load(const String& url) override; + void load(const String& url, MediaSourcePrivateClient*) override; +#if ENABLE(MEDIA_STREAM) + void load(MediaStreamPrivate&) override { } +#endif + void cancelLoad() override; + void play() override; + void pause() override; + FloatSize naturalSize() const override; + bool hasVideo() const override; + bool hasAudio() const override; + void setVisible(bool) override; + bool seeking() const override; + bool paused() const override; + MediaPlayer::NetworkState networkState() const override; + MediaTime maxMediaTimeSeekable() const override; + std::unique_ptr<PlatformTimeRanges> buffered() const override; + bool didLoadingProgress() const override; + void setSize(const IntSize&) override; + void paint(GraphicsContext&, const FloatRect&) override; + MediaTime currentMediaTime() const override; + MediaTime durationMediaTime() const override; + void seekWithTolerance(const MediaTime&, const MediaTime&, const MediaTime&) override; + unsigned long totalVideoFrames() override; + unsigned long droppedVideoFrames() override; + unsigned long corruptedVideoFrames() override; + MediaTime totalFrameDelay() override; MediaPlayer* m_player; - RefPtr<HTMLMediaSource> m_mediaSource; RefPtr<MockMediaSourcePrivate> m_mediaSourcePrivate; MediaTime m_currentTime; - double m_duration; + MediaTime m_duration; MediaPlayer::ReadyState m_readyState; MediaPlayer::NetworkState m_networkState; bool m_playing; + bool m_seekCompleted; }; } diff --git a/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.cpp b/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.cpp index 811173dfa..eb2ff784c 100644 --- a/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.cpp +++ b/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.cpp @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -29,25 +29,26 @@ #if ENABLE(MEDIA_SOURCE) #include "ContentType.h" -#include "ExceptionCodePlaceholder.h" +#include "MediaSourcePrivateClient.h" #include "MockMediaPlayerMediaSource.h" #include "MockSourceBufferPrivate.h" namespace WebCore { -RefPtr<MockMediaSourcePrivate> MockMediaSourcePrivate::create(MockMediaPlayerMediaSource* parent) +RefPtr<MockMediaSourcePrivate> MockMediaSourcePrivate::create(MockMediaPlayerMediaSource* parent, MediaSourcePrivateClient* client) { - return adoptRef(new MockMediaSourcePrivate(parent)); + RefPtr<MockMediaSourcePrivate> mediaSourcePrivate = adoptRef(new MockMediaSourcePrivate(parent, client)); + client->setPrivateAndOpen(*mediaSourcePrivate); + return mediaSourcePrivate; } -MockMediaSourcePrivate::MockMediaSourcePrivate(MockMediaPlayerMediaSource* parent) +MockMediaSourcePrivate::MockMediaSourcePrivate(MockMediaPlayerMediaSource* parent, MediaSourcePrivateClient* client) : m_player(parent) - , m_duration(std::numeric_limits<float>::quiet_NaN()) + , m_client(client) , m_isEnded(false) , m_totalVideoFrames(0) , m_droppedVideoFrames(0) , m_corruptedVideoFrames(0) - , m_totalFrameDelay(0) { } @@ -84,18 +85,19 @@ void MockMediaSourcePrivate::removeSourceBuffer(SourceBufferPrivate* buffer) m_sourceBuffers.remove(pos); } -double MockMediaSourcePrivate::duration() +MediaTime MockMediaSourcePrivate::duration() { - return m_duration; + return m_client->duration(); } -void MockMediaSourcePrivate::setDuration(double duration) +std::unique_ptr<PlatformTimeRanges> MockMediaSourcePrivate::buffered() { - if (duration == m_duration) - return; + return m_client->buffered(); +} - m_duration = duration; - m_player->updateDuration(duration); +void MockMediaSourcePrivate::durationChanged() +{ + m_player->updateDuration(duration()); } void MockMediaSourcePrivate::markEndOfStream(EndOfStreamStatus status) @@ -120,6 +122,16 @@ void MockMediaSourcePrivate::setReadyState(MediaPlayer::ReadyState readyState) m_player->setReadyState(readyState); } +void MockMediaSourcePrivate::waitForSeekCompleted() +{ + m_player->waitForSeekCompleted(); +} + +void MockMediaSourcePrivate::seekCompleted() +{ + m_player->seekCompleted(); +} + void MockMediaSourcePrivate::sourceBufferPrivateDidChangeActiveState(MockSourceBufferPrivate* buffer, bool active) { if (active && !m_activeSourceBuffers.contains(buffer)) @@ -154,8 +166,7 @@ bool MockMediaSourcePrivate::hasVideo() const void MockMediaSourcePrivate::seekToTime(const MediaTime& time) { - for (auto it = m_activeSourceBuffers.begin(), end = m_activeSourceBuffers.end(); it != end; ++it) - (*it)->seekToTime(time); + m_client->seekToTime(time); } MediaTime MockMediaSourcePrivate::seekToTime(const MediaTime& targetTime, const MediaTime& negativeThreshold, const MediaTime& positiveThreshold) diff --git a/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.h b/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.h index 9cc3da2eb..8c7169ea0 100644 --- a/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.h +++ b/Source/WebCore/platform/mock/mediasource/MockMediaSourcePrivate.h @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -39,7 +39,7 @@ class TimeRanges; class MockMediaSourcePrivate final : public MediaSourcePrivate { public: - static RefPtr<MockMediaSourcePrivate> create(MockMediaPlayerMediaSource*); + static RefPtr<MockMediaSourcePrivate> create(MockMediaPlayerMediaSource*, MediaSourcePrivateClient*); virtual ~MockMediaSourcePrivate(); const Vector<MockSourceBufferPrivate*>& activeSourceBuffers() const { return m_activeSourceBuffers; } @@ -47,6 +47,9 @@ public: bool hasAudio() const; bool hasVideo() const; + MediaTime duration(); + std::unique_ptr<PlatformTimeRanges> buffered(); + MockMediaPlayerMediaSource* player() const { return m_player; } void seekToTime(const MediaTime&); @@ -55,24 +58,25 @@ public: unsigned long totalVideoFrames() const { return m_totalVideoFrames; } unsigned long droppedVideoFrames() const { return m_droppedVideoFrames; } unsigned long corruptedVideoFrames() const { return m_corruptedVideoFrames; } - double totalFrameDelay() const { return m_totalFrameDelay; } + MediaTime totalFrameDelay() const { return m_totalFrameDelay; } void incrementTotalVideoFrames() { ++m_totalVideoFrames; } void incrementDroppedFrames() { ++m_droppedVideoFrames; } void incrementCorruptedFrames() { ++m_corruptedVideoFrames; } - void incrementTotalFrameDelayBy(double delay) { m_totalFrameDelay += delay; } + void incrementTotalFrameDelayBy(const MediaTime& delay) { m_totalFrameDelay += delay; } private: - MockMediaSourcePrivate(MockMediaPlayerMediaSource*); + MockMediaSourcePrivate(MockMediaPlayerMediaSource*, MediaSourcePrivateClient*); // MediaSourcePrivate Overrides - virtual AddStatus addSourceBuffer(const ContentType&, RefPtr<SourceBufferPrivate>&) override; - virtual double duration() override; - virtual void setDuration(double) override; - virtual void markEndOfStream(EndOfStreamStatus) override; - virtual void unmarkEndOfStream() override; - virtual MediaPlayer::ReadyState readyState() const override; - virtual void setReadyState(MediaPlayer::ReadyState) override; + AddStatus addSourceBuffer(const ContentType&, RefPtr<SourceBufferPrivate>&) override; + void durationChanged() override; + void markEndOfStream(EndOfStreamStatus) override; + void unmarkEndOfStream() override; + MediaPlayer::ReadyState readyState() const override; + void setReadyState(MediaPlayer::ReadyState) override; + void waitForSeekCompleted() override; + void seekCompleted() override; void sourceBufferPrivateDidChangeActiveState(MockSourceBufferPrivate*, bool active); void removeSourceBuffer(SourceBufferPrivate*); @@ -80,7 +84,7 @@ private: friend class MockSourceBufferPrivate; MockMediaPlayerMediaSource* m_player; - double m_duration; + RefPtr<MediaSourcePrivateClient> m_client; Vector<RefPtr<MockSourceBufferPrivate>> m_sourceBuffers; Vector<MockSourceBufferPrivate*> m_activeSourceBuffers; bool m_isEnded; @@ -88,7 +92,7 @@ private: unsigned long m_totalVideoFrames; unsigned long m_droppedVideoFrames; unsigned long m_corruptedVideoFrames; - double m_totalFrameDelay; + MediaTime m_totalFrameDelay; }; } diff --git a/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.cpp b/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.cpp index 643ae76cd..e031a9b5d 100644 --- a/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.cpp +++ b/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013-2017 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -10,17 +10,17 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" @@ -38,29 +38,40 @@ #include "SourceBufferPrivateClient.h" #include <map> #include <runtime/ArrayBuffer.h> +#include <wtf/StringPrintStream.h> namespace WebCore { class MockMediaSample final : public MediaSample { public: - static RefPtr<MockMediaSample> create(const MockSampleBox& box) { return adoptRef(new MockMediaSample(box)); } + static Ref<MockMediaSample> create(const MockSampleBox& box) { return adoptRef(*new MockMediaSample(box)); } virtual ~MockMediaSample() { } - virtual MediaTime presentationTime() const override { return m_box.presentationTimestamp(); } - virtual MediaTime decodeTime() const override { return m_box.decodeTimestamp(); } - virtual MediaTime duration() const override { return m_box.duration(); } - virtual AtomicString trackID() const override { return m_id; } - - virtual SampleFlags flags() const override; - virtual PlatformSample platformSample() override; - -protected: +private: MockMediaSample(const MockSampleBox& box) : m_box(box) , m_id(String::format("%d", box.trackID())) { } + MediaTime presentationTime() const override { return m_box.presentationTimestamp(); } + MediaTime decodeTime() const override { return m_box.decodeTimestamp(); } + MediaTime duration() const override { return m_box.duration(); } + AtomicString trackID() const override { return m_id; } + void setTrackID(const String& id) override { m_id = id; } + size_t sizeInBytes() const override { return sizeof(m_box); } + SampleFlags flags() const override; + PlatformSample platformSample() override; + FloatSize presentationSize() const override { return FloatSize(); } + void dump(PrintStream&) const override; + void offsetTimestampsBy(const MediaTime& offset) override { m_box.offsetTimestampsBy(offset); } + void setTimestamps(const MediaTime& presentationTimestamp, const MediaTime& decodeTimestamp) override { m_box.setTimestamps(presentationTimestamp, decodeTimestamp); } + bool isDivisable() const override { return false; } + std::pair<RefPtr<MediaSample>, RefPtr<MediaSample>> divide(const MediaTime&) override { return {nullptr, nullptr}; } + Ref<MediaSample> createNonDisplayingCopy() const override; + + unsigned generation() const { return m_box.generation(); } + MockSampleBox m_box; AtomicString m_id; }; @@ -68,8 +79,10 @@ protected: MediaSample::SampleFlags MockMediaSample::flags() const { unsigned flags = None; - if (m_box.flags() & MockSampleBox::IsSync) + if (m_box.isSync()) flags |= IsSync; + if (m_box.isNonDisplaying()) + flags |= IsNonDisplaying; return SampleFlags(flags); } @@ -79,15 +92,27 @@ PlatformSample MockMediaSample::platformSample() return sample; } +void MockMediaSample::dump(PrintStream& out) const +{ + out.print("{PTS(", presentationTime(), "), DTS(", decodeTime(), "), duration(", duration(), "), flags(", (int)flags(), "), generation(", generation(), ")}"); +} + +Ref<MediaSample> MockMediaSample::createNonDisplayingCopy() const +{ + auto copy = MockMediaSample::create(m_box); + copy->m_box.setFlag(MockSampleBox::IsNonDisplaying); + return WTFMove(copy); +} + class MockMediaDescription final : public MediaDescription { public: static RefPtr<MockMediaDescription> create(const MockTrackBox& box) { return adoptRef(new MockMediaDescription(box)); } virtual ~MockMediaDescription() { } - virtual AtomicString codec() const override { return m_box.codec(); } - virtual bool isVideo() const override { return m_box.kind() == MockTrackBox::Video; } - virtual bool isAudio() const override { return m_box.kind() == MockTrackBox::Audio; } - virtual bool isText() const override { return m_box.kind() == MockTrackBox::Text; } + AtomicString codec() const override { return m_box.codec(); } + bool isVideo() const override { return m_box.kind() == MockTrackBox::Video; } + bool isAudio() const override { return m_box.kind() == MockTrackBox::Audio; } + bool isText() const override { return m_box.kind() == MockTrackBox::Text; } protected: MockMediaDescription(const MockTrackBox& box) : m_box(box) { } @@ -114,12 +139,12 @@ void MockSourceBufferPrivate::setClient(SourceBufferPrivateClient* client) m_client = client; } -SourceBufferPrivate::AppendResult MockSourceBufferPrivate::append(const unsigned char* data, unsigned length) +void MockSourceBufferPrivate::append(const unsigned char* data, unsigned length) { m_inputBuffer.append(data, length); - AppendResult result = AppendSucceeded; + SourceBufferPrivateClient::AppendResult result = SourceBufferPrivateClient::AppendSucceeded; - while (m_inputBuffer.size() && result == AppendSucceeded) { + while (m_inputBuffer.size() && result == SourceBufferPrivateClient::AppendSucceeded) { RefPtr<ArrayBuffer> buffer = ArrayBuffer::create(m_inputBuffer.data(), m_inputBuffer.size()); size_t boxLength = MockBox::peekLength(buffer.get()); if (boxLength > buffer->byteLength()) @@ -133,12 +158,13 @@ SourceBufferPrivate::AppendResult MockSourceBufferPrivate::append(const unsigned MockSampleBox sampleBox = MockSampleBox(buffer.get()); didReceiveSample(sampleBox); } else - result = ParsingFailed; + result = SourceBufferPrivateClient::ParsingFailed; m_inputBuffer.remove(0, boxLength); } - return result; + if (m_client) + m_client->sourceBufferPrivateAppendComplete(result); } void MockSourceBufferPrivate::didReceiveInitializationSegment(const MockInitializationBox& initBox) @@ -169,7 +195,7 @@ void MockSourceBufferPrivate::didReceiveInitializationSegment(const MockInitiali } } - m_client->sourceBufferPrivateDidReceiveInitializationSegment(this, segment); + m_client->sourceBufferPrivateDidReceiveInitializationSegment(segment); } @@ -178,13 +204,17 @@ void MockSourceBufferPrivate::didReceiveSample(const MockSampleBox& sampleBox) if (!m_client) return; - m_client->sourceBufferPrivateDidReceiveSample(this, MockMediaSample::create(sampleBox)); + m_client->sourceBufferPrivateDidReceiveSample(MockMediaSample::create(sampleBox)); } void MockSourceBufferPrivate::abort() { } +void MockSourceBufferPrivate::resetParserState() +{ +} + void MockSourceBufferPrivate::removedFromMediaSource() { if (m_mediaSource) @@ -202,32 +232,27 @@ void MockSourceBufferPrivate::setReadyState(MediaPlayer::ReadyState readyState) m_mediaSource->player()->setReadyState(readyState); } -void MockSourceBufferPrivate::evictCodedFrames() -{ - // No-op. -} - -bool MockSourceBufferPrivate::isFull() -{ - return false; -} - void MockSourceBufferPrivate::setActive(bool isActive) { if (m_mediaSource) m_mediaSource->sourceBufferPrivateDidChangeActiveState(this, isActive); } -void MockSourceBufferPrivate::enqueueSample(PassRefPtr<MediaSample> sample, AtomicString) +Vector<String> MockSourceBufferPrivate::enqueuedSamplesForTrackID(const AtomicString&) +{ + return m_enqueuedSamples; +} + +void MockSourceBufferPrivate::enqueueSample(Ref<MediaSample>&& sample, const AtomicString&) { - if (!m_mediaSource || !sample) + if (!m_mediaSource) return; PlatformSample platformSample = sample->platformSample(); if (platformSample.type != PlatformSample::MockSampleBoxType) return; - MockSampleBox* box = platformSample.sample.mockSampleBox; + auto* box = platformSample.sample.mockSampleBox; if (!box) return; @@ -237,37 +262,32 @@ void MockSourceBufferPrivate::enqueueSample(PassRefPtr<MediaSample> sample, Atom if (box->isDropped()) m_mediaSource->incrementDroppedFrames(); if (box->isDelayed()) - m_mediaSource->incrementTotalFrameDelayBy(1); + m_mediaSource->incrementTotalFrameDelayBy(MediaTime(1, 1)); + + m_enqueuedSamples.append(toString(sample.get())); } bool MockSourceBufferPrivate::hasVideo() const { - if (!m_client) - return false; - - return m_client->sourceBufferPrivateHasVideo(this); + return m_client && m_client->sourceBufferPrivateHasVideo(); } bool MockSourceBufferPrivate::hasAudio() const { - if (!m_client) - return false; - - return m_client->sourceBufferPrivateHasAudio(this); + return m_client && m_client->sourceBufferPrivateHasAudio(); } - MediaTime MockSourceBufferPrivate::fastSeekTimeForMediaTime(const MediaTime& time, const MediaTime& negativeThreshold, const MediaTime& positiveThreshold) { if (m_client) - return m_client->sourceBufferPrivateFastSeekTimeForMediaTime(this, time, negativeThreshold, positiveThreshold); + return m_client->sourceBufferPrivateFastSeekTimeForMediaTime(time, negativeThreshold, positiveThreshold); return time; } void MockSourceBufferPrivate::seekToTime(const MediaTime& time) { if (m_client) - m_client->sourceBufferPrivateSeekToTime(this, time); + m_client->sourceBufferPrivateSeekToTime(time); } } diff --git a/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.h b/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.h index 109d032db..49650553b 100644 --- a/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.h +++ b/Source/WebCore/platform/mock/mediasource/MockSourceBufferPrivate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013-2017 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -23,17 +23,11 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MockSourceBufferPrivate_h -#define MockSourceBufferPrivate_h +#pragma once #if ENABLE(MEDIA_SOURCE) #include "SourceBufferPrivate.h" -#include <wtf/HashMap.h> -#include <wtf/MediaTime.h> -#include <wtf/RefPtr.h> -#include <wtf/RetainPtr.h> -#include <wtf/Vector.h> namespace WebCore { @@ -45,7 +39,7 @@ class MockSampleBox; class TimeRanges; class VideoTrackPrivate; -class MockSourceBufferPrivate : public SourceBufferPrivate { +class MockSourceBufferPrivate final : public SourceBufferPrivate { public: static RefPtr<MockSourceBufferPrivate> create(MockMediaSourcePrivate*); virtual ~MockSourceBufferPrivate(); @@ -62,25 +56,27 @@ private: explicit MockSourceBufferPrivate(MockMediaSourcePrivate*); // SourceBufferPrivate overrides - virtual void setClient(SourceBufferPrivateClient*) override; - virtual AppendResult append(const unsigned char* data, unsigned length) override; - virtual void abort() override; - virtual void removedFromMediaSource() override; - virtual MediaPlayer::ReadyState readyState() const override; - virtual void setReadyState(MediaPlayer::ReadyState) override; - virtual void evictCodedFrames() override; - virtual bool isFull() override; - - virtual void flushAndEnqueueNonDisplayingSamples(Vector<RefPtr<MediaSample>>, AtomicString) override { } - virtual void enqueueSample(PassRefPtr<MediaSample>, AtomicString) override; - virtual bool isReadyForMoreSamples(AtomicString) override { return true; } - virtual void setActive(bool) override; + void setClient(SourceBufferPrivateClient*) final; + void append(const unsigned char* data, unsigned length) final; + void abort() final; + void resetParserState() final; + void removedFromMediaSource() final; + MediaPlayer::ReadyState readyState() const final; + void setReadyState(MediaPlayer::ReadyState) final; + + void flush(const AtomicString&) final { m_enqueuedSamples.clear(); } + void enqueueSample(Ref<MediaSample>&&, const AtomicString&) final; + bool isReadyForMoreSamples(const AtomicString&) final { return true; } + void setActive(bool) final; + + Vector<String> enqueuedSamplesForTrackID(const AtomicString&) final; void didReceiveInitializationSegment(const MockInitializationBox&); void didReceiveSample(const MockSampleBox&); MockMediaSourcePrivate* m_mediaSource; SourceBufferPrivateClient* m_client; + Vector<String> m_enqueuedSamples; Vector<char> m_inputBuffer; }; @@ -88,6 +84,3 @@ private: } #endif // ENABLE(MEDIA_SOURCE) && USE(AVFOUNDATION) - -#endif - diff --git a/Source/WebCore/platform/mock/mediasource/MockTracks.h b/Source/WebCore/platform/mock/mediasource/MockTracks.h index 3f8eded74..073f36863 100644 --- a/Source/WebCore/platform/mock/mediasource/MockTracks.h +++ b/Source/WebCore/platform/mock/mediasource/MockTracks.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013-2017 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -10,10 +10,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -23,8 +23,7 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MockTracks_h -#define MockTracks_h +#pragma once #if ENABLE(MEDIA_SOURCE) @@ -37,7 +36,7 @@ namespace WebCore { class MockAudioTrackPrivate : public AudioTrackPrivate { public: - static RefPtr<MockAudioTrackPrivate> create(const MockTrackBox& box) { return adoptRef(new MockAudioTrackPrivate(box)); } + static Ref<MockAudioTrackPrivate> create(const MockTrackBox& box) { return adoptRef(*new MockAudioTrackPrivate(box)); } virtual ~MockAudioTrackPrivate() { } virtual AtomicString id() const { return m_id; } @@ -45,7 +44,7 @@ public: protected: MockAudioTrackPrivate(const MockTrackBox& box) : m_box(box) - , m_id(String::format("%d", box.trackID())) + , m_id(AtomicString::number(box.trackID())) { } MockTrackBox m_box; @@ -63,7 +62,7 @@ protected: MockTextTrackPrivate(const MockTrackBox& box) : InbandTextTrackPrivate(InbandTextTrackPrivate::Generic) , m_box(box) - , m_id(String::format("%d", box.trackID())) + , m_id(AtomicString::number(box.trackID())) { } MockTrackBox m_box; @@ -81,7 +80,7 @@ public: protected: MockVideoTrackPrivate(const MockTrackBox& box) : m_box(box) - , m_id(String::format("%d", box.trackID())) + , m_id(AtomicString::number(box.trackID())) { } MockTrackBox m_box; @@ -91,5 +90,3 @@ protected: } #endif - -#endif |