Changeset 239024 in webkit


Ignore:
Timestamp:
Dec 9, 2018 9:30:23 PM (6 years ago)
Author:
youenn@apple.com
Message:

Move capture manager from RealtimeMediaSourceCenter to capture factory
​https://bugs.webkit.org/show_bug.cgi?id=192542

Reviewed by Eric Carlson.

Source/WebCore:

We should be able to run mock captures in wither UIProcess or WebProcess.
Currently, mock capture is only done in WebProcess.
This patch is a first step towards that goal.

It also simplifies RealtimeMediaSourceCenter implementation by starting to remove virtual methods.
Further refactoring will remove the need to subclass RealtimeMediaSourceCenter.
Instead, remaining virtual methods will become non virtual and their
implementation will become port specific.

Removed a JS internal method that is not longer used to further simplify RealtimeMediaSourceCenter.

No visible change of behavior.
Covered by existing tests.

  • platform/mediastream/CaptureDeviceManager.h:
  • platform/mediastream/RealtimeMediaSourceCenter.cpp:

(WebCore::RealtimeMediaSourceCenter::singleton):
(WebCore::RealtimeMediaSourceCenter::getMediaStreamDevices):
(WebCore::RealtimeMediaSourceCenter::getDisplayMediaDevices):
(WebCore::RealtimeMediaSourceCenter::getUserMediaDevices):
(WebCore::RealtimeMediaSourceCenter::captureDeviceWithPersistentID):
(WebCore::RealtimeMediaSourceCenter::unsetAudioFactory):
(WebCore::RealtimeMediaSourceCenter::unsetVideoFactory):
(WebCore::RealtimeMediaSourceCenter::unsetDisplayCaptureFactory):

  • platform/mediastream/RealtimeMediaSourceCenter.h:
  • platform/mediastream/RealtimeMediaSourceFactory.h:
  • platform/mediastream/gstreamer/GStreamerAudioCaptureSource.cpp:
  • platform/mediastream/gstreamer/GStreamerVideoCaptureSource.cpp:
  • platform/mediastream/gstreamer/RealtimeMediaSourceCenterLibWebRTC.cpp:
  • platform/mediastream/gstreamer/RealtimeMediaSourceCenterLibWebRTC.h:
  • platform/mediastream/mac/CoreAudioCaptureSource.cpp:

(WebCore::CoreAudioCaptureSourceFactory::audioCaptureDeviceManager):

  • platform/mediastream/mac/CoreAudioCaptureSource.h:
  • platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:
  • platform/mediastream/mac/RealtimeMediaSourceCenterMac.h:
  • platform/mock/MockRealtimeMediaSourceCenter.cpp:

(WebCore::MockRealtimeMediaSourceCenter::setMockRealtimeMediaSourceCenterEnabled):
(WebCore::MockRealtimeMediaSourceCenter::audioFactory):
(WebCore::MockRealtimeMediaSourceCenter::videoFactory):
(WebCore::MockRealtimeMediaSourceCenter::displayCaptureFactory):

  • platform/mock/MockRealtimeMediaSourceCenter.h:

(WebCore::MockRealtimeMediaSourceCenter::audioCaptureDeviceManager):
(WebCore::MockRealtimeMediaSourceCenter::videoCaptureDeviceManager):
(WebCore::MockRealtimeMediaSourceCenter::displayCaptureDeviceManager):

  • testing/Internals.cpp:
  • testing/Internals.h:
  • testing/Internals.idl:

Source/WebKit:

Make sure to unregister for video capture as done for other capture types.
Implement manager which should be doing nothing as the manager is used for enumeration of devices
which should only happen in UIProcess.

Given that mock capture is interfering with UserMediaCaptureManager,
switching on/off mock capture will require creating a new process.
This shortcoming should be fixed once mock capture will be fully happening in
the same process as regular capture.

  • WebProcess/cocoa/UserMediaCaptureManager.cpp:

(WebKit::UserMediaCaptureManager::~UserMediaCaptureManager):

  • WebProcess/cocoa/UserMediaCaptureManager.h:
