Changeset 194397 in webkit


Ignore:
Timestamp:
Dec 23, 2015 2:51:28 PM (8 years ago)
Author:
eric.carlson@apple.com
Message:

[MediaStream] MediaDeviceInfo.label must be empty in some situations
https://bugs.webkit.org/show_bug.cgi?id=152000

Reviewed by Brent Fulgham.

Source/WebCore:

No new tests, updated fast/mediastream/MediaDevices-enumerateDevices.html.

  • Modules/mediastream/CaptureDeviceManager.cpp:

(CaptureDeviceManager::getSourcesInfo): TrackSourceInfo constructor takes persistent ID.

  • Modules/mediastream/MediaDevicesRequest.cpp:

(WebCore::MediaDevicesRequest::start): If Document had an active stream track, don't bother

checking for a persistent permission to access devices.

(WebCore::MediaDevicesRequest::didCompleteCheck): m_hasUserMediaPermission -> m_canShowLabels.
(WebCore::MediaDevicesRequest::getTrackSources): New, factored out of didCompleteCheck so it

can be called when we don't need to check permissions.

(WebCore::MediaDevicesRequest::didCompleteRequest): m_hasUserMediaPermission -> m_canShowLabels.

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

(WebCore::MediaStream::MediaStream): Call setIsActive. Register new stream with MediaStreamRegistry.
(WebCore::MediaStream::~MediaStream): Unregister stream with MediaStreamRegistry.
(WebCore::MediaStream::setIsActive): New. Set m_isActive and call Document if stream is active.
(WebCore::MediaStream::scheduleActiveStateChange): Call setIsActive.
(WebCore::MediaStream::registry): MediaStreamRegistry::registry -> MediaStreamRegistry::shared.
(WebCore::mediaStreams): Deleted. Drive-by cleanup: moved list of all streams to MediaStreamRegistry.
(WebCore::registerMediaStream): Ditto.
(WebCore::unRegisterMediaStream): Ditto.
(WebCore::MediaStream::lookUp): Ditto.
(WebCore::MediaStream::setRegistry): Ditto.

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

(WebCore::MediaStreamRegistry::shared): Renamed from "registry".
(WebCore::MediaStreamRegistry::MediaStreamRegistry):
(WebCore::MediaStreamRegistry::lookUp): Moved here from MediaStream.
(WebCore::mediaStreams): Ditto.
(WebCore::MediaStreamRegistry::registerStream): Ditto.
(WebCore::MediaStreamRegistry::unregisterStream): Ditto.
(WebCore::MediaStreamRegistry::registry): Deleted.

  • Modules/mediastream/MediaStreamRegistry.h:
  • dom/Document.h:

(WebCore::Document::setHasActiveMediaStreamTrack): New, set m_hasHadActiveMediaStreamTrack.
(WebCore::Document::hasHadActiveMediaStreamTrack): New, return m_hasHadActiveMediaStreamTrack.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::loadResource): MediaStream::lookUp -> MediaStreamRegistry::shared().lookUp.

  • platform/mediastream/MediaStreamTrackSourcesRequestClient.h:

(WebCore::TrackSourceInfo::create): Take track persistent ID.
(WebCore::TrackSourceInfo::persistentId): New.
(WebCore::TrackSourceInfo::TrackSourceInfo): Take track persistent ID.

  • platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:

(WebCore::RealtimeMediaSourceCenterMac::sourceWithUID): TrackSourceInfo::create takes persistent ID.

  • platform/mock/MockRealtimeMediaSource.cpp:

(WebCore::MockRealtimeMediaSource::trackSourceWithUID): Ditto.

  • platform/mediastream/openwebrtc/RealtimeMediaSourceOwr.cpp:

(WebCore::RealtimeMediaSourceCenterMac::sourceWithUID): TrackSourceInfo::create takes persistent ID.

Tools:

  • WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl:
  • WebKitTestRunner/InjectedBundle/InjectedBundle.cpp:

(WTR::InjectedBundle::setUserMediaPermission):
(WTR::InjectedBundle::setUserMediaPermissionForOrigin): New.

  • WebKitTestRunner/InjectedBundle/InjectedBundle.h:
  • WebKitTestRunner/InjectedBundle/TestRunner.cpp:

(WTR::TestRunner::setUserMediaPermissionForOrigin): New.

  • WebKitTestRunner/InjectedBundle/TestRunner.h:
  • WebKitTestRunner/TestController.cpp:

(WTR::TestController::setUserMediaPermissionForOrigin):
(WTR::TestController::handleCheckOfUserMediaPermissionForOrigin): Add NULL check.
(WTR::TestController::decidePolicyForUserMediaPermissionRequestIfPossible): Don't add

persistent permission for origin, that can be done from script now.

  • WebKitTestRunner/TestController.h:
  • WebKitTestRunner/TestInvocation.cpp:

(WTR::TestInvocation::didReceiveMessageFromInjectedBundle): Add support for

