⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 243899 in webkit


Ignore:
Timestamp:
Apr 4, 2019, 1:44:29 PM (7 years ago)
Author:
eric.carlson@apple.com
Message:

[MediaStream] Host should be able to mute screen capture and camera/microphone independently
​https://bugs.webkit.org/show_bug.cgi?id=196555
<rdar://problem/47303865>

Reviewed by Youenn Fablet.

Source/WebCore:

Test: fast/mediastream/media-stream-page-muted.html

  • Modules/mediastream/MediaStream.cpp:

(WebCore::MediaStream::MediaStream): Call setCaptureTracksMuted to pass page muted
state to tracks.
(WebCore::MediaStream::startProducingData): Ditto.
(WebCore::MediaStream::setCaptureTracksMuted): New.

  • Modules/mediastream/MediaStream.h:
  • Modules/mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::MediaStreamTrack): Call setMuted with page muted state.
(WebCore::MediaStreamTrack::setMuted): Set muted according to page state and source type.
(WebCore::MediaStreamTrack::pageMutedStateDidChange): Call setMuted.
(WebCore::MediaStreamTrack::mediaState const): Update for new page state.

  • Modules/mediastream/MediaStreamTrack.h:
  • page/MediaProducer.h: Split capture muted state into two: camera/microphone and screen.
  • page/Page.h:

(WebCore::Page::isMediaCaptureMuted const): Update for state changes.

  • platform/mediastream/MediaStreamPrivate.cpp:

(WebCore::MediaStreamPrivate::setCaptureTracksMuted): Deleted.
(WebCore::MediaStreamPrivate::hasCaptureVideoSource const): Deleted.

  • platform/mediastream/MediaStreamPrivate.h:
  • platform/mediastream/RealtimeMediaSource.cpp:

(WebCore::RealtimeMediaSource::setMuted): Log state.
(WebCore::RealtimeMediaSource::notifyMutedChange): Call notifyMutedObservers on the
next runloop so events aren't dispatched synchronously.

  • testing/Internals.cpp:

(WebCore::Internals::setPageMuted): Add new state.

Source/WebKit:

  • UIProcess/API/C/WKPagePrivate.h: Add kWKMediaScreenCaptureMuted.
  • UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView _setPageMuted:]):
(-[WKWebView _setMediaCaptureMuted:]): Deleted, it was unused.
(-[WKWebView _muteMediaCapture]): Deleted, it was unused.

  • UIProcess/API/Cocoa/WKWebViewPrivate.h:
  • UIProcess/UserMediaPermissionRequestManagerProxy.cpp:

(WebKit::UserMediaPermissionRequestManagerProxy::processUserMediaPermissionValidRequest): Fix
a log comment typo.

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::setMediaStreamCaptureMuted): Use the new flag.
(WebKit::WebPageProxy::activateMediaStreamCaptureInPage): Ditto.
(WebKit::WebPageProxy::setMuted): Ditto.

  • UIProcess/WebPageProxy.h:

(WebKit::WebPageProxy::isMediaStreamCaptureMuted const): Ditto.

LayoutTests:

  • fast/mediastream/media-stream-page-muted-expected.txt: Added.
  • fast/mediastream/media-stream-page-muted.html: Added.
  • fast/mediastream/media-stream-track-interrupted.html: Read page muted state before

interrupting capture track because the page state now changes immediately.

  • fast/mediastream/media-stream-track-muted.html: Ditto, for muting.
Location:
trunk
Files:
2 added
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r243893 r243899  
     12019-04-04  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Host should be able to mute screen capture and camera/microphone independently
     4        https://bugs.webkit.org/show_bug.cgi?id=196555
     5        <rdar://problem/47303865>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * fast/mediastream/media-stream-page-muted-expected.txt: Added.
     10        * fast/mediastream/media-stream-page-muted.html: Added.
     11        * fast/mediastream/media-stream-track-interrupted.html: Read page muted state before
     12        interrupting capture track because the page state now changes immediately.
     13        * fast/mediastream/media-stream-track-muted.html: Ditto, for muting.
     14
    1152019-04-04  Antti Koivisto  <antti@apple.com>
    216

  • trunk/LayoutTests/fast/mediastream/media-stream-track-interrupted.html

    r237837 r243899  
    4646                track.onmute = () => {
    4747                    new Promise((innerResolve, innerReject) => {
    48                         waitForPageStateChange(10, internals.pageMediaState(), innerResolve, innerReject)
     48                        waitForPageStateChange(10, pageState, innerResolve, innerReject)
    4949                    }).then((pageMediaState) => {
    5050
    5151                        track.onunmute = (evt) => {
    52                             waitForPageStateChange(10, internals.pageMediaState(), resolve, reject)
     52                            waitForPageStateChange(10, pageState, resolve, reject)
    5353                        }
    5454
    … …  
    5858                            assert_true(pageMediaState.includes(isVideo ? 'HasActiveAudioCaptureDevice' : 'HasActiveVideoCaptureDevice'));
    5959                            assert_false(pageMediaState.includes(isVideo ? 'HasActiveVideoCaptureDevice' : 'HasActiveAudioCaptureDevice'));
     60                            pageState = internals.pageMediaState();
    6061                            internals.setMediaStreamSourceInterrupted(track, false)
    6162                        }
    … …  
    6364                }
    6465
    65                 if (window.internals)
     66                if (window.internals) {
     67                    pageState = internals.pageMediaState();
    6668                    internals.setMediaStreamSourceInterrupted(track, true);
     69                }
    6770                setTimeout(() => reject("Muted state did not change in 1 second"), 1000);
    6871            });

  • trunk/LayoutTests/fast/mediastream/media-stream-track-muted.html

    r217775 r243899  
    4040                track.onmute = () => {
    4141                    new Promise((innerResolve, innerReject) => {
    42                         waitForPageStateChange(10, internals.pageMediaState(), innerResolve, innerReject)
     42                        waitForPageStateChange(10, pageState, innerResolve, innerReject)
    4343                    }).then((pageMediaState) => {
    4444
    4545                        track.onunmute = (evt) => {
    46                             waitForPageStateChange(10, internals.pageMediaState(), resolve, reject)
     46                            waitForPageStateChange(10, pageState, resolve, reject)
    4747                        }
    4848
    … …  
    5252                            assert_true(pageMediaState.includes(isVideo ? 'HasActiveAudioCaptureDevice' : 'HasActiveVideoCaptureDevice'));
    5353                            assert_false(pageMediaState.includes(isVideo ? 'HasActiveVideoCaptureDevice' : 'HasActiveAudioCaptureDevice'));
     54                            pageState = internals.pageMediaState();
    5455                            internals.setMediaStreamTrackMuted(track, false)
    5556                        }
    … …  
    5758                }
    5859
    59                 if (window.internals)
     60                if (window.internals) {
     61                    pageState = internals.pageMediaState();
    6062                    internals.setMediaStreamTrackMuted(track, true);
     63                }
    6164                setTimeout(() => reject("Muted state did not change in .5 second"), 500);
    6265            });
    … …  
    7275    }, "Create stream");
    7376
    74 
    7577    </script>
    7678</head>

  • trunk/Source/WebCore/ChangeLog

    r243895 r243899  
     12019-04-04  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Host should be able to mute screen capture and camera/microphone independently
     4        https://bugs.webkit.org/show_bug.cgi?id=196555
     5        <rdar://problem/47303865>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        Test: fast/mediastream/media-stream-page-muted.html
     10
     11        * Modules/mediastream/MediaStream.cpp:
     12        (WebCore::MediaStream::MediaStream): Call setCaptureTracksMuted to pass page muted
     13        state to tracks.
     14        (WebCore::MediaStream::startProducingData): Ditto.
     15        (WebCore::MediaStream::setCaptureTracksMuted): New.
     16        * Modules/mediastream/MediaStream.h:
     17
     18        * Modules/mediastream/MediaStreamTrack.cpp:
     19        (WebCore::MediaStreamTrack::MediaStreamTrack): Call setMuted with page muted state.
     20        (WebCore::MediaStreamTrack::setMuted): Set muted according to page state and source type.
     21        (WebCore::MediaStreamTrack::pageMutedStateDidChange): Call setMuted.
     22        (WebCore::MediaStreamTrack::mediaState const): Update for new page state.
     23        * Modules/mediastream/MediaStreamTrack.h:
     24
     25        * page/MediaProducer.h: Split capture muted state into two: camera/microphone and screen.
     26
     27        * page/Page.h:
     28        (WebCore::Page::isMediaCaptureMuted const): Update for state changes.
     29
     30        * platform/mediastream/MediaStreamPrivate.cpp:
     31        (WebCore::MediaStreamPrivate::setCaptureTracksMuted): Deleted.
     32        (WebCore::MediaStreamPrivate::hasCaptureVideoSource const): Deleted.
     33        * platform/mediastream/MediaStreamPrivate.h:
     34
     35        * platform/mediastream/RealtimeMediaSource.cpp:
     36        (WebCore::RealtimeMediaSource::setMuted): Log state.
     37        (WebCore::RealtimeMediaSource::notifyMutedChange): Call notifyMutedObservers on the
     38        next runloop so events aren't dispatched synchronously.
     39
     40        * testing/Internals.cpp:
     41        (WebCore::Internals::setPageMuted): Add new state.
     42
    1432019-04-04  Chris Dumez  <cdumez@apple.com>
    244

  • trunk/Source/WebCore/Modules/mediastream/MediaStream.cpp

    r243887 r243899  
    120120#endif
    121121    setIsActive(m_private->active());
    122     if (document()->page() && document()->page()->isMediaCaptureMuted())
    123         m_private->setCaptureTracksMuted(true);
    124122    m_private->addObserver(*this);
    125123    MediaStreamRegistry::shared().registerStream(*this);
    … …  
    327325    m_mediaSession->canProduceAudioChanged();
    328326    m_private->startProducingData();
    329 
    330     if (document->page()->isMediaCaptureMuted())
    331         m_private->setCaptureTracksMuted(true);
    332327}
    333328

  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp

    r243887 r243899  
    7272    m_private->addObserver(*this);
    7373
    74     if (auto document = this->document())
     74    if (auto document = this->document()) {
    7575        document->addAudioProducer(*this);
     76        if (isCaptureTrack() && document->page() && document->page()->mutedState())
     77            setMuted(document->page()->mutedState());
     78    }
    7679}
    7780
    … …  
    170173{
    171174    return m_private->muted();
     175}
     176
     177void MediaStreamTrack::setMuted(MediaProducer::MutedStateFlags state)
     178{
     179    bool trackMuted = false;
     180    switch (source().deviceType()) {
     181    case CaptureDevice::DeviceType::Microphone:
     182    case CaptureDevice::DeviceType::Camera:
     183        trackMuted = state & AudioAndVideoCaptureIsMuted;
     184        break;
     185    case CaptureDevice::DeviceType::Screen:
     186    case CaptureDevice::DeviceType::Window:
     187        trackMuted = state & ScreenCaptureIsMuted;
     188        break;
     189    case CaptureDevice::DeviceType::Unknown:
     190        ASSERT_NOT_REACHED();
     191        break;
     192    }
     193
     194    m_private->setMuted(trackMuted);
    172195}
    173196
    … …  
    374397        return;
    375398
    376     m_private->setMuted(document->page()->isMediaCaptureMuted());
     399    setMuted(document->page()->mutedState());
    377400}
    378401
    … …  
    386409        return IsNotPlaying;
    387410
    388     bool pageCaptureMuted = document->page()->isMediaCaptureMuted();
    389 
    390411    if (source().type() == RealtimeMediaSource::Type::Audio) {
    391         if (source().interrupted() && !pageCaptureMuted)
     412        if (source().interrupted() && !source().muted())
    392413            return HasInterruptedAudioCaptureDevice;
    393414        if (muted())
    … …  
    398419        auto deviceType = source().deviceType();
    399420        ASSERT(deviceType == CaptureDevice::DeviceType::Camera || deviceType == CaptureDevice::DeviceType::Screen || deviceType == CaptureDevice::DeviceType::Window);
    400         if (source().interrupted() && !pageCaptureMuted)
     421        if (source().interrupted() && !source().muted())
    401422            return deviceType == CaptureDevice::DeviceType::Camera ? HasInterruptedVideoCaptureDevice : HasInterruptedDisplayCaptureDevice;
    402423        if (muted())
    … …  
    443464        return;
    444465
    445     AtomicString eventType = muted() ? eventNames().muteEvent : eventNames().unmuteEvent;
    446     dispatchEvent(Event::create(eventType, Event::CanBubble::No, Event::IsCancelable::No));
     466    m_eventTaskQueue.enqueueTask([this, muted = this->muted()] {
     467        AtomicString eventType = muted ? eventNames().muteEvent : eventNames().unmuteEvent;
     468        dispatchEvent(Event::create(eventType, Event::CanBubble::No, Event::IsCancelable::No));
     469    });
    447470
    448471    configureTrackRendering();

  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.h

    r243887 r243899  
    8383
    8484    bool muted() const;
     85    void setMuted(MediaProducer::MutedStateFlags);
    8586
    8687    enum class State { Live, Ended };
    … …  
    200201    Optional<DOMPromiseDeferred<void>> m_promise;
    201202    GenericTaskQueue<ScriptExecutionContext> m_taskQueue;
     203    GenericTaskQueue<Timer> m_eventTaskQueue;
    202204
    203205    bool m_ended { false };

  • trunk/Source/WebCore/page/MediaProducer.h

    r239840 r243899  
    5757        VideoCaptureMask = HasActiveVideoCaptureDevice | HasMutedVideoCaptureDevice | HasInterruptedVideoCaptureDevice,
    5858        DisplayCaptureMask = HasActiveDisplayCaptureDevice | HasMutedDisplayCaptureDevice | HasInterruptedDisplayCaptureDevice,
     59        MutedCaptureMask =  HasMutedAudioCaptureDevice | HasMutedVideoCaptureDevice | HasMutedDisplayCaptureDevice,
    5960        MediaCaptureMask = AudioCaptureMask | VideoCaptureMask | DisplayCaptureMask,
    6061    };
    … …  
    6869        NoneMuted = 0,
    6970        AudioIsMuted = 1 << 0,
    70         CaptureDevicesAreMuted = 1 << 1,
     71        AudioAndVideoCaptureIsMuted = 1 << 1,
     72        ScreenCaptureIsMuted = 1 << 2,
     73
     74        MediaStreamCaptureIsMuted = AudioAndVideoCaptureIsMuted | ScreenCaptureIsMuted,
    7175    };
    7276    typedef unsigned MutedStateFlags;

  • trunk/Source/WebCore/page/Page.h

    r243762 r243899  
    622622    MediaProducer::MutedStateFlags mutedState() const { return m_mutedState; }
    623623    bool isAudioMuted() const { return m_mutedState & MediaProducer::AudioIsMuted; }
    624     bool isMediaCaptureMuted() const { return m_mutedState & MediaProducer::CaptureDevicesAreMuted; };
     624    bool isMediaCaptureMuted() const { return m_mutedState & MediaProducer::MediaStreamCaptureIsMuted; };
    625625    void schedulePlaybackControlsManagerUpdate();
    626626    WEBCORE_EXPORT void setMuted(MediaProducer::MutedStateFlags);

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

    r243666 r243899  
    194194}
    195195
    196 void MediaStreamPrivate::setCaptureTracksMuted(bool muted)
    197 {
    198     ALWAYS_LOG(LOGIDENTIFIER, muted);
    199     for (auto& track : m_trackSet.values()) {
    200         if (track->isCaptureTrack())
    201             track->setMuted(muted);
    202     }
    203 }
    204 
    205196bool MediaStreamPrivate::hasVideo() const
    206197{

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

    r243033 r243899  
    106106    bool hasCaptureVideoSource() const;
    107107    bool hasCaptureAudioSource() const;
    108     void setCaptureTracksMuted(bool);
    109108
    110109    FloatSize intrinsicSize() const;

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

    r243033 r243899  
    9292void RealtimeMediaSource::setMuted(bool muted)
    9393{
    94     ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER);
     94    ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER, muted);
    9595
    9696    if (muted)
    … …  
    111111        return;
    112112
    113     ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER);
     113    ALWAYS_LOG_IF(m_logger, LOGIDENTIFIER, muted);
    114114    m_muted = muted;
    115115

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

    r243811 r243899  
    40534053            state |= MediaProducer::AudioIsMuted;
    40544054        if (equalLettersIgnoringASCIICase(stateString, "capturedevices"))
    4055             state |= MediaProducer::CaptureDevicesAreMuted;
     4055            state |= MediaProducer::AudioAndVideoCaptureIsMuted;
     4056        if (equalLettersIgnoringASCIICase(stateString, "screencapture"))
     4057            state |= MediaProducer::ScreenCaptureIsMuted;
    40564058    }
    40574059

  • trunk/Source/WebKit/ChangeLog

    r243888 r243899  
     12019-04-04  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Host should be able to mute screen capture and camera/microphone independently
     4        https://bugs.webkit.org/show_bug.cgi?id=196555
     5        <rdar://problem/47303865>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * UIProcess/API/C/WKPagePrivate.h: Add kWKMediaScreenCaptureMuted.
     10
     11        * UIProcess/API/Cocoa/WKWebView.mm:
     12        (-[WKWebView _setPageMuted:]):
     13        (-[WKWebView _setMediaCaptureMuted:]): Deleted, it was unused.
     14        (-[WKWebView _muteMediaCapture]): Deleted, it was unused.
     15        * UIProcess/API/Cocoa/WKWebViewPrivate.h:
     16
     17        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
     18        (WebKit::UserMediaPermissionRequestManagerProxy::processUserMediaPermissionValidRequest): Fix
     19        a log comment typo.
     20
     21        * UIProcess/WebPageProxy.cpp:
     22        (WebKit::WebPageProxy::setMediaStreamCaptureMuted): Use the new flag.
     23        (WebKit::WebPageProxy::activateMediaStreamCaptureInPage): Ditto.
     24        (WebKit::WebPageProxy::setMuted): Ditto.
     25        * UIProcess/WebPageProxy.h:
     26        (WebKit::WebPageProxy::isMediaStreamCaptureMuted const): Ditto.
     27
    1282019-04-04  Per Arne Vollan  <pvollan@apple.com>
    229

  • trunk/Source/WebKit/UIProcess/API/C/WKPagePrivate.h

    r241451 r243899  
    127127    kWKMediaAudioMuted = 1 << 0,
    128128    kWKMediaCaptureDevicesMuted = 1 << 1,
     129    kWKMediaScreenCaptureMuted = 1 << 2,
    129130};
    130131typedef uint32_t WKMediaMutedState;

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm

    r243787 r243899  
    57775777}
    57785778
    5779 - (void)_setMediaCaptureMuted:(BOOL)muted
    5780 {
    5781     _page->setMediaStreamCaptureMuted(muted);
    5782 }
    5783 
    5784 - (void)_muteMediaCapture
    5785 {
    5786     _page->setMediaStreamCaptureMuted(true);
    5787 }
    5788 
    57895779- (void)_setMediaCaptureEnabled:(BOOL)enabled
    57905780{
    … …  
    58045794        coreState |= WebCore::MediaProducer::AudioIsMuted;
    58055795    if (mutedState & _WKMediaCaptureDevicesMuted)
    5806         coreState |= WebCore::MediaProducer::CaptureDevicesAreMuted;
     5796        coreState |= WebCore::MediaProducer::AudioAndVideoCaptureIsMuted;
     5797    if (mutedState & _WKMediaScreenCaptureMuted)
     5798        coreState |= WebCore::MediaProducer::ScreenCaptureIsMuted;
    58075799
    58085800    _page->setMuted(coreState);

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivate.h

    r243523 r243899  
    5454    _WKMediaAudioMuted = 1 << 0,
    5555    _WKMediaCaptureDevicesMuted = 1 << 1,
     56    _WKMediaScreenCaptureMuted = 1 << 2,
    5657} WK_API_AVAILABLE(macos(10.13), ios(11.0));
    5758
    … …  
    408409@property (nonatomic, readonly) _WKMediaCaptureState _mediaCaptureState WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    409410
    410 - (void)_setMediaCaptureMuted:(BOOL)muted WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    411 - (void)_muteMediaCapture WK_API_AVAILABLE(macos(10.13), ios(11.0));
    412411- (void)_setPageMuted:(_WKMediaMutedState)mutedState WK_API_AVAILABLE(macos(10.13), ios(11.0));
    413412

  • trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp

    r243328 r243899  
    430430void UserMediaPermissionRequestManagerProxy::processUserMediaPermissionValidRequest(Ref<UserMediaPermissionRequestProxy>&& request, Vector<CaptureDevice>&& audioDevices, Vector<CaptureDevice>&& videoDevices, String&& deviceIdentifierHashSalt)
    431431{
    432     ALWAYS_LOG(LOGIDENTIFIER, request->userMediaID(), ", video:, ", videoDevices.size(), " audio: ", audioDevices.size());
     432    ALWAYS_LOG(LOGIDENTIFIER, request->userMediaID(), ", video: ", videoDevices.size(), " audio: ", audioDevices.size());
    433433    if (videoDevices.isEmpty() && audioDevices.isEmpty()) {
    434434        denyRequest(request->userMediaID(), UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints, emptyString());

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r243848 r243899  
    20572057{
    20582058    if (muted)
    2059         setMuted(m_mutedState | WebCore::MediaProducer::CaptureDevicesAreMuted);
     2059        setMuted(m_mutedState | WebCore::MediaProducer::MediaStreamCaptureIsMuted);
    20602060    else
    2061         setMuted(m_mutedState & ~WebCore::MediaProducer::CaptureDevicesAreMuted);
     2061        setMuted(m_mutedState & ~WebCore::MediaProducer::MediaStreamCaptureIsMuted);
    20622062}
    20632063
    … …  
    20672067    UserMediaProcessManager::singleton().muteCaptureMediaStreamsExceptIn(*this);
    20682068#endif
    2069     setMuted(m_mutedState & ~WebCore::MediaProducer::CaptureDevicesAreMuted);
     2069    setMuted(m_mutedState & ~WebCore::MediaProducer::MediaStreamCaptureIsMuted);
    20702070}
    20712071
    … …  
    53495349
    53505350#if ENABLE(MEDIA_STREAM)
    5351     bool hasMutedCaptureStreams = m_mediaState & (WebCore::MediaProducer::HasMutedAudioCaptureDevice | WebCore::MediaProducer::HasMutedVideoCaptureDevice);
    5352     if (hasMutedCaptureStreams && !(state & WebCore::MediaProducer::CaptureDevicesAreMuted))
     5351    bool hasMutedCaptureStreams = m_mediaState & WebCore::MediaProducer::MutedCaptureMask;
     5352    if (hasMutedCaptureStreams && !(state & WebCore::MediaProducer::MediaStreamCaptureIsMuted))
    53535353        UserMediaProcessManager::singleton().muteCaptureMediaStreamsExceptIn(*this);
    53545354#endif

  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r243861 r243899  
    615615
    616616    void activateMediaStreamCaptureInPage();
    617     bool isMediaStreamCaptureMuted() const { return m_mutedState & WebCore::MediaProducer::CaptureDevicesAreMuted; }
     617    bool isMediaStreamCaptureMuted() const { return m_mutedState & WebCore::MediaProducer::MediaStreamCaptureIsMuted; }
    618618    void setMediaStreamCaptureMuted(bool);
    619619    void executeEditCommand(const String& commandName, const String& argument, WTF::Function<void(CallbackBase::Error)>&&);
Note: See TracChangeset for help on using the changeset viewer.