Changeset 246436 in webkit


Ignore:
Timestamp:
Jun 14, 2019 10:14:47 AM (5 years ago)
Author:
youenn@apple.com
Message:

Cloning a MediaStreamTrack does not clone the logger
​https://bugs.webkit.org/show_bug.cgi?id=198844

Reviewed by Eric Carlson.

Source/WebCore:

Make MediaStream and MediaStreamTrack rely on their private versions for logging.
Move from a RefPtr version to a Ref so as to forbid nullptr crashes.
Make sure that RealtimeIncomingAudioSource and RealtimeIncomingVideoSource check for their logger before logging.
Covered by existing tests and updated test.

  • Modules/mediastream/CanvasCaptureMediaStreamTrack.cpp:

(WebCore::loggerFromContext):
(WebCore::CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack):

  • Modules/mediastream/MediaStream.cpp:

(WebCore::loggerFromContext):
(WebCore::MediaStream::create):
(WebCore::MediaStream::MediaStream):

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

(WebCore::MediaStreamTrack::MediaStreamTrack):

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

(WebCore::UserMediaRequest::allow):

  • Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:

(WebCore::LibWebRTCMediaEndpoint::mediaStreamFromRTCStream):

  • Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:

(WebCore::LibWebRTCPeerConnectionBackend::createReceiverForSource):

  • Modules/webaudio/MediaStreamAudioDestinationNode.cpp:

(WebCore::MediaStreamAudioDestinationNode::MediaStreamAudioDestinationNode):

  • platform/mediastream/MediaStreamPrivate.cpp:

(WebCore::MediaStreamPrivate::create):
(WebCore::MediaStreamPrivate::MediaStreamPrivate):
(WebCore::MediaStreamPrivate::setLogger): Deleted.

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

(WebCore::MediaStreamTrackPrivate::create):
(WebCore::MediaStreamTrackPrivate::MediaStreamTrackPrivate):
(WebCore::MediaStreamTrackPrivate::clone):
(WebCore::MediaStreamTrackPrivate::setLogger): Deleted.

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

(WebCore::RealtimeMediaSourceCenter::createMediaStream):

  • platform/mediastream/RealtimeMediaSourceCenter.h:
  • platform/mediastream/mac/RealtimeIncomingAudioSourceCocoa.cpp:

(WebCore::RealtimeIncomingAudioSourceCocoa::OnData):

  • platform/mediastream/mac/RealtimeIncomingVideoSourceCocoa.mm:

(WebCore::RealtimeIncomingVideoSourceCocoa::pixelBufferPool):
(WebCore::RealtimeIncomingVideoSourceCocoa::pixelBufferFromVideoFrame):
(WebCore::RealtimeIncomingVideoSourceCocoa::OnFrame):