Location:
trunk/Source
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r239018 r239024  
     12018-12-09  Youenn Fablet  <youenn@apple.com>
     2
     3        Move capture manager from RealtimeMediaSourceCenter to capture factory
     4        https://bugs.webkit.org/show_bug.cgi?id=192542
     5
     6        Reviewed by Eric Carlson.
     7
     8        We should be able to run mock captures in wither UIProcess or WebProcess.
     9        Currently, mock capture is only done in WebProcess.
     10        This patch is a first step towards that goal.
     11
     12        It also simplifies RealtimeMediaSourceCenter implementation by starting to remove virtual methods.
     13        Further refactoring will remove the need to subclass RealtimeMediaSourceCenter.
     14        Instead, remaining virtual methods will become non virtual and their
     15        implementation will become port specific.
     16
     17        Removed a JS internal method that is not longer used to further simplify RealtimeMediaSourceCenter.
     18
     19        No visible change of behavior.
     20        Covered by existing tests.
     21
     22        * platform/mediastream/CaptureDeviceManager.h:
     23        * platform/mediastream/RealtimeMediaSourceCenter.cpp:
     24        (WebCore::RealtimeMediaSourceCenter::singleton):
     25        (WebCore::RealtimeMediaSourceCenter::getMediaStreamDevices):
     26        (WebCore::RealtimeMediaSourceCenter::getDisplayMediaDevices):
     27        (WebCore::RealtimeMediaSourceCenter::getUserMediaDevices):
     28        (WebCore::RealtimeMediaSourceCenter::captureDeviceWithPersistentID):
     29        (WebCore::RealtimeMediaSourceCenter::unsetAudioFactory):
     30        (WebCore::RealtimeMediaSourceCenter::unsetVideoFactory):
     31        (WebCore::RealtimeMediaSourceCenter::unsetDisplayCaptureFactory):
     32        * platform/mediastream/RealtimeMediaSourceCenter.h:
     33        * platform/mediastream/RealtimeMediaSourceFactory.h:
     34        * platform/mediastream/gstreamer/GStreamerAudioCaptureSource.cpp:
     35        * platform/mediastream/gstreamer/GStreamerVideoCaptureSource.cpp:
     36        * platform/mediastream/gstreamer/RealtimeMediaSourceCenterLibWebRTC.cpp:
     37        * platform/mediastream/gstreamer/RealtimeMediaSourceCenterLibWebRTC.h:
     38        * platform/mediastream/mac/CoreAudioCaptureSource.cpp:
     39        (WebCore::CoreAudioCaptureSourceFactory::audioCaptureDeviceManager):
     40        * platform/mediastream/mac/CoreAudioCaptureSource.h:
     41        * platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:
     42        * platform/mediastream/mac/RealtimeMediaSourceCenterMac.h:
     43        * platform/mock/MockRealtimeMediaSourceCenter.cpp:
     44        (WebCore::MockRealtimeMediaSourceCenter::setMockRealtimeMediaSourceCenterEnabled):
     45        (WebCore::MockRealtimeMediaSourceCenter::audioFactory):
     46        (WebCore::MockRealtimeMediaSourceCenter::videoFactory):
     47        (WebCore::MockRealtimeMediaSourceCenter::displayCaptureFactory):
     48        * platform/mock/MockRealtimeMediaSourceCenter.h:
     49        (WebCore::MockRealtimeMediaSourceCenter::audioCaptureDeviceManager):
     50        (WebCore::MockRealtimeMediaSourceCenter::videoCaptureDeviceManager):
     51        (WebCore::MockRealtimeMediaSourceCenter::displayCaptureDeviceManager):
     52        * testing/Internals.cpp:
     53        * testing/Internals.h:
     54        * testing/Internals.idl:
     55
    1562018-12-09  Commit Queue  <commit-queue@webkit.org>
    257

  • trunk/Source/WebCore/platform/mediastream/CaptureDeviceManager.h

    r235086 r239024  
    3434namespace WebCore {
    3535
    36 class CaptureDeviceManager : public CanMakeWeakPtr<CaptureDeviceManager> {
     36class WEBCORE_EXPORT CaptureDeviceManager : public CanMakeWeakPtr<CaptureDeviceManager> {
    3737public:
    3838    virtual const Vector<CaptureDevice>& captureDevices() = 0;

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.cpp

    r237234 r239024  
    3636#if ENABLE(MEDIA_STREAM)
    3737
    38 // FIXME: GTK to implement its own RealtimeMediaSourceCenter.
    39 #if PLATFORM(GTK)
    40 #include "MockRealtimeMediaSourceCenter.h"
    41 #endif
    42 
    4338#include "CaptureDeviceManager.h"
    4439#include "Logging.h"
    … …  
    4843namespace WebCore {
    4944
    50 static RealtimeMediaSourceCenter*& mediaStreamCenterOverride()
    51 {
    52     static RealtimeMediaSourceCenter* override;
    53     return override;
    54 }
    5545
    5646RealtimeMediaSourceCenter& RealtimeMediaSourceCenter::singleton()
    5747{
    58     RealtimeMediaSourceCenter* override = mediaStreamCenterOverride();
    59     if (override)
    60         return *override;
    6148    return RealtimeMediaSourceCenter::platformCenter();
    62 }
    63 
    64 void RealtimeMediaSourceCenter::setSharedStreamCenterOverride(RealtimeMediaSourceCenter* center)
    65 {
    66     mediaStreamCenterOverride() = center;
    6749}
    6850
    … …  
    125107{
    126108    Vector<CaptureDevice> result;
    127     for (auto& device : audioCaptureDeviceManager().captureDevices()) {
     109    for (auto& device : audioFactory().audioCaptureDeviceManager().captureDevices()) {
    128110        if (device.enabled())
    129111            result.append(device);
    130112    }
    131     for (auto& device : videoCaptureDeviceManager().captureDevices()) {
     113    for (auto& device : videoFactory().videoCaptureDeviceManager().captureDevices()) {
    132114        if (device.enabled())
    133115            result.append(device);
    134116    }
    135     for (auto& device : displayCaptureDeviceManager().captureDevices()) {
     117    for (auto& device : displayCaptureFactory().displayCaptureDeviceManager().captureDevices()) {
    136118        if (device.enabled())
    137119            result.append(device);
    … …  
    173155}
    174156
    175 CaptureDevice RealtimeMediaSourceCenter::captureDeviceWithUniqueID(const String& uniqueID, const String& idHashSalt)
    176 {
    177     for (auto& device : getMediaStreamDevices()) {
    178         if (uniqueID == hashStringWithSalt(device.persistentId(), idHashSalt))
    179             return device;
    180     }
    181 
    182     return { };
    183 }
    184 
    185 ExceptionOr<void> RealtimeMediaSourceCenter::setDeviceEnabled(const String& id, bool enabled)
    186 {
    187     for (auto& captureDevice : getMediaStreamDevices()) {
    188         if (id == captureDevice.persistentId()) {
    189             if (enabled != captureDevice.enabled()) {
    190                 captureDevice.setEnabled(enabled);
    191                 captureDevicesChanged();
    192             }
    193 
    194             return { };
    195         }
    196     }
    197 
    198     return Exception { NotFoundError };
    199 }
    200 
    201157void RealtimeMediaSourceCenter::setDevicesChangedObserver(std::function<void()>&& observer)
    202158{
    … …  
    219175
    220176    String invalidConstraint;
    221     for (auto& device : displayCaptureDeviceManager().captureDevices()) {
     177    for (auto& device : displayCaptureFactory().displayCaptureDeviceManager().captureDevices()) {
    222178        if (!device.enabled())
    223179            return;
    … …  
    236192    String invalidConstraint;
    237193    if (request.audioConstraints.isValid) {
    238         for (auto& device : audioCaptureDeviceManager().captureDevices()) {
     194        for (auto& device : audioFactory().audioCaptureDeviceManager().captureDevices()) {
    239195            if (!device.enabled())
    240196                continue;
    … …  
    250206
    251207    if (request.videoConstraints.isValid) {
    252         for (auto& device : videoCaptureDeviceManager().captureDevices()) {
     208        for (auto& device : videoFactory().videoCaptureDeviceManager().captureDevices()) {
    253209            if (!device.enabled())
    254210                continue;
    … …  
    315271    switch (type) {
    316272    case CaptureDevice::DeviceType::Camera:
    317         return videoCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
     273        return videoFactory().videoCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
    318274        break;
    319275    case CaptureDevice::DeviceType::Microphone:
    320         return audioCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
     276        return audioFactory().audioCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
    321277        break;
    322278    case CaptureDevice::DeviceType::Screen:
    … …  
    324280    case CaptureDevice::DeviceType::Window:
    325281    case CaptureDevice::DeviceType::Browser:
    326         return displayCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
     282        return displayCaptureFactory().displayCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
    327283        break;
    328284    case CaptureDevice::DeviceType::Unknown:
    … …  
    342298{
    343299    ASSERT_UNUSED(oldOverride, audioFactoryOverride == &oldOverride);
    344     audioFactoryOverride = nullptr;
     300    if (&oldOverride == audioFactoryOverride)
     301        audioFactoryOverride = nullptr;
    345302}
    346303
    … …  
    358315{
    359316    ASSERT_UNUSED(oldOverride, videoFactoryOverride == &oldOverride);
    360     videoFactoryOverride = nullptr;
     317    if (&oldOverride == videoFactoryOverride)
     318        videoFactoryOverride = nullptr;
    361319}
    362320
    … …  
    374332{
    375333    ASSERT_UNUSED(oldOverride, displayCaptureFactoryOverride == &oldOverride);
    376     displayCaptureFactoryOverride = nullptr;
     334    if (&oldOverride == displayCaptureFactoryOverride)
     335        displayCaptureFactoryOverride = nullptr;
    377336}
    378337

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.h

    r238796 r239024  
    5656class RealtimeMediaSourceCenter {
    5757public:
     58    static RealtimeMediaSourceCenter& platformCenter();
    5859    virtual ~RealtimeMediaSourceCenter();
    5960
    6061    WEBCORE_EXPORT static RealtimeMediaSourceCenter& singleton();
    61     static void setSharedStreamCenterOverride(RealtimeMediaSourceCenter*);
    6262
    6363    using ValidConstraintsHandler = WTF::Function<void(Vector<CaptureDevice>&& audioDeviceUIDs, Vector<CaptureDevice>&& videoDeviceUIDs, String&&)>;
    … …  
    6868    virtual void createMediaStream(NewMediaStreamHandler&&, String&&, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest&);
    6969
    70     WEBCORE_EXPORT virtual Vector<CaptureDevice> getMediaStreamDevices();
     70    WEBCORE_EXPORT Vector<CaptureDevice> getMediaStreamDevices();
    7171    WEBCORE_EXPORT std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
    7272   
    … …  
    8585    WEBCORE_EXPORT static void unsetDisplayCaptureFactory(DisplayCaptureFactory&);
    8686
    87     virtual CaptureDeviceManager& audioCaptureDeviceManager() = 0;
    88     virtual CaptureDeviceManager& videoCaptureDeviceManager() = 0;
    89     virtual CaptureDeviceManager& displayCaptureDeviceManager() = 0;
    90 
    9187    WEBCORE_EXPORT String hashStringWithSalt(const String& id, const String& hashSalt);
    92     WEBCORE_EXPORT CaptureDevice captureDeviceWithUniqueID(const String& id, const String& hashSalt);
    93     WEBCORE_EXPORT ExceptionOr<void> setDeviceEnabled(const String&, bool);
    9488
    9589    WEBCORE_EXPORT void setDevicesChangedObserver(std::function<void()>&&);
    … …  
    10296    RealtimeMediaSourceCenter();
    10397
    104     static RealtimeMediaSourceCenter& platformCenter();
    10598    RealtimeMediaSourceSupportedConstraints m_supportedConstraints;
    10699

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceFactory.h

    r237266 r239024  
    3333
    3434class CaptureDevice;
     35class CaptureDeviceManager;
    3536class RealtimeMediaSource;
    3637
    … …  
    5657    virtual ~AudioCaptureFactory() = default;
    5758    virtual CaptureSourceOrError createAudioCaptureSource(const CaptureDevice&, String&&, const MediaConstraints*) = 0;
     59    virtual CaptureDeviceManager& audioCaptureDeviceManager() = 0;
    5860
    5961protected:
    … …  
    6971    virtual ~VideoCaptureFactory() = default;
    7072    virtual CaptureSourceOrError createVideoCaptureSource(const CaptureDevice&, String&&, const MediaConstraints*) = 0;
     73    virtual CaptureDeviceManager& videoCaptureDeviceManager() = 0;
    7174    virtual void setVideoCapturePageState(bool, bool) { }
    7275
    … …  
    7982    virtual ~DisplayCaptureFactory() = default;
    8083    virtual CaptureSourceOrError createDisplayCaptureSource(const CaptureDevice&, const MediaConstraints*) = 0;
     84    virtual CaptureDeviceManager& displayCaptureDeviceManager() = 0;
    8185    virtual void setDisplayCapturePageState(bool , bool) { }
    8286

  • trunk/Source/WebCore/platform/mediastream/gstreamer/GStreamerAudioCaptureSource.cpp

    r236877 r239024  
    5858        return GStreamerAudioCaptureSource::create(String { device.persistentId() }, WTFMove(hashSalt), constraints);
    5959    }
     60private:
     61    CaptureDeviceManager& audioCaptureDeviceManager() final { return GStreamerAudioCaptureDeviceManager::singleton(); }
    6062};
    6163

  • trunk/Source/WebCore/platform/mediastream/gstreamer/GStreamerVideoCaptureSource.cpp

    r238607 r239024  
    7272        return GStreamerVideoCaptureSource::create(String { device.persistentId() }, WTFMove(hashSalt), constraints);
    7373    }
     74private:
     75    CaptureDeviceManager& videoCaptureDeviceManager() final { return GStreamerVideoCaptureDeviceManager::singleton(); }
    7476};
    7577
    … …  
    8789        return { };
    8890    }
     91private:
     92    CaptureDeviceManager& displayCaptureDeviceManager() final { return GStreamerDisplayCaptureDeviceManager::singleton(); }
    8993};
    9094

  • trunk/Source/WebCore/platform/mediastream/gstreamer/RealtimeMediaSourceCenterLibWebRTC.cpp

    r237234 r239024  
    2727#include "GStreamerAudioCaptureSource.h"
    2828#include "GStreamerCaptureDevice.h"
    29 #include "GStreamerCaptureDeviceManager.h"
    3029#include "GStreamerVideoCaptureSource.h"
    3130#include <wtf/MainThread.h>
    … …  
    6867}
    6968
    70 CaptureDeviceManager& RealtimeMediaSourceCenterLibWebRTC::audioCaptureDeviceManager()
    71 {
    72     return GStreamerAudioCaptureDeviceManager::singleton();
    73 }
    74 
    75 CaptureDeviceManager& RealtimeMediaSourceCenterLibWebRTC::videoCaptureDeviceManager()
    76 {
    77     return GStreamerVideoCaptureDeviceManager::singleton();
    78 }
    79 
    80 CaptureDeviceManager& RealtimeMediaSourceCenterLibWebRTC::displayCaptureDeviceManager()
    81 {
    82     return GStreamerDisplayCaptureDeviceManager::singleton();
    83 }
    84 
    8569} // namespace WebCore
    8670

  • trunk/Source/WebCore/platform/mediastream/gstreamer/RealtimeMediaSourceCenterLibWebRTC.h

    r237234 r239024  
    4747    VideoCaptureFactory& videoFactoryPrivate() final;
    4848    DisplayCaptureFactory& displayCaptureFactoryPrivate() final;
    49 
    50     CaptureDeviceManager& audioCaptureDeviceManager() final;
    51     CaptureDeviceManager& videoCaptureDeviceManager() final;
    52     CaptureDeviceManager& displayCaptureDeviceManager() final;
    53 
    54     AudioCaptureFactory* m_audioFactoryOverride { nullptr };
    5549};
    5650

  • trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.cpp

    r237837 r239024  
    775775}
    776776
     777CaptureDeviceManager& CoreAudioCaptureSourceFactory::audioCaptureDeviceManager()
     778{
     779#if PLATFORM(MAC)
     780    return CoreAudioCaptureDeviceManager::singleton();
     781#else
     782    return AVAudioSessionCaptureDeviceManager::singleton();
     783#endif
     784}
     785
    777786CoreAudioCaptureSource::CoreAudioCaptureSource(String&& deviceID, String&& label, String&& hashSalt, uint32_t persistentID)
    778787    : RealtimeMediaSource(RealtimeMediaSource::Type::Audio, WTFMove(label), WTFMove(deviceID), WTFMove(hashSalt))

  • trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h

    r237266 r239024  
    131131        return CoreAudioCaptureSource::create(String { device.persistentId() }, WTFMove(hashSalt), constraints);
    132132    }
     133
     134    CaptureDeviceManager& audioCaptureDeviceManager() final;
    133135};
    134136

  • trunk/Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp

    r237266 r239024  
    3434#include "RealtimeMediaSourceCenterMac.h"
    3535
    36 #include "AVAudioSessionCaptureDeviceManager.h"
    3736#include "AVCaptureDeviceManager.h"
    3837#include "AVVideoCaptureSource.h"
    39 #include "CoreAudioCaptureDeviceManager.h"
    4038#include "CoreAudioCaptureSource.h"
    4139#include "DisplayCaptureManagerCocoa.h"
    … …  
    5654    }
    5755
     56private:
    5857#if PLATFORM(IOS_FAMILY)
    59 private:
    6058    void setVideoCapturePageState(bool interrupted, bool pageMuted)
    6159    {
    … …  
    6462    }
    6563#endif
     64
     65    CaptureDeviceManager& videoCaptureDeviceManager() { return AVCaptureDeviceManager::singleton(); }
    6666};
    6767
    … …  
    9494        return { };
    9595    }
     96private:
     97    CaptureDeviceManager& displayCaptureDeviceManager() { return DisplayCaptureManagerCocoa::singleton(); }
    9698};
    9799
    … …  
    130132}
    131133
    132 CaptureDeviceManager& RealtimeMediaSourceCenterMac::audioCaptureDeviceManager()
    133 {
    134 #if PLATFORM(MAC)
    135     return CoreAudioCaptureDeviceManager::singleton();
    136 #else
    137     return AVAudioSessionCaptureDeviceManager::singleton();
    138 #endif
    139 }
    140 
    141 CaptureDeviceManager& RealtimeMediaSourceCenterMac::videoCaptureDeviceManager()
    142 {
    143     return AVCaptureDeviceManager::singleton();
    144 }
    145 
    146 CaptureDeviceManager& RealtimeMediaSourceCenterMac::displayCaptureDeviceManager()
    147 {
    148     return DisplayCaptureManagerCocoa::singleton();
    149 }
    150 
    151134} // namespace WebCore
    152135

  • trunk/Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.h

    r237234 r239024  
    5353    VideoCaptureFactory& videoFactoryPrivate() final;
    5454    DisplayCaptureFactory& displayCaptureFactoryPrivate() final;
    55 
    56     CaptureDeviceManager& audioCaptureDeviceManager() final;
    57     CaptureDeviceManager& videoCaptureDeviceManager() final;
    58     CaptureDeviceManager& displayCaptureDeviceManager() final;
    59 
    60     AudioCaptureFactory* m_audioFactoryOverride { nullptr };
    6155};
    6256

  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp

    r237266 r239024  
    9595    }
    9696
     97private:
    9798#if PLATFORM(IOS_FAMILY)
    98 private:
    9999    void setVideoCapturePageState(bool interrupted, bool pageMuted)
    100100    {
    … …  
    103103    }
    104104#endif
     105    CaptureDeviceManager& videoCaptureDeviceManager() final { return MockRealtimeMediaSourceCenter::singleton().videoCaptureDeviceManager(); }
    105106};
    106107
    … …  
    127128        return { };
    128129    }
     130private:
     131    CaptureDeviceManager& displayCaptureDeviceManager() final { return MockRealtimeMediaSourceCenter::singleton().displayCaptureDeviceManager(); }
    129132};
    130133
    … …  
    138141        return MockRealtimeAudioSource::create(String { device.persistentId() }, String { device.label() }, WTFMove(hashSalt), constraints);
    139142    }
     143private:
     144    CaptureDeviceManager& audioCaptureDeviceManager() final { return MockRealtimeMediaSourceCenter::singleton().audioCaptureDeviceManager(); }
    140145};
    141146
    … …  
    180185{
    181186    static bool active = false;
    182     if (active != enabled) {
    183         active = enabled;
    184         RealtimeMediaSourceCenter::setSharedStreamCenterOverride(enabled ? &singleton() : nullptr);
    185     }
     187    if (active == enabled)
     188        return;
     189
     190    active = enabled;
     191
     192    RealtimeMediaSourceCenter& center = RealtimeMediaSourceCenter::singleton();
     193    MockRealtimeMediaSourceCenter& mock = singleton();
     194
     195    if (active) {
     196        center.setAudioFactory(mock.audioFactory());
     197        center.setVideoFactory(mock.videoFactory());
     198        center.setDisplayCaptureFactory(mock.displayCaptureFactory());
     199        return;
     200    }
     201
     202    center.unsetAudioFactory(mock.audioFactory());
     203    center.unsetVideoFactory(mock.videoFactory());
     204    center.unsetDisplayCaptureFactory(mock.displayCaptureFactory());
    186205}
    187206
    … …  
    311330}
    312331
    313 AudioCaptureFactory& MockRealtimeMediaSourceCenter::audioFactoryPrivate()
     332AudioCaptureFactory& MockRealtimeMediaSourceCenter::audioFactory()
    314333{
    315334    static NeverDestroyed<MockRealtimeAudioSourceFactory> factory;
    … …  
    317336}
    318337
    319 VideoCaptureFactory& MockRealtimeMediaSourceCenter::videoFactoryPrivate()
     338VideoCaptureFactory& MockRealtimeMediaSourceCenter::videoFactory()
    320339{
    321340    static NeverDestroyed<MockRealtimeVideoSourceFactory> factory;
    … …  
    323342}
    324343
    325 DisplayCaptureFactory& MockRealtimeMediaSourceCenter::displayCaptureFactoryPrivate()
     344DisplayCaptureFactory& MockRealtimeMediaSourceCenter::displayCaptureFactory()
    326345{
    327346    static NeverDestroyed<MockRealtimeDisplaySourceFactory> factory;

  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h

    r237234 r239024  
    3737namespace WebCore {
    3838
    39 class MockRealtimeMediaSourceCenter final : public RealtimeMediaSourceCenter {
     39class MockRealtimeMediaSourceCenter {
    4040public:
     41    static MockRealtimeMediaSourceCenter& singleton();
     42
    4143    WEBCORE_EXPORT static void setMockRealtimeMediaSourceCenterEnabled(bool);
    4244
    … …  
    5355    static std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
    5456
     57    CaptureDeviceManager& audioCaptureDeviceManager() { return m_audioCaptureDeviceManager; }
     58    CaptureDeviceManager& videoCaptureDeviceManager() { return m_videoCaptureDeviceManager; }
     59    CaptureDeviceManager& displayCaptureDeviceManager() { return m_displayCaptureDeviceManager; }
     60
    5561private:
    5662    MockRealtimeMediaSourceCenter() = default;
    5763    friend NeverDestroyed<MockRealtimeMediaSourceCenter>;
    5864
    59     static MockRealtimeMediaSourceCenter& singleton();
    60 
    61     AudioCaptureFactory& audioFactoryPrivate() final;
    62     VideoCaptureFactory& videoFactoryPrivate() final;
    63     DisplayCaptureFactory& displayCaptureFactoryPrivate() final;
    64 
    65     CaptureDeviceManager& audioCaptureDeviceManager() final { return m_audioCaptureDeviceManager; }
    66     CaptureDeviceManager& videoCaptureDeviceManager() final { return m_videoCaptureDeviceManager; }
    67     CaptureDeviceManager& displayCaptureDeviceManager() final { return m_displayCaptureDeviceManager; }
     65    AudioCaptureFactory& audioFactory();
     66    VideoCaptureFactory& videoFactory();
     67    DisplayCaptureFactory& displayCaptureFactory();
    6868
    6969    class MockAudioCaptureDeviceManager final : public CaptureDeviceManager {

  • trunk/Source/WebCore/testing/Internals.cpp

    r238902 r239024  
    45344534}
    45354535
    4536 ExceptionOr<void> Internals::setMediaDeviceState(const String& id, const String& property, bool value)
    4537 {
    4538     auto* document = contextDocument();
    4539     if (!document)
    4540         return Exception { InvalidAccessError, "No context document"_s };
    4541 
    4542     if (!equalLettersIgnoringASCIICase(property, "enabled"))
    4543         return Exception { InvalidAccessError, makeString("\"" + property, "\" is not a valid property for this method.") };
    4544 
    4545     auto salt = document->deviceIDHashSalt();
    4546     CaptureDevice device = RealtimeMediaSourceCenter::singleton().captureDeviceWithUniqueID(id, salt);
    4547     if (!device)
    4548         return Exception { InvalidAccessError, makeString("device with ID \"" + id, "\" not found.") };
    4549 
    4550     auto result = RealtimeMediaSourceCenter::singleton().setDeviceEnabled(device.persistentId(), value);
    4551     if (result.hasException())
    4552         return result.releaseException();
    4553 
    4554     return { };
    4555 }
    4556 
    45574536void Internals::delayMediaStreamTrackSamples(MediaStreamTrack& track, float delay)
    45584537{

  • trunk/Source/WebCore/testing/Internals.h

    r238902 r239024  
    678678#if ENABLE(MEDIA_STREAM)
    679679    void setCameraMediaStreamTrackOrientation(MediaStreamTrack&, int orientation);
    680     ExceptionOr<void> setMediaDeviceState(const String& id, const String& property, bool value);
    681680    unsigned long trackAudioSampleCount() const { return m_trackAudioSampleCount; }
    682681    unsigned long trackVideoSampleCount() const { return m_trackVideoSampleCount; }

  • trunk/Source/WebCore/testing/Internals.idl

    r238902 r239024  
    665665    [Conditional=MEDIA_STREAM] readonly attribute unsigned long trackAudioSampleCount;
    666666    [Conditional=MEDIA_STREAM] readonly attribute unsigned long trackVideoSampleCount;
    667     [Conditional=MEDIA_STREAM, MayThrowException] void setMediaDeviceState(DOMString deviceID, DOMString property, boolean value);
    668667    [Conditional=MEDIA_STREAM] void delayMediaStreamTrackSamples(MediaStreamTrack track, float delay);
    669668    [Conditional=MEDIA_STREAM] void setMediaStreamTrackMuted(MediaStreamTrack track, boolean muted);

  • trunk/Source/WebKit/ChangeLog

    r239023 r239024  
     12018-12-09  Youenn Fablet  <youenn@apple.com>
     2
     3        Move capture manager from RealtimeMediaSourceCenter to capture factory
     4        https://bugs.webkit.org/show_bug.cgi?id=192542
     5
     6        Reviewed by Eric Carlson.
     7
     8        Make sure to unregister for video capture as done for other capture types.
     9        Implement manager which should be doing nothing as the manager is used for enumeration of devices
     10        which should only happen in UIProcess.
     11
     12        Given that mock capture is interfering with UserMediaCaptureManager,
     13        switching on/off mock capture will require creating a new process.
     14        This shortcoming should be fixed once mock capture will be fully happening in
     15        the same process as regular capture.
     16
     17        * WebProcess/cocoa/UserMediaCaptureManager.cpp:
     18        (WebKit::UserMediaCaptureManager::~UserMediaCaptureManager):
     19        * WebProcess/cocoa/UserMediaCaptureManager.h:
     20
    1212018-12-09  Saam barati  <sbarati@apple.com>
    222

  • trunk/Source/WebKit/WebProcess/cocoa/UserMediaCaptureManager.cpp

    r238909 r239024  
    208208    RealtimeMediaSourceCenter::unsetAudioFactory(*this);
    209209    RealtimeMediaSourceCenter::unsetDisplayCaptureFactory(*this);
     210    RealtimeMediaSourceCenter::unsetVideoFactory(*this);
    210211    m_process.removeMessageReceiver(Messages::UserMediaCaptureManager::messageReceiverName());
    211212}

  • trunk/Source/WebKit/WebProcess/cocoa/UserMediaCaptureManager.h

    r237281 r239024  
    3131#include "SharedMemory.h"
    3232#include "WebProcessSupplement.h"
     33#include <WebCore/CaptureDeviceManager.h>
    3334#include <WebCore/RealtimeMediaSource.h>
    3435#include <WebCore/RealtimeMediaSourceFactory.h>
    … …  
    6263    WebCore::CaptureSourceOrError createCaptureSource(const WebCore::CaptureDevice&, String&&, const WebCore::MediaConstraints*);
    6364
     65    class NoOpCaptureDeviceManager : public WebCore::CaptureDeviceManager {
     66    public:
     67        NoOpCaptureDeviceManager() = default;
     68
     69    private:
     70        const Vector<WebCore::CaptureDevice>& captureDevices() final
     71        {
     72            ASSERT_NOT_REACHED();
     73            return m_emptyDevices;
     74        }
     75        Vector<WebCore::CaptureDevice> m_emptyDevices;
     76    };
     77
     78    WebCore::CaptureDeviceManager& audioCaptureDeviceManager() final { return m_noOpCaptureDeviceManager; }
     79    WebCore::CaptureDeviceManager& videoCaptureDeviceManager() final { return m_noOpCaptureDeviceManager; }
     80    WebCore::CaptureDeviceManager& displayCaptureDeviceManager() final { return m_noOpCaptureDeviceManager; }
     81
    6482    // IPC::MessageReceiver
    6583    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
    … …  
    87105    HashMap<uint64_t, RefPtr<Source>> m_sources;
    88106    WebProcess& m_process;
     107    NoOpCaptureDeviceManager m_noOpCaptureDeviceManager;
    89108};
    90109
Note: See TracChangeset for help on using the changeset viewer.