SetUserMediaPermissionForOrigin.

LayoutTests:

  • fast/mediastream/MediaDevices-enumerateDevices-expected.txt:
  • fast/mediastream/MediaDevices-enumerateDevices.html:
Location:
trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r194395 r194397  
     12015-12-23  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] MediaDeviceInfo.label must be empty in some situations
     4        https://bugs.webkit.org/show_bug.cgi?id=152000
     5
     6        Reviewed by Brent Fulgham.
     7
     8        * fast/mediastream/MediaDevices-enumerateDevices-expected.txt:
     9        * fast/mediastream/MediaDevices-enumerateDevices.html:
     10
    1112015-12-23  Andy VanWagoner  <andy@instructure.com>
    212
  • trunk/LayoutTests/fast/mediastream/MediaDevices-enumerateDevices-expected.txt

    r193944 r194397  
    88
    99
    10 *** Calling mediaDevices.enumerateDevices when persistent access HAS NOT been granted
     10*** Calling mediaDevices.enumerateDevices without persistent access, and without a media stream track
    1111
    1212PASS captureDevices.length is non-zero.
     
    2525
    2626
    27 *** Calling mediaDevices.enumerateDevices when persistent access HAS been granted
     27*** Calling mediaDevices.enumerateDevices without persistent access, and without a media stream track
     28
     29PASS captureDevices.length is non-zero.
     30
     31PASS captureDevice.kind is non-null.
     32PASS captureDevice.deviceId is non-null.
     33PASS captureDevice.label is non-null.
     34PASS captureDevice.label is not ""
     35PASS captureDevice.groupId is non-null.
     36
     37PASS captureDevice.kind is non-null.
     38PASS captureDevice.deviceId is non-null.
     39PASS captureDevice.label is non-null.
     40PASS captureDevice.label is not ""
     41PASS captureDevice.groupId is non-null.
     42
     43
     44*** Calling mediaDevices.enumerateDevices without persistent access, with a media stream track
    2845
    2946PASS captureDevices.length is non-zero.
  • trunk/LayoutTests/fast/mediastream/MediaDevices-enumerateDevices.html

    r193944 r194397  
    2121            function enumerate(next)
    2222            {
    23                 debug(`<br>*** Calling mediaDevices.enumerateDevices when persistent access HAS ${havePermission ? "" : "NOT "}been granted<br>`);
    2423                navigator.mediaDevices.enumerateDevices()
    2524                    .then(function(devices) {
     
    4948            }
    5049           
    51             function grantPermission()
     50            function createStream()
    5251            {
    5352                if (window.testRunner) {
    5453                    testRunner.setUserMediaPermission(true);
    55                     navigator.mediaDevices
    56                         .getUserMedia({audio:{}, video:{}})
    57                         .then(function(stream) {
    58                             havePermission = true;
    59                             enumerate(null);                       
    60                         })
    61                         .catch(function(err) {
    62                             testFailed(`mediaDevices.getUserMedia() failed with ${err.name}: ${err.message}`);
    63                         });
     54                    testRunner.setUserMediaPermissionForOrigin(false, document.location.href);
    6455                }
     56
     57                navigator.mediaDevices
     58                    .getUserMedia({audio:{}, video:{}})
     59                    .then(function(stream) {
     60                        debug(`<br>*** Calling mediaDevices.enumerateDevices without persistent access, with a media stream track<br>`);
     61                        havePermission = true;
     62                        enumerate(null);                       
     63                    })
     64                    .catch(function(err) {
     65                        testFailed(`mediaDevices.getUserMedia() failed with ${err.name}: ${err.message}`);
     66                    });
     67            }
     68           
     69            function grantPermission()
     70            {
     71                if (window.testRunner)
     72                    testRunner.setUserMediaPermissionForOrigin(true, document.location.href);
     73
     74                debug(`<br>*** Calling mediaDevices.enumerateDevices without persistent access, and without a media stream track<br>`);
     75                havePermission = true;
     76                enumerate(createStream);
    6577            }
    6678
    6779            havePermission = false;
     80            debug(`<br>*** Calling mediaDevices.enumerateDevices without persistent access, and without a media stream track<br>`);
    6881            enumerate(grantPermission);
    6982
  • trunk/Source/WebCore/ChangeLog

    r194391 r194397  
     12015-12-23  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] MediaDeviceInfo.label must be empty in some situations
     4        https://bugs.webkit.org/show_bug.cgi?id=152000
     5
     6        Reviewed by Brent Fulgham.
     7
     8        No new tests, updated fast/mediastream/MediaDevices-enumerateDevices.html.
     9
     10        * Modules/mediastream/CaptureDeviceManager.cpp:
     11        (CaptureDeviceManager::getSourcesInfo): TrackSourceInfo constructor takes persistent ID.
     12
     13        * Modules/mediastream/MediaDevicesRequest.cpp:
     14        (WebCore::MediaDevicesRequest::start): If Document had an active stream track, don't bother
     15          checking for a persistent permission to access devices.
     16        (WebCore::MediaDevicesRequest::didCompleteCheck): m_hasUserMediaPermission -> m_canShowLabels.
     17        (WebCore::MediaDevicesRequest::getTrackSources): New, factored out of didCompleteCheck so it
     18          can be called when we don't need to check permissions.
     19        (WebCore::MediaDevicesRequest::didCompleteRequest): m_hasUserMediaPermission -> m_canShowLabels.
     20        * Modules/mediastream/MediaDevicesRequest.h:
     21
     22        * Modules/mediastream/MediaStream.cpp:
     23        (WebCore::MediaStream::MediaStream): Call setIsActive. Register new stream with MediaStreamRegistry.
     24        (WebCore::MediaStream::~MediaStream): Unregister stream with MediaStreamRegistry.
     25        (WebCore::MediaStream::setIsActive): New. Set m_isActive and call Document if stream is active.
     26        (WebCore::MediaStream::scheduleActiveStateChange): Call setIsActive.
     27        (WebCore::MediaStream::registry): MediaStreamRegistry::registry -> MediaStreamRegistry::shared.
     28        (WebCore::mediaStreams): Deleted. Drive-by cleanup: moved list of all streams to MediaStreamRegistry.
     29        (WebCore::registerMediaStream): Ditto.
     30        (WebCore::unRegisterMediaStream): Ditto.
     31        (WebCore::MediaStream::lookUp): Ditto.
     32        (WebCore::MediaStream::setRegistry): Ditto.
     33        * Modules/mediastream/MediaStream.h:
     34
     35        * Modules/mediastream/MediaStreamRegistry.cpp:
     36        (WebCore::MediaStreamRegistry::shared): Renamed from "registry".
     37        (WebCore::MediaStreamRegistry::MediaStreamRegistry):
     38        (WebCore::MediaStreamRegistry::lookUp): Moved here from MediaStream.
     39        (WebCore::mediaStreams): Ditto.
     40        (WebCore::MediaStreamRegistry::registerStream): Ditto.
     41        (WebCore::MediaStreamRegistry::unregisterStream): Ditto.
     42        (WebCore::MediaStreamRegistry::registry): Deleted.
     43        * Modules/mediastream/MediaStreamRegistry.h:
     44
     45        * dom/Document.h:
     46        (WebCore::Document::setHasActiveMediaStreamTrack): New, set m_hasHadActiveMediaStreamTrack.
     47        (WebCore::Document::hasHadActiveMediaStreamTrack): New, return m_hasHadActiveMediaStreamTrack.
     48
     49        * html/HTMLMediaElement.cpp:
     50        (WebCore::HTMLMediaElement::loadResource): MediaStream::lookUp -> MediaStreamRegistry::shared().lookUp.
     51
     52        * platform/mediastream/MediaStreamTrackSourcesRequestClient.h:
     53        (WebCore::TrackSourceInfo::create): Take track persistent ID.
     54        (WebCore::TrackSourceInfo::persistentId): New.
     55        (WebCore::TrackSourceInfo::TrackSourceInfo): Take track persistent ID.
     56
     57        * platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:
     58        (WebCore::RealtimeMediaSourceCenterMac::sourceWithUID): TrackSourceInfo::create takes persistent ID.
     59
     60        * platform/mock/MockRealtimeMediaSource.cpp:
     61        (WebCore::MockRealtimeMediaSource::trackSourceWithUID): Ditto.
     62
     63        * platform/mediastream/openwebrtc/RealtimeMediaSourceOwr.cpp:
     64        (WebCore::RealtimeMediaSourceCenterMac::sourceWithUID): TrackSourceInfo::create takes persistent ID.
     65
    1662015-12-23  Xabier Rodriguez Calvar  <calvaris@igalia.com>
    267
  • trunk/Source/WebCore/Modules/mediastream/CaptureDeviceManager.cpp

    r192954 r194397  
    5353
    5454        TrackSourceInfo::SourceKind trackSourceType = captureDevice.m_sourceType == RealtimeMediaSource::Video ? TrackSourceInfo::Video : TrackSourceInfo::Audio;
    55         sourcesInfo.append(TrackSourceInfo::create(captureDevice.m_sourceId, trackSourceType, captureDevice.m_localizedName, captureDevice.m_groupID));
     55        sourcesInfo.append(TrackSourceInfo::create(captureDevice.m_persistentDeviceID, captureDevice.m_sourceId, trackSourceType, captureDevice.m_localizedName, captureDevice.m_groupID));
    5656    }
    5757    LOG(Media, "CaptureDeviceManager::getSourcesInfo(%p), found %zu active devices", this, sourcesInfo.size());
  • trunk/Source/WebCore/Modules/mediastream/MediaDevicesRequest.cpp

    r193944 r194397  
    7878{
    7979    m_protector = this;
     80
     81    if (Document* document = downcast<Document>(scriptExecutionContext())) {
     82        m_canShowLabels = document->hasHadActiveMediaStreamTrack();
     83        if (m_canShowLabels) {
     84            getTrackSources();
     85            return;
     86        }
     87    }
     88
    8089    m_permissionCheck = UserMediaPermissionCheck::create(*downcast<Document>(scriptExecutionContext()), *this);
    8190    m_permissionCheck->start();
     
    8796    m_permissionCheck = nullptr;
    8897
    89     m_hasUserMediaPermission = canAccess;
     98    m_canShowLabels = canAccess;
     99    getTrackSources();
     100}
    90101
     102void MediaDevicesRequest::getTrackSources()
     103{
    91104    callOnMainThread([this] {
    92105        RealtimeMediaSourceCenter::singleton().getMediaStreamTrackSources(this);
     
    106119        String deviceType = trackInfo->kind() == TrackSourceInfo::SourceKind::Audio ? MediaDeviceInfo::audioInputType() : MediaDeviceInfo::videoInputType();
    107120
    108         AtomicString label = m_hasUserMediaPermission ? trackInfo->label() : emptyAtom;
     121        AtomicString label = m_canShowLabels ? trackInfo->label() : emptyAtom;
    109122        deviceInfo.append(MediaDeviceInfo::create(m_scriptExecutionContext, label, trackInfo->id(), trackInfo->groupId(), deviceType));
    110123    }
  • trunk/Source/WebCore/Modules/mediastream/MediaDevicesRequest.h

    r193944 r194397  
    6060    MediaDevicesRequest(ScriptExecutionContext*, MediaDevices::EnumerateDevicesPromise&&);
    6161
     62    void getTrackSources();
     63
    6264    // MediaStreamTrackSourcesRequestClient
    6365    const String& requestOrigin() const final;
     
    7476    RefPtr<UserMediaPermissionCheck> m_permissionCheck;
    7577
    76     bool m_hasUserMediaPermission { false };
     78    bool m_canShowLabels { false };
    7779};
    7880
  • trunk/Source/WebCore/Modules/mediastream/MediaStream.cpp

    r194371 r194397  
    3131#if ENABLE(MEDIA_STREAM)
    3232
     33#include "Document.h"
    3334#include "Event.h"
    3435#include "ExceptionCode.h"
     
    4142namespace WebCore {
    4243
    43 static Vector<MediaStream*>& mediaStreams()
    44 {
    45     static NeverDestroyed<Vector<MediaStream*>> streams;
    46     return streams;
    47 }
    48 
    49 static void registerMediaStream(MediaStream* stream)
    50 {
    51     mediaStreams().append(stream);
    52 }
    53 
    54 static void unRegisterMediaStream(MediaStream* stream)
    55 {
    56     Vector<MediaStream*>& allStreams = mediaStreams();
    57     size_t pos = allStreams.find(stream);
    58     if (pos != notFound)
    59         allStreams.remove(pos);
    60 }
    61 
    62 MediaStream* MediaStream::lookUp(const MediaStreamPrivate& privateStream)
    63 {
    64     Vector<MediaStream*>& allStreams = mediaStreams();
    65     for (auto& stream : allStreams) {
    66         if (stream->m_private == &privateStream)
    67             return stream;
    68     }
    69 
    70     return nullptr;
    71 }
    72 
    73 static URLRegistry* s_registry;
    74 
    75 void MediaStream::setRegistry(URLRegistry& registry)
    76 {
    77     ASSERT(!s_registry);
    78     s_registry = &registry;
    79 }
    80 
    81 MediaStream* MediaStream::lookUp(const URL& url)
    82 {
    83     if (!s_registry)
    84         return nullptr;
    85 
    86     return static_cast<MediaStream*>(s_registry->lookup(url.string()));
    87 }
    88 
    8944Ref<MediaStream> MediaStream::create(ScriptExecutionContext& context)
    9045{
     
    12580
    12681    m_private = MediaStreamPrivate::create(trackPrivates);
    127     m_isActive = m_private->active();
     82    setIsActive(m_private->active());
    12883    m_private->addObserver(*this);
    129     registerMediaStream(this);
     84    MediaStreamRegistry::shared().registerStream(*this);
    13085}
    13186
     
    13388    : ContextDestructionObserver(&context)
    13489    , m_private(streamPrivate)
    135     , m_isActive(m_private->active())
    13690    , m_activityEventTimer(*this, &MediaStream::activityEventTimerFired)
    13791{
    13892    ASSERT(m_private);
     93    setIsActive(m_private->active());
    13994    m_private->addObserver(*this);
    140     registerMediaStream(this);
     95    MediaStreamRegistry::shared().registerStream(*this);
    14196
    14297    for (auto& trackPrivate : m_private->tracks()) {
     
    149104MediaStream::~MediaStream()
    150105{
    151     unRegisterMediaStream(this);
     106    MediaStreamRegistry::shared().unregisterStream(*this);
    152107    m_private->removeObserver(*this);
    153108    for (auto& track : m_trackSet.values())
     
    275230
    276231    return true;
     232}
     233
     234void MediaStream::setIsActive(bool active)
     235{
     236    m_isActive = active;
     237    if (!active)
     238        return;
     239
     240    if (Document* document = downcast<Document>(scriptExecutionContext()))
     241        document->setHasActiveMediaStreamTrack();
    277242}
    278243
     
    286251        }
    287252    }
     253
    288254    if (m_isActive == active)
    289255        return;
    290256
    291     m_isActive = active;
     257    setIsActive(active);
    292258
    293259    const AtomicString& eventName = m_isActive ? eventNames().inactiveEvent : eventNames().activeEvent;
     
    309275URLRegistry& MediaStream::registry() const
    310276{
    311     return MediaStreamRegistry::registry();
     277    return MediaStreamRegistry::shared();
    312278}
    313279
  • trunk/Source/WebCore/Modules/mediastream/MediaStream.h

    r192354 r194397  
    5252        virtual void didAddOrRemoveTrack() = 0;
    5353    };
    54 
    55     static void setRegistry(URLRegistry&);
    56     static MediaStream* lookUp(const URL&);
    57 
    58     static MediaStream* lookUp(const MediaStreamPrivate&);
    5954
    6055    static Ref<MediaStream> create(ScriptExecutionContext&);
     
    120115    void scheduleActiveStateChange();
    121116    void activityEventTimerFired();
     117    void setIsActive(bool);
    122118
    123119    MediaStreamTrackVector trackVectorForType(RealtimeMediaSource::Type) const;
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamRegistry.cpp

    r190072 r194397  
    2929#if ENABLE(MEDIA_STREAM)
    3030
     31#include "MediaStream.h"
    3132#include "URL.h"
    32 #include "MediaStream.h"
    3333#include <wtf/MainThread.h>
    3434#include <wtf/NeverDestroyed.h>
     
    3636namespace WebCore {
    3737
    38 MediaStreamRegistry& MediaStreamRegistry::registry()
     38MediaStreamRegistry& MediaStreamRegistry::shared()
    3939{
    4040    // Since WebWorkers cannot obtain MediaSource objects, we should be on the main thread.
     
    6565MediaStreamRegistry::MediaStreamRegistry()
    6666{
    67     MediaStream::setRegistry(*this);
     67}
     68
     69MediaStream* MediaStreamRegistry::lookUp(const URL& url) const
     70{
     71    return static_cast<MediaStream*>(lookup(url.string()));
     72}
     73
     74static Vector<MediaStream*>& mediaStreams()
     75{
     76    static NeverDestroyed<Vector<MediaStream*>> streams;
     77    return streams;
     78}
     79
     80void MediaStreamRegistry::registerStream(MediaStream& stream)
     81{
     82    mediaStreams().append(&stream);
     83}
     84
     85void MediaStreamRegistry::unregisterStream(MediaStream& stream)
     86{
     87    Vector<MediaStream*>& allStreams = mediaStreams();
     88    size_t pos = allStreams.find(&stream);
     89    if (pos != notFound)
     90        allStreams.remove(pos);
     91}
     92
     93MediaStream* MediaStreamRegistry::lookUp(const MediaStreamPrivate& privateStream) const
     94{
     95    Vector<MediaStream*>& allStreams = mediaStreams();
     96    for (auto& stream : allStreams) {
     97        if (stream->privateStream() == &privateStream)
     98            return stream;
     99    }
     100
     101    return nullptr;
    68102}
    69103
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamRegistry.h

    r190072 r194397  
    3636namespace WebCore {
    3737
     38class MediaStream;
     39class MediaStreamPrivate;
    3840class URL;
    39 class MediaStream;
    4041
    4142class MediaStreamRegistry final : public URLRegistry {
     
    4445
    4546    // Returns a single instance of MediaStreamRegistry.
    46     static MediaStreamRegistry& registry();
     47    static MediaStreamRegistry& shared();
    4748
    4849    // Registers a blob URL referring to the specified stream data.
     
    5152
    5253    virtual URLRegistrable* lookup(const String&) const override;
     54
     55    void registerStream(MediaStream&);
     56    void unregisterStream(MediaStream&);
     57
     58    MediaStream* lookUp(const URL&) const;
     59    MediaStream* lookUp(const MediaStreamPrivate&) const;
    5360
    5461private:
  • trunk/Source/WebCore/dom/Document.h

    r194006 r194397  
    13131313    void removeViewportDependentPicture(HTMLPictureElement&);
    13141314
     1315#if ENABLE(MEDIA_STREAM)
     1316    void setHasActiveMediaStreamTrack() { m_hasHadActiveMediaStreamTrack = true; }
     1317    bool hasHadActiveMediaStreamTrack() const { return m_hasHadActiveMediaStreamTrack; }
     1318#endif
     1319
    13151320protected:
    13161321    enum ConstructionFlags { Synthesized = 1, NonRenderedPlaceholder = 1 << 1 };
     
    17811786#endif
    17821787    bool m_areDeviceMotionAndOrientationUpdatesSuspended { false };
     1788
     1789#if ENABLE(MEDIA_STREAM)
     1790    bool m_hasHadActiveMediaStreamTrack { false };
     1791#endif
    17831792};
    17841793
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r193884 r194397  
    13291329    if (!loadAttempted) {
    13301330        if (!m_mediaStreamSrcObject && url.protocolIs(mediaStreamBlobProtocol))
    1331             m_mediaStreamSrcObject = MediaStream::lookUp(url);
     1331            m_mediaStreamSrcObject = MediaStreamRegistry::shared().lookUp(url);
    13321332
    13331333        if (m_mediaStreamSrcObject) {
  • trunk/Source/WebCore/platform/mediastream/MediaStreamTrackSourcesRequestClient.h

    r190072 r194397  
    4040    enum SourceKind { Audio, Video };
    4141
    42     static PassRefPtr<TrackSourceInfo> create(const AtomicString& id, SourceKind kind, const AtomicString& label)
     42    static PassRefPtr<TrackSourceInfo> create(const AtomicString& persistentId, const AtomicString& id, SourceKind kind, const AtomicString& label)
    4343    {
    44         return adoptRef(new TrackSourceInfo(id, kind, label));
     44        return adoptRef(new TrackSourceInfo(persistentId, id, kind, label));
    4545    }
    4646
    47     static Ref<TrackSourceInfo> create(const AtomicString& id, SourceKind kind, const AtomicString& label, const AtomicString& groupId)
     47    static Ref<TrackSourceInfo> create(const AtomicString& persistentId, const AtomicString& id, SourceKind kind, const AtomicString& label, const AtomicString& groupId)
    4848    {
    49         return adoptRef(*new TrackSourceInfo(id, kind, label, groupId));
     49        return adoptRef(*new TrackSourceInfo(persistentId, id, kind, label, groupId));
    5050    }
    5151
    5252    const AtomicString& id() const { return m_id; }
     53    const AtomicString& persistentId() const { return m_persistentId; }
    5354    const AtomicString& label() const { return m_label; }
    5455    const AtomicString& groupId() const { return m_groupId; }
     
    5657
    5758private:
    58     TrackSourceInfo(const AtomicString& id, SourceKind kind, const AtomicString& label)
    59         : m_id(id)
     59    TrackSourceInfo(const AtomicString& persistentId, const AtomicString& id, SourceKind kind, const AtomicString& label)
     60        : m_persistentId(persistentId)
     61        , m_id(id)
    6062        , m_kind(kind)
    6163        , m_label(label)
     
    6365    }
    6466
    65     TrackSourceInfo(const AtomicString& id, SourceKind kind, const AtomicString& label, const AtomicString& groupId)
    66         : m_id(id)
     67    TrackSourceInfo(const AtomicString& persistentId, const AtomicString& id, SourceKind kind, const AtomicString& label, const AtomicString& groupId)
     68        : m_persistentId(persistentId)
     69        , m_id(id)
    6770        , m_kind(kind)
    6871        , m_label(label)
     
    7174    }
    7275
     76    AtomicString m_persistentId;
    7377    AtomicString m_id;
    7478    SourceKind m_kind;
     
    8589    virtual const String& requestOrigin() const = 0;
    8690    virtual void didCompleteRequest(const TrackSourceInfoVector&) = 0;
    87 
    8891};
    8992
  • trunk/Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp

    r192838 r194397  
    179179    if (!mediaSource)
    180180        return nullptr;
    181     return TrackSourceInfo::create(mediaSource->id(), mediaSource->type() == RealtimeMediaSource::Type::Video ? TrackSourceInfo::SourceKind::Video : TrackSourceInfo::SourceKind::Audio, mediaSource->name());
     181    return TrackSourceInfo::create(mediaSource->persistentID(), mediaSource->id(), mediaSource->type() == RealtimeMediaSource::Type::Video ? TrackSourceInfo::SourceKind::Video : TrackSourceInfo::SourceKind::Audio, mediaSource->name());
    182182}
    183183
  • trunk/Source/WebCore/platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.cpp

    r190362 r194397  
    216216    for (auto& source : m_sourceMap.values()) {
    217217        if (source->id() == UID)
    218             return TrackSourceInfo::create(source->id(), source->type() == RealtimeMediaSource::Type::Video ? TrackSourceInfo::SourceKind::Video : TrackSourceInfo::SourceKind::Audio , source->name());
     218            return TrackSourceInfo::create(source->persistentID(), source->id(), source->type() == RealtimeMediaSource::Type::Video ? TrackSourceInfo::SourceKind::Video : TrackSourceInfo::SourceKind::Audio , source->name());
    219219    }
    220220
  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSource.cpp

    r193389 r194397  
    7474
    7575    if (mockAudioSourcePersistentID() == id)
    76         return TrackSourceInfo::create(mockAudioSourcePersistentID(), TrackSourceInfo::Audio, "Mock audio device");
     76        return TrackSourceInfo::create(mockAudioSourcePersistentID(), id, TrackSourceInfo::Audio, "Mock audio device");
    7777
    7878    if (mockVideoSourcePersistentID() == id)
    79         return TrackSourceInfo::create(mockVideoSourcePersistentID(), TrackSourceInfo::Video, "Mock video device");
     79        return TrackSourceInfo::create(mockVideoSourcePersistentID(), id, TrackSourceInfo::Video, "Mock video device");
    8080   
    8181    return nullptr;
  • trunk/Tools/ChangeLog

    r194396 r194397  
     12015-12-23  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] MediaDeviceInfo.label must be empty in some situations
     4        https://bugs.webkit.org/show_bug.cgi?id=152000
     5
     6        Reviewed by Brent Fulgham.
     7
     8        * WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl:
     9        * WebKitTestRunner/InjectedBundle/InjectedBundle.cpp:
     10        (WTR::InjectedBundle::setUserMediaPermission):
     11        (WTR::InjectedBundle::setUserMediaPermissionForOrigin): New.
     12        * WebKitTestRunner/InjectedBundle/InjectedBundle.h:
     13
     14        * WebKitTestRunner/InjectedBundle/TestRunner.cpp:
     15        (WTR::TestRunner::setUserMediaPermissionForOrigin): New.
     16        * WebKitTestRunner/InjectedBundle/TestRunner.h:
     17
     18        * WebKitTestRunner/TestController.cpp:
     19        (WTR::TestController::setUserMediaPermissionForOrigin):
     20        (WTR::TestController::handleCheckOfUserMediaPermissionForOrigin): Add NULL check.
     21        (WTR::TestController::decidePolicyForUserMediaPermissionRequestIfPossible): Don't add
     22          persistent permission for origin, that can be done from script now.
     23        * WebKitTestRunner/TestController.h:
     24
     25        * WebKitTestRunner/TestInvocation.cpp:
     26        (WTR::TestInvocation::didReceiveMessageFromInjectedBundle): Add support for
     27          SetUserMediaPermissionForOrigin.
     28
    1292015-12-23  Brent Fulgham  <bfulgham@apple.com>
    230
  • trunk/Tools/WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl

    r193924 r194397  
    180180    // MediaStream
    181181    void setUserMediaPermission(boolean value);
     182    void setUserMediaPermissionForOrigin(boolean permission, DOMString url);
    182183
    183184    // Audio testing.
  • trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp

    r191047 r194397  
    527527}
    528528
     529void InjectedBundle::setUserMediaPermissionForOrigin(bool permission, WKStringRef url)
     530{
     531    auto messageName = adoptWK(WKStringCreateWithUTF8CString("SetUserMediaPermissionForOrigin"));
     532    WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
     533
     534    WKRetainPtr<WKStringRef> permissionKeyWK(AdoptWK, WKStringCreateWithUTF8CString("permission"));
     535    WKRetainPtr<WKBooleanRef> permissionWK(AdoptWK, WKBooleanCreate(permission));
     536    WKDictionarySetItem(messageBody.get(), permissionKeyWK.get(), permissionWK.get());
     537
     538    WKRetainPtr<WKStringRef> urlKeyWK(AdoptWK, WKStringCreateWithUTF8CString("url"));
     539    WKDictionarySetItem(messageBody.get(), urlKeyWK.get(), url);
     540
     541    WKBundlePagePostMessage(page()->page(), messageName.get(), messageBody.get());
     542}
     543
    529544void InjectedBundle::setCustomPolicyDelegate(bool enabled, bool permissive)
    530545{
  • trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.h

    r190304 r194397  
    9797    // MediaStream.
    9898    void setUserMediaPermission(bool);
     99    void setUserMediaPermissionForOrigin(bool permission, WKStringRef url);
    99100
    100101    // Policy delegate.
  • trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp

    r192782 r194397  
    776776}
    777777
     778void TestRunner::setUserMediaPermissionForOrigin(bool permission, JSStringRef url)
     779{
     780    WKRetainPtr<WKStringRef> urlWK = toWK(url);
     781    InjectedBundle::singleton().setUserMediaPermissionForOrigin(permission, urlWK.get());
     782}
     783
    778784bool TestRunner::callShouldCloseOnWebView()
    779785{
  • trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.h

    r193924 r194397  
    269269    // MediaStream
    270270    void setUserMediaPermission(bool);
     271    void setUserMediaPermissionForOrigin(bool permission, JSStringRef url);
    271272
    272273    void setPageVisibility(JSStringRef state);
  • trunk/Tools/WebKitTestRunner/TestController.cpp

    r193944 r194397  
    16461646}
    16471647
    1648 void TestController::setUserMediaPermission(bool enabled)
    1649 {
    1650     m_isUserMediaPermissionSet = true;
    1651     m_isUserMediaPermissionAllowed = enabled;
    1652     decidePolicyForUserMediaPermissionRequestIfPossible();
    1653 }
    1654 
    16551648static WKStringRef originUserVisibleName(WKSecurityOriginRef origin)
    16561649{
     
    16681661}
    16691662
     1663void TestController::setUserMediaPermission(bool enabled)
     1664{
     1665    m_isUserMediaPermissionSet = true;
     1666    m_isUserMediaPermissionAllowed = enabled;
     1667    decidePolicyForUserMediaPermissionRequestIfPossible();
     1668}
     1669
     1670void TestController::setUserMediaPermissionForOrigin(bool permission, WKStringRef originString)
     1671{
     1672    if (!m_userMediaOriginPermissions)
     1673        m_userMediaOriginPermissions = adoptWK(WKMutableDictionaryCreate());
     1674    WKRetainPtr<WKBooleanRef> allowed = adoptWK(WKBooleanCreate(permission));
     1675    WKRetainPtr<WKSecurityOriginRef> origin = adoptWK(WKSecurityOriginCreateFromString(originString));
     1676    WKDictionarySetItem(m_userMediaOriginPermissions.get(), originUserVisibleName(origin.get()), allowed.get());
     1677}
     1678
    16701679void TestController::handleCheckOfUserMediaPermissionForOrigin(WKSecurityOriginRef origin, const WKUserMediaPermissionCheckRef& checkRequest)
    16711680{
     
    16751684        WKRetainPtr<WKStringRef> originString = originUserVisibleName(origin);
    16761685        WKBooleanRef value = static_cast<WKBooleanRef>(WKDictionaryGetItemForKey(m_userMediaOriginPermissions.get(), originString.get()));
    1677         if (WKGetTypeID(value) == WKBooleanGetTypeID())
     1686        if (value && WKGetTypeID(value) == WKBooleanGetTypeID())
    16781687            allowed = WKBooleanGetValue(value);
    16791688    }
     
    16941703
    16951704    for (auto& pair : m_userMediaPermissionRequests) {
    1696         auto origin = pair.first.get();
    16971705        auto request = pair.second.get();
    16981706        WKRetainPtr<WKArrayRef> audioDeviceUIDs = WKUserMediaPermissionRequestAudioDeviceUIDs(request);
    16991707        WKRetainPtr<WKArrayRef> videoDeviceUIDs = WKUserMediaPermissionRequestVideoDeviceUIDs(request);
    1700 
    1701         WKRetainPtr<WKStringRef> originString = adoptWK(originUserVisibleName(origin));
    1702         if (!m_userMediaOriginPermissions)
    1703             m_userMediaOriginPermissions = adoptWK(WKMutableDictionaryCreate());
    1704         WKRetainPtr<WKBooleanRef> allowed = adoptWK(WKBooleanCreate(m_isUserMediaPermissionAllowed));
    1705         WKDictionarySetItem(m_userMediaOriginPermissions.get(), originString.get(), allowed.get());
    17061708
    17071709        if (m_isUserMediaPermissionAllowed && (WKArrayGetSize(videoDeviceUIDs.get()) || WKArrayGetSize(audioDeviceUIDs.get()))) {
  • trunk/Tools/WebKitTestRunner/TestController.h

    r193944 r194397  
    9797    // MediaStream.
    9898    void setUserMediaPermission(bool);
     99    void setUserMediaPermissionForOrigin(bool permission, WKStringRef url);
    99100    void handleUserMediaPermissionRequest(WKSecurityOriginRef, WKUserMediaPermissionRequestRef);
    100101    void handleCheckOfUserMediaPermissionForOrigin(WKSecurityOriginRef, const WKUserMediaPermissionCheckRef&);
  • trunk/Tools/WebKitTestRunner/TestInvocation.cpp

    r190335 r194397  
    468468    }
    469469
     470    if (WKStringIsEqualToUTF8CString(messageName, "SetUserMediaPermissionForOrigin")) {
     471        ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
     472        WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
     473
     474        WKRetainPtr<WKStringRef> permissionKeyWK(AdoptWK, WKStringCreateWithUTF8CString("permission"));
     475        WKBooleanRef permissionWK = static_cast<WKBooleanRef>(WKDictionaryGetItemForKey(messageBodyDictionary, permissionKeyWK.get()));
     476        bool permission = WKBooleanGetValue(permissionWK);
     477
     478        WKRetainPtr<WKStringRef> urlKey(AdoptWK, WKStringCreateWithUTF8CString("url"));
     479        WKStringRef urlWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, urlKey.get()));
     480
     481        TestController::singleton().setUserMediaPermissionForOrigin(permission, urlWK);
     482        return;
     483    }
     484
    470485    if (WKStringIsEqualToUTF8CString(messageName, "SetCacheModel")) {
    471486        ASSERT(WKGetTypeID(messageBody) == WKUInt64GetTypeID());
Note: See TracChangeset for help on using the changeset viewer.