LayoutTests:

  • fast/mediastream/MediaStreamTrack-clone-expected.txt:
  • fast/mediastream/MediaStreamTrack-clone.html:
Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r246435 r246436  
     12019-06-14  Youenn Fablet  <youenn@apple.com>
     2
     3        Cloning a MediaStreamTrack does not clone the logger
     4        https://bugs.webkit.org/show_bug.cgi?id=198844
     5
     6        Reviewed by Eric Carlson.
     7
     8        * fast/mediastream/MediaStreamTrack-clone-expected.txt:
     9        * fast/mediastream/MediaStreamTrack-clone.html:
     10
    1112019-06-14  Shawn Roberts  <sroberts@apple.com>
    212

  • trunk/LayoutTests/fast/mediastream/MediaStreamTrack-clone-expected.txt

    r186081 r246436  
    2121PASS videoTrack.onoverconstrained is not videoTrack2.onoverconstrained
    2222PASS videoTrack.readyState is not videoTrack2.readyState
     23PASS videoTrack.readyState is videoTrack3.readyState
    2324PASS successfullyParsed is true
    2425

  • trunk/LayoutTests/fast/mediastream/MediaStreamTrack-clone.html

    r186081 r246436  
    88            var videoTrack;
    99            var videoTrack2;
     10            var videoTrack3;
    1011            var audioTrack;
    1112
    … …  
    4142                shouldNotBe('videoTrack.readyState', 'videoTrack2.readyState');
    4243
     44                videoTrack3 = videoTrack.clone();
     45                shouldBe('videoTrack.readyState', 'videoTrack3.readyState');
     46
    4347                finishJSTest();
    4448            }

  • trunk/Source/WebCore/ChangeLog

    r246432 r246436  
     12019-06-14  Youenn Fablet  <youenn@apple.com>
     2
     3        Cloning a MediaStreamTrack does not clone the logger
     4        https://bugs.webkit.org/show_bug.cgi?id=198844
     5
     6        Reviewed by Eric Carlson.
     7
     8        Make MediaStream and MediaStreamTrack rely on their private versions for logging.
     9        Move from a RefPtr version to a Ref so as to forbid nullptr crashes.
     10        Make sure that RealtimeIncomingAudioSource and RealtimeIncomingVideoSource check for their logger before logging.
     11        Covered by existing tests and updated test.
     12
     13        * Modules/mediastream/CanvasCaptureMediaStreamTrack.cpp:
     14        (WebCore::loggerFromContext):
     15        (WebCore::CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack):
     16        * Modules/mediastream/MediaStream.cpp:
     17        (WebCore::loggerFromContext):
     18        (WebCore::MediaStream::create):
     19        (WebCore::MediaStream::MediaStream):
     20        * Modules/mediastream/MediaStream.h:
     21        * Modules/mediastream/MediaStreamTrack.cpp:
     22        (WebCore::MediaStreamTrack::MediaStreamTrack):
     23        * Modules/mediastream/MediaStreamTrack.h:
     24        * Modules/mediastream/UserMediaRequest.cpp:
     25        (WebCore::UserMediaRequest::allow):
     26        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:
     27        (WebCore::LibWebRTCMediaEndpoint::mediaStreamFromRTCStream):
     28        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:
     29        (WebCore::LibWebRTCPeerConnectionBackend::createReceiverForSource):
     30        * Modules/webaudio/MediaStreamAudioDestinationNode.cpp:
     31        (WebCore::MediaStreamAudioDestinationNode::MediaStreamAudioDestinationNode):
     32        * platform/mediastream/MediaStreamPrivate.cpp:
     33        (WebCore::MediaStreamPrivate::create):
     34        (WebCore::MediaStreamPrivate::MediaStreamPrivate):
     35        (WebCore::MediaStreamPrivate::setLogger): Deleted.
     36        * platform/mediastream/MediaStreamPrivate.h:
     37        * platform/mediastream/MediaStreamTrackPrivate.cpp:
     38        (WebCore::MediaStreamTrackPrivate::create):
     39        (WebCore::MediaStreamTrackPrivate::MediaStreamTrackPrivate):
     40        (WebCore::MediaStreamTrackPrivate::clone):
     41        (WebCore::MediaStreamTrackPrivate::setLogger): Deleted.
     42        * platform/mediastream/MediaStreamTrackPrivate.h:
     43        * platform/mediastream/RealtimeMediaSourceCenter.cpp:
     44        (WebCore::RealtimeMediaSourceCenter::createMediaStream):
     45        * platform/mediastream/RealtimeMediaSourceCenter.h:
     46        * platform/mediastream/mac/RealtimeIncomingAudioSourceCocoa.cpp:
     47        (WebCore::RealtimeIncomingAudioSourceCocoa::OnData):
     48        * platform/mediastream/mac/RealtimeIncomingVideoSourceCocoa.mm:
     49        (WebCore::RealtimeIncomingVideoSourceCocoa::pixelBufferPool):
     50        (WebCore::RealtimeIncomingVideoSourceCocoa::pixelBufferFromVideoFrame):
     51        (WebCore::RealtimeIncomingVideoSourceCocoa::OnFrame):
     52
    1532019-06-14  Ali Juma  <ajuma@chromium.org>
    254

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

    r243887 r246436  
    4343}
    4444
     45static inline Ref<const Logger> loggerFromContext(ScriptExecutionContext& context)
     46{
     47    return downcast<Document>(context).logger();
     48}
     49
    4550CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack(ScriptExecutionContext& context, Ref<HTMLCanvasElement>&& canvas, Ref<CanvasCaptureMediaStreamTrack::Source>&& source)
    46     : MediaStreamTrack(context, MediaStreamTrackPrivate::create(source.copyRef()))
     51    : MediaStreamTrack(context, MediaStreamTrackPrivate::create(loggerFromContext(context), source.copyRef()))
    4752    , m_canvas(WTFMove(canvas))
    4853{

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

    r243899 r246436  
    4949WTF_MAKE_ISO_ALLOCATED_IMPL(MediaStream);
    5050
     51static inline Ref<const Logger> loggerFromContext(ScriptExecutionContext& context)
     52{
     53    return downcast<Document>(context).logger();
     54}
     55
    5156Ref<MediaStream> MediaStream::create(ScriptExecutionContext& context)
    5257{
    53     return MediaStream::create(context, MediaStreamPrivate::create({ }));
     58    return MediaStream::create(context, MediaStreamPrivate::create(loggerFromContext(context), { }));
    5459}
    5560
    … …  
    8085MediaStream::MediaStream(ScriptExecutionContext& context, const MediaStreamTrackVector& tracks)
    8186    : ActiveDOMObject(&context)
    82     , m_private(MediaStreamPrivate::create(createTrackPrivateVector(tracks)))
     87    , m_private(MediaStreamPrivate::create(document()->logger(), createTrackPrivateVector(tracks)))
    8388    , m_mediaSession(PlatformMediaSession::create(*this))
    84 #if !RELEASE_LOG_DISABLED
    85     , m_logger(document()->logger())
    86     , m_logIdentifier(uniqueLogIdentifier())
    87 #endif
    8889{
    8990    // This constructor preserves MediaStreamTrack instances and must be used by calls originating
    9091    // from the JavaScript MediaStream constructor.
    91 
    92 #if !RELEASE_LOG_DISABLED
    93     ALWAYS_LOG(LOGIDENTIFIER);
    94     m_private->setLogger(logger(), logIdentifier());
    95 #endif
    9692
    9793    for (auto& track : tracks) {
    … …  
    110106    , m_private(WTFMove(streamPrivate))
    111107    , m_mediaSession(PlatformMediaSession::create(*this))
    112 #if !RELEASE_LOG_DISABLED
    113     , m_logger(document()->logger())
    114     , m_logIdentifier(uniqueLogIdentifier())
    115 #endif
    116 {
    117 #if !RELEASE_LOG_DISABLED
     108{
    118109    ALWAYS_LOG(LOGIDENTIFIER);
    119     m_private->setLogger(logger(), logIdentifier());
    120 #endif
     110
    121111    setIsActive(m_private->active());
    122112    m_private->addObserver(*this);

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

    r243887 r246436  
    126126
    127127#if !RELEASE_LOG_DISABLED
    128     const Logger& logger() const final { return m_logger.get(); }
    129     const void* logIdentifier() const final { return m_logIdentifier; }
     128    const Logger& logger() const final { return m_private->logger(); }
     129    const void* logIdentifier() const final { return m_private->logIdentifier(); }
    130130    WTFLogChannel& logChannel() const final;
    131131    const char* logClassName() const final { return "MediaStream"; }
    … …  
    188188    MediaProducer::MediaStateFlags m_state { MediaProducer::IsNotPlaying };
    189189
    190 #if !RELEASE_LOG_DISABLED
    191     Ref<Logger> m_logger;
    192     const void* m_logIdentifier;
    193 #endif
    194 
    195190    bool m_isActive { false };
    196191    bool m_isProducingData { false };

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

    r246212 r246436  
    5959    : ActiveDOMObject(&context)
    6060    , m_private(WTFMove(privateTrack))
    61 #if !RELEASE_LOG_DISABLED
    62     , m_logger(document()->logger())
    63     , m_logIdentifier(uniqueLogIdentifier())
    64 #endif
    6561    , m_taskQueue(context)
    6662    , m_isCaptureTrack(m_private->isCaptureTrack())
    … …  
    6965    suspendIfNeeded();
    7066
    71 #if !RELEASE_LOG_DISABLED
    72     m_private->setLogger(logger(), logIdentifier());
    73 #endif
    7467    m_private->addObserver(*this);
    7568

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

    r246212 r246436  
    152152
    153153#if !RELEASE_LOG_DISABLED
    154     const Logger& logger() const final { return m_logger.get(); }
    155     const void* logIdentifier() const final { return m_logIdentifier; }
     154    const Logger& logger() const final { return m_private->logger(); }
     155    const void* logIdentifier() const final { return m_private->logIdentifier(); }
    156156#endif
    157157
    … …  
    190190    const char* logClassName() const final { return "MediaStreamTrack"; }
    191191    WTFLogChannel& logChannel() const final;
    192    
    193     Ref<const Logger> m_logger;
    194     const void* m_logIdentifier;
    195192#endif
    196193

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

    r245335 r246436  
    247247    document.setDeviceIDHashSalt(deviceIdentifierHashSalt);
    248248
    249     RealtimeMediaSourceCenter::singleton().createMediaStream(WTFMove(callback), WTFMove(deviceIdentifierHashSalt), WTFMove(audioDevice), WTFMove(videoDevice), m_request);
     249    RealtimeMediaSourceCenter::singleton().createMediaStream(document.logger(), WTFMove(callback), WTFMove(deviceIdentifierHashSalt), WTFMove(audioDevice), WTFMove(videoDevice), m_request);
    250250
    251251    if (!m_scriptExecutionContext)

  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp

    r244736 r246436  
    355355    auto label = fromStdString(rtcStream.id());
    356356    auto mediaStream = m_remoteStreamsById.ensure(label, [label, this]() mutable {
    357         return MediaStream::create(*m_peerConnectionBackend.connection().scriptExecutionContext(), MediaStreamPrivate::create({ }, WTFMove(label)));
     357        auto& document = downcast<Document>(*m_peerConnectionBackend.connection().scriptExecutionContext());
     358        return MediaStream::create(document, MediaStreamPrivate::create(document.logger(), { }, WTFMove(label)));
    358359    });
    359360    return *mediaStream.iterator->value;

  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp

    r243163 r246436  
    270270Ref<RTCRtpReceiver> LibWebRTCPeerConnectionBackend::createReceiverForSource(Ref<RealtimeMediaSource>&& source, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
    271271{
    272     String trackID = source->persistentID();
    273     auto remoteTrackPrivate = MediaStreamTrackPrivate::create(WTFMove(source), WTFMove(trackID));
    274     auto remoteTrack = MediaStreamTrack::create(*m_peerConnection.scriptExecutionContext(), WTFMove(remoteTrackPrivate));
     272    auto& document = downcast<Document>(*m_peerConnection.scriptExecutionContext());
     273    auto trackID = source->persistentID();
     274    auto remoteTrackPrivate = MediaStreamTrackPrivate::create(document.logger(), WTFMove(source), WTFMove(trackID));
     275    auto remoteTrack = MediaStreamTrack::create(document, WTFMove(remoteTrackPrivate));
    275276
    276277    return RTCRtpReceiver::create(*this, WTFMove(remoteTrack), WTFMove(backend));

  • trunk/Source/WebCore/Modules/webaudio/MediaStreamAudioDestinationNode.cpp

    r244899 r246436  
    4848    : AudioBasicInspectorNode(context, context.sampleRate(), numberOfChannels)
    4949    , m_source(MediaStreamAudioSource::create(context.sampleRate()))
    50     , m_stream(MediaStream::create(*context.document(), MediaStreamPrivate::create(m_source.copyRef())))
     50    , m_stream(MediaStream::create(*context.document(), MediaStreamPrivate::create(context.document()->logger(), m_source.copyRef())))
    5151{
    5252    setNodeType(NodeTypeMediaStreamAudioDestination);

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

    r243899 r246436  
    4646namespace WebCore {
    4747
    48 Ref<MediaStreamPrivate> MediaStreamPrivate::create(Ref<RealtimeMediaSource>&& source)
    49 {
    50     return MediaStreamPrivate::create(MediaStreamTrackPrivateVector::from(MediaStreamTrackPrivate::create(WTFMove(source))));
    51 }
    52 
    53 Ref<MediaStreamPrivate> MediaStreamPrivate::create(const Vector<Ref<RealtimeMediaSource>>& audioSources, const Vector<Ref<RealtimeMediaSource>>& videoSources)
     48Ref<MediaStreamPrivate> MediaStreamPrivate::create(Ref<const Logger>&& logger, Ref<RealtimeMediaSource>&& source)
     49{
     50    auto loggerCopy = logger.copyRef();
     51    return MediaStreamPrivate::create(WTFMove(logger), MediaStreamTrackPrivateVector::from(MediaStreamTrackPrivate::create(WTFMove(loggerCopy), WTFMove(source))));
     52}
     53
     54Ref<MediaStreamPrivate> MediaStreamPrivate::create(Ref<const Logger>&& logger, const Vector<Ref<RealtimeMediaSource>>& audioSources, const Vector<Ref<RealtimeMediaSource>>& videoSources)
    5455{
    5556    MediaStreamTrackPrivateVector tracks;
    … …  
    5758
    5859    for (auto& source : audioSources)
    59         tracks.uncheckedAppend(MediaStreamTrackPrivate::create(source.copyRef()));
     60        tracks.uncheckedAppend(MediaStreamTrackPrivate::create(logger.copyRef(), source.copyRef()));
    6061
    6162    for (auto& source : videoSources)
    62         tracks.uncheckedAppend(MediaStreamTrackPrivate::create(source.copyRef()));
    63 
    64     return MediaStreamPrivate::create(tracks);
    65 }
    66 
    67 MediaStreamPrivate::MediaStreamPrivate(const MediaStreamTrackPrivateVector& tracks, String&& id)
     63        tracks.uncheckedAppend(MediaStreamTrackPrivate::create(logger.copyRef(), source.copyRef()));
     64
     65    return MediaStreamPrivate::create(WTFMove(logger), tracks);
     66}
     67
     68MediaStreamPrivate::MediaStreamPrivate(Ref<const Logger>&& logger, const MediaStreamTrackPrivateVector& tracks, String&& id)
    6869    : m_id(WTFMove(id))
    69 {
     70#if !RELEASE_LOG_DISABLED
     71    , m_logger(WTFMove(logger))
     72    , m_logIdentifier(uniqueLogIdentifier())
     73#endif
     74{
     75    UNUSED_PARAM(logger);
    7076    ASSERT(!m_id.isEmpty());
    7177
    … …  
    346352
    347353#if !RELEASE_LOG_DISABLED
    348 void MediaStreamPrivate::setLogger(const Logger& newLogger, const void* newLogIdentifier)
    349 {
    350     m_logger = &newLogger;
    351     m_logIdentifier = newLogIdentifier;
    352     ALWAYS_LOG(LOGIDENTIFIER);
    353 }
    354 
    355354WTFLogChannel& MediaStreamPrivate::logChannel() const
    356355{

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

    r243899 r246436  
    7474    };
    7575
    76     static Ref<MediaStreamPrivate> create(Ref<RealtimeMediaSource>&&);
    77     static Ref<MediaStreamPrivate> create(const Vector<Ref<RealtimeMediaSource>>& audioSources, const Vector<Ref<RealtimeMediaSource>>& videoSources);
    78     static Ref<MediaStreamPrivate> create(const MediaStreamTrackPrivateVector& tracks, String&& id = createCanonicalUUIDString()) { return adoptRef(*new MediaStreamPrivate(tracks, WTFMove(id))); }
     76    static Ref<MediaStreamPrivate> create(Ref<const Logger>&&, Ref<RealtimeMediaSource>&&);
     77    static Ref<MediaStreamPrivate> create(Ref<const Logger>&&, const Vector<Ref<RealtimeMediaSource>>& audioSources, const Vector<Ref<RealtimeMediaSource>>& videoSources);
     78    static Ref<MediaStreamPrivate> create(Ref<const Logger>&& logger, const MediaStreamTrackPrivateVector& tracks, String&& id = createCanonicalUUIDString()) { return adoptRef(*new MediaStreamPrivate(WTFMove(logger), tracks, WTFMove(id))); }
    7979
    8080    virtual ~MediaStreamPrivate();
    … …  
    112112
    113113#if !RELEASE_LOG_DISABLED
    114     void setLogger(const Logger&, const void*);
     114    const Logger& logger() const final { return m_logger; }
     115    const void* logIdentifier() const final { return m_logIdentifier; }
    115116#endif
    116117
    117118private:
    118     MediaStreamPrivate(const MediaStreamTrackPrivateVector&, String&&);
     119    MediaStreamPrivate(Ref<const Logger>&&, const MediaStreamTrackPrivateVector&, String&&);
    119120
    120121    // MediaStreamTrackPrivate::Observer
    … …  
    132133
    133134#if !RELEASE_LOG_DISABLED
    134     const Logger& logger() const final { ASSERT(m_logger); return *m_logger.get(); }
    135     const void* logIdentifier() const final { return m_logIdentifier; }
    136135    const char* logClassName() const final { return "MediaStreamPrivate"; }
    137136    WTFLogChannel& logChannel() const final;
    138 
    139     RefPtr<const Logger> m_logger;
    140     const void* m_logIdentifier;
    141137#endif
    142138
    … …  
    146142    HashMap<String, RefPtr<MediaStreamTrackPrivate>> m_trackSet;
    147143    bool m_isActive { false };
     144#if !RELEASE_LOG_DISABLED
     145    Ref<const Logger> m_logger;
     146    const void* m_logIdentifier;
     147#endif
    148148};
    149149

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

    r243033 r246436  
    4545namespace WebCore {
    4646
    47 Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(Ref<RealtimeMediaSource>&& source)
    48 {
    49     return create(WTFMove(source), createCanonicalUUIDString());
    50 }
    51 
    52 Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(Ref<RealtimeMediaSource>&& source, String&& id)
    53 {
    54     return adoptRef(*new MediaStreamTrackPrivate(WTFMove(source), WTFMove(id)));
    55 }
    56 
    57 MediaStreamTrackPrivate::MediaStreamTrackPrivate(Ref<RealtimeMediaSource>&& source, String&& id)
     47Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(Ref<const Logger>&& logger, Ref<RealtimeMediaSource>&& source)
     48{
     49    return create(WTFMove(logger), WTFMove(source), createCanonicalUUIDString());
     50}
     51
     52Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(Ref<const Logger>&& logger, Ref<RealtimeMediaSource>&& source, String&& id)
     53{
     54    return adoptRef(*new MediaStreamTrackPrivate(WTFMove(logger), WTFMove(source), WTFMove(id)));
     55}
     56
     57MediaStreamTrackPrivate::MediaStreamTrackPrivate(Ref<const Logger>&& logger, Ref<RealtimeMediaSource>&& source, String&& id)
    5858    : m_source(WTFMove(source))
    5959    , m_id(WTFMove(id))
    60 {
     60    , m_logger(WTFMove(logger))
     61#if !RELEASE_LOG_DISABLED
     62    , m_logIdentifier(uniqueLogIdentifier())
     63#endif
     64{
     65    UNUSED_PARAM(logger);
     66#if !RELEASE_LOG_DISABLED
     67    m_source->setLogger(m_logger.copyRef(), m_logIdentifier);
     68#endif
    6169    m_source->addObserver(*this);
    6270}
    … …  
    148156Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::clone()
    149157{
    150     auto clonedMediaStreamTrackPrivate = create(m_source.copyRef());
     158    auto clonedMediaStreamTrackPrivate = create(m_logger.copyRef(), m_source.copyRef());
     159
    151160    clonedMediaStreamTrackPrivate->m_isEnabled = this->m_isEnabled;
    152161    clonedMediaStreamTrackPrivate->m_isEnded = this->m_isEnded;
    … …  
    280289
    281290#if !RELEASE_LOG_DISABLED
    282 void MediaStreamTrackPrivate::setLogger(const Logger& newLogger, const void* newLogIdentifier)
    283 {
    284     m_logger = &newLogger;
    285     m_logIdentifier = newLogIdentifier;
    286     ALWAYS_LOG(LOGIDENTIFIER);
    287     m_source->setLogger(newLogger, newLogIdentifier);
    288 }
    289 
    290291WTFLogChannel& MediaStreamTrackPrivate::logChannel() const
    291292{

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

    r243033 r246436  
    6565    };
    6666
    67     static Ref<MediaStreamTrackPrivate> create(Ref<RealtimeMediaSource>&&);
    68     static Ref<MediaStreamTrackPrivate> create(Ref<RealtimeMediaSource>&&, String&& id);
     67    static Ref<MediaStreamTrackPrivate> create(Ref<const Logger>&&, Ref<RealtimeMediaSource>&&);
     68    static Ref<MediaStreamTrackPrivate> create(Ref<const Logger>&&, Ref<RealtimeMediaSource>&&, String&& id);
    6969
    7070    virtual ~MediaStreamTrackPrivate();
    … …  
    118118
    119119#if !RELEASE_LOG_DISABLED
    120     void setLogger(const Logger&, const void*);
    121     const Logger& logger() const final { ASSERT(m_logger); return *m_logger.get(); }
     120    const Logger& logger() const final { return m_logger; }
    122121    const void* logIdentifier() const final { return m_logIdentifier; }
    123122#endif
    124    
     123
    125124private:
    126     MediaStreamTrackPrivate(Ref<RealtimeMediaSource>&&, String&& id);
     125    MediaStreamTrackPrivate(Ref<const Logger>&&, Ref<RealtimeMediaSource>&&, String&& id);
    127126
    128127    // RealtimeMediaSourceObserver
    … …  
    142141    const char* logClassName() const final { return "MediaStreamTrackPrivate"; }
    143142    WTFLogChannel& logChannel() const final;
    144 
    145     RefPtr<const Logger> m_logger;
    146     const void* m_logIdentifier;
    147143#endif
    148144
    … …  
    158154    HintValue m_contentHint { HintValue::Empty };
    159155    RefPtr<WebAudioSourceProvider> m_audioSourceProvider;
     156    Ref<const Logger> m_logger;
     157#if !RELEASE_LOG_DISABLED
     158    const void* m_logIdentifier;
     159#endif
    160160};
    161161

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

    r246002 r246436  
    6464RealtimeMediaSourceCenter::~RealtimeMediaSourceCenter() = default;
    6565
    66 void RealtimeMediaSourceCenter::createMediaStream(NewMediaStreamHandler&& completionHandler, String&& hashSalt, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest& request)
     66void RealtimeMediaSourceCenter::createMediaStream(Ref<const Logger>&& logger, NewMediaStreamHandler&& completionHandler, String&& hashSalt, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest& request)
    6767{
    6868    Vector<Ref<RealtimeMediaSource>> audioSources;
    … …  
    103103    }
    104104
    105     completionHandler(MediaStreamPrivate::create(audioSources, videoSources));
     105    completionHandler(MediaStreamPrivate::create(WTFMove(logger), audioSources, videoSources));
    106106}
    107107

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

    r246002 r246436  
    6060    WEBCORE_EXPORT static RealtimeMediaSourceCenter& singleton();
    6161
    62     using ValidConstraintsHandler = WTF::Function<void(Vector<CaptureDevice>&& audioDeviceUIDs, Vector<CaptureDevice>&& videoDeviceUIDs, String&&)>;
    63     using InvalidConstraintsHandler = WTF::Function<void(const String& invalidConstraint)>;
     62    using ValidConstraintsHandler = Function<void(Vector<CaptureDevice>&& audioDeviceUIDs, Vector<CaptureDevice>&& videoDeviceUIDs, String&&)>;
     63    using InvalidConstraintsHandler = Function<void(const String& invalidConstraint)>;
    6464    WEBCORE_EXPORT void validateRequestConstraints(ValidConstraintsHandler&&, InvalidConstraintsHandler&&, const MediaStreamRequest&, String&&);
    6565
    66     using NewMediaStreamHandler = WTF::Function<void(RefPtr<MediaStreamPrivate>&&)>;
    67     void createMediaStream(NewMediaStreamHandler&&, String&&, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest&);
     66    using NewMediaStreamHandler = Function<void(RefPtr<MediaStreamPrivate>&&)>;
     67    void createMediaStream(Ref<const Logger>&&, NewMediaStreamHandler&&, String&&, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest&);
    6868
    6969    WEBCORE_EXPORT Vector<CaptureDevice> getMediaStreamDevices();

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

    r240120 r246436  
    8989#if !RELEASE_LOG_DISABLED
    9090    if (!(++m_chunksReceived % 200))
    91         ALWAYS_LOG(LOGIDENTIFIER, "chunk ", m_chunksReceived);
     91        ALWAYS_LOG_IF(loggerPtr(), LOGIDENTIFIER, "chunk ", m_chunksReceived);
    9292#endif
    9393

  • trunk/Source/WebCore/platform/mediastream/mac/RealtimeIncomingVideoSourceCocoa.mm

    r240120 r246436  
    114114
    115115        if (status != kCVReturnSuccess) {
    116             ERROR_LOG(LOGIDENTIFIER, "Failed creating a pixel buffer pool with error ", status);
     116            ERROR_LOG_IF(loggerPtr(), LOGIDENTIFIER, "Failed creating a pixel buffer pool with error ", status);
    117117            return nullptr;
    118118        }
    … …  
    145145
    146146        if (status != kCVReturnSuccess) {
    147             ERROR_LOG(LOGIDENTIFIER, "Failed creating a pixel buffer with error ", status);
     147            ERROR_LOG_IF(loggerPtr(), LOGIDENTIFIER, "Failed creating a pixel buffer with error ", status);
    148148            return nullptr;
    149149        }
    … …  
    160160#if !RELEASE_LOG_DISABLED
    161161    if (!(++m_numberOfFrames % 60))
    162         ALWAYS_LOG(LOGIDENTIFIER, "frame ", m_numberOfFrames);
     162        ALWAYS_LOG_IF(loggerPtr(), LOGIDENTIFIER, "frame ", m_numberOfFrames);
    163163#endif
    164164
    165165    auto pixelBuffer = pixelBufferFromVideoFrame(frame);
    166166    if (!pixelBuffer) {
    167         ERROR_LOG(LOGIDENTIFIER, "Failed to get a pixel buffer from a frame");
     167        ERROR_LOG_IF(loggerPtr(), LOGIDENTIFIER, "Failed to get a pixel buffer from a frame");
    168168        return;
    169169    }
    … …  
    179179    OSStatus ostatus = CMVideoFormatDescriptionCreateForImageBuffer(kCFAllocatorDefault, (CVImageBufferRef)pixelBuffer, &formatDescription);
    180180    if (ostatus != noErr) {
    181         ERROR_LOG(LOGIDENTIFIER, "Failed to initialize CMVideoFormatDescription with error ", static_cast<int>(ostatus));
     181        ERROR_LOG_IF(loggerPtr(), LOGIDENTIFIER, "Failed to initialize CMVideoFormatDescription with error ", static_cast<int>(ostatus));
    182182        return;
    183183    }
    … …  
    187187    CFRelease(formatDescription);
    188188    if (ostatus != noErr) {
    189         ERROR_LOG(LOGIDENTIFIER, "Failed to create the sample buffer with error ", static_cast<int>(ostatus));
     189        ERROR_LOG_IF(loggerPtr(), LOGIDENTIFIER, "Failed to create the sample buffer with error ", static_cast<int>(ostatus));
    190190        return;
    191191    }
Note: See TracChangeset for help on using the changeset viewer.