Changeset 159769 in webkit


Ignore:
Timestamp:
Nov 25, 2013 3:21:47 PM (10 years ago)
Author:
commit-queue@webkit.org
Message:

[MediaStream] Use std::unique_ptr instead of OwnPtr/PassOwnPtr
https://bugs.webkit.org/show_bug.cgi?id=124858

Patch by Sergio Correia <Sergio Correia> on 2013-11-25
Reviewed by Eric Carlson.

Another step of the OwnPtr/PassOwnPtr => std::unique_ptr conversion,
now targeting mediastream-related code.

No new tests, covered by existing ones.

  • Modules/mediastream/RTCDTMFSender.cpp:
  • Modules/mediastream/RTCDTMFSender.h:
  • Modules/mediastream/RTCDataChannel.cpp:
  • Modules/mediastream/RTCDataChannel.h:
  • Modules/mediastream/RTCPeerConnection.cpp:
  • Modules/mediastream/RTCPeerConnection.h:
  • platform/mediastream/MediaStreamSource.cpp:
  • platform/mediastream/RTCPeerConnectionHandler.cpp:
  • platform/mediastream/RTCPeerConnectionHandler.h:
  • platform/mediastream/RTCPeerConnectionHandlerClient.h:
  • platform/mock/RTCNotifiersMock.cpp:
  • platform/mock/RTCPeerConnectionHandlerMock.cpp:
  • platform/mock/RTCPeerConnectionHandlerMock.h:
Location:
trunk/Source/WebCore
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r159767 r159769  
     12013-11-25  Sergio Correia  <sergio.correia@openbossa.org>
     2
     3        [MediaStream] Use std::unique_ptr instead of OwnPtr/PassOwnPtr
     4        https://bugs.webkit.org/show_bug.cgi?id=124858
     5
     6        Reviewed by Eric Carlson.
     7
     8        Another step of the OwnPtr/PassOwnPtr => std::unique_ptr conversion,
     9        now targeting mediastream-related code.
     10
     11        No new tests, covered by existing ones.
     12
     13        * Modules/mediastream/RTCDTMFSender.cpp:
     14        * Modules/mediastream/RTCDTMFSender.h:
     15        * Modules/mediastream/RTCDataChannel.cpp:
     16        * Modules/mediastream/RTCDataChannel.h:
     17        * Modules/mediastream/RTCPeerConnection.cpp:
     18        * Modules/mediastream/RTCPeerConnection.h:
     19        * platform/mediastream/MediaStreamSource.cpp:
     20        * platform/mediastream/RTCPeerConnectionHandler.cpp:
     21        * platform/mediastream/RTCPeerConnectionHandler.h:
     22        * platform/mediastream/RTCPeerConnectionHandlerClient.h:
     23        * platform/mock/RTCNotifiersMock.cpp:
     24        * platform/mock/RTCPeerConnectionHandlerMock.cpp:
     25        * platform/mock/RTCPeerConnectionHandlerMock.h:
     26
    1272013-11-25  Nick Diego Yamane  <nick.yamane@openbossa.org>
    228
  • trunk/Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp

    r159447 r159769  
    4848{
    4949    RefPtr<MediaStreamTrack> track = prpTrack;
    50     OwnPtr<RTCDTMFSenderHandler> handler = peerConnectionHandler->createDTMFSender(track->source());
     50    std::unique_ptr<RTCDTMFSenderHandler> handler = peerConnectionHandler->createDTMFSender(track->source());
    5151    if (!handler) {
    5252        ec = NOT_SUPPORTED_ERR;
     
    5454    }
    5555
    56     RefPtr<RTCDTMFSender> dtmfSender = adoptRef(new RTCDTMFSender(context, track, handler.release()));
     56    RefPtr<RTCDTMFSender> dtmfSender = adoptRef(new RTCDTMFSender(context, track, std::move(handler)));
    5757    dtmfSender->suspendIfNeeded();
    5858    return dtmfSender.release();
    5959}
    6060
    61 RTCDTMFSender::RTCDTMFSender(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrack> track, PassOwnPtr<RTCDTMFSenderHandler> handler)
     61RTCDTMFSender::RTCDTMFSender(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrack> track, std::unique_ptr<RTCDTMFSenderHandler> handler)
    6262    : ActiveDOMObject(context)
    6363    , m_track(track)
    6464    , m_duration(defaultToneDurationMs)
    6565    , m_interToneGap(defaultInterToneGapMs)
    66     , m_handler(handler)
     66    , m_handler(std::move(handler))
    6767    , m_stopped(false)
    6868    , m_scheduledEventTimer(this, &RTCDTMFSender::scheduledEventTimerFired)
  • trunk/Source/WebCore/Modules/mediastream/RTCDTMFSender.h

    r157653 r159769  
    7070
    7171private:
    72     RTCDTMFSender(ScriptExecutionContext*, PassRefPtr<MediaStreamTrack>, PassOwnPtr<RTCDTMFSenderHandler>);
     72    RTCDTMFSender(ScriptExecutionContext*, PassRefPtr<MediaStreamTrack>, std::unique_ptr<RTCDTMFSenderHandler>);
    7373
    7474    void scheduleDispatchEvent(PassRefPtr<Event>);
     
    8686    long m_interToneGap;
    8787
    88     OwnPtr<RTCDTMFSenderHandler> m_handler;
     88    std::unique_ptr<RTCDTMFSenderHandler> m_handler;
    8989
    9090    bool m_stopped;
  • trunk/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp

    r159447 r159769  
    6565    options.get("protocol", initData.protocol);
    6666
    67     OwnPtr<RTCDataChannelHandler> handler = peerConnectionHandler->createDataChannel(label, initData);
     67    std::unique_ptr<RTCDataChannelHandler> handler = peerConnectionHandler->createDataChannel(label, initData);
    6868    if (!handler) {
    6969        ec = NOT_SUPPORTED_ERR;
    7070        return nullptr;
    7171    }
    72     return adoptRef(new RTCDataChannel(context, handler.release()));
    73 }
    74 
    75 PassRefPtr<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext* context, PassOwnPtr<RTCDataChannelHandler> handler)
     72    return adoptRef(new RTCDataChannel(context, std::move(handler)));
     73}
     74
     75PassRefPtr<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext* context, std::unique_ptr<RTCDataChannelHandler> handler)
    7676{
    7777    ASSERT(handler);
    78     return adoptRef(new RTCDataChannel(context, handler));
    79 }
    80 
    81 RTCDataChannel::RTCDataChannel(ScriptExecutionContext* context, PassOwnPtr<RTCDataChannelHandler> handler)
     78    return adoptRef(new RTCDataChannel(context, std::move(handler)));
     79}
     80
     81RTCDataChannel::RTCDataChannel(ScriptExecutionContext* context, std::unique_ptr<RTCDataChannelHandler> handler)
    8282    : m_scriptExecutionContext(context)
    83     , m_handler(handler)
     83    , m_handler(std::move(handler))
    8484    , m_stopped(false)
    8585    , m_readyState(ReadyStateConnecting)
  • trunk/Source/WebCore/Modules/mediastream/RTCDataChannel.h

    r157653 r159769  
    4848class RTCDataChannel FINAL : public RefCounted<RTCDataChannel>, public ScriptWrappable, public EventTargetWithInlineData, public RTCDataChannelHandlerClient {
    4949public:
    50     static PassRefPtr<RTCDataChannel> create(ScriptExecutionContext*, PassOwnPtr<RTCDataChannelHandler>);
     50    static PassRefPtr<RTCDataChannel> create(ScriptExecutionContext*, std::unique_ptr<RTCDataChannelHandler>);
    5151    static PassRefPtr<RTCDataChannel> create(ScriptExecutionContext*, RTCPeerConnectionHandler*, const String& , const Dictionary&, ExceptionCode&);
    5252    ~RTCDataChannel();
     
    8787
    8888private:
    89     RTCDataChannel(ScriptExecutionContext*, PassOwnPtr<RTCDataChannelHandler>);
     89    RTCDataChannel(ScriptExecutionContext*, std::unique_ptr<RTCDataChannelHandler>);
    9090
    9191    void scheduleDispatchEvent(PassRefPtr<Event>);
     
    104104    virtual void didDetectError() OVERRIDE;
    105105
    106     OwnPtr<RTCDataChannelHandler> m_handler;
     106    std::unique_ptr<RTCDataChannelHandler> m_handler;
    107107
    108108    bool m_stopped;
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r159447 r159769  
    575575}
    576576
    577 void RTCPeerConnection::didAddRemoteDataChannel(PassOwnPtr<RTCDataChannelHandler> handler)
     577void RTCPeerConnection::didAddRemoteDataChannel(std::unique_ptr<RTCDataChannelHandler> handler)
    578578{
    579579    ASSERT(scriptExecutionContext()->isContextThread());
     
    582582        return;
    583583
    584     RefPtr<RTCDataChannel> channel = RTCDataChannel::create(scriptExecutionContext(), handler);
     584    RefPtr<RTCDataChannel> channel = RTCDataChannel::create(scriptExecutionContext(), std::move(handler));
    585585    m_dataChannels.append(channel);
    586586
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

    r158849 r159769  
    119119    virtual void didAddRemoteStream(PassRefPtr<MediaStreamPrivate>) OVERRIDE;
    120120    virtual void didRemoveRemoteStream(MediaStreamPrivate*) OVERRIDE;
    121     virtual void didAddRemoteDataChannel(PassOwnPtr<RTCDataChannelHandler>) OVERRIDE;
     121    virtual void didAddRemoteDataChannel(std::unique_ptr<RTCDataChannelHandler>) OVERRIDE;
    122122
    123123    // EventTarget
     
    156156    Vector<RefPtr<RTCDataChannel>> m_dataChannels;
    157157
    158     OwnPtr<RTCPeerConnectionHandler> m_peerHandler;
     158    std::unique_ptr<RTCPeerConnectionHandler> m_peerHandler;
    159159
    160160    Timer<RTCPeerConnection> m_scheduledEventTimer;
  • trunk/Source/WebCore/platform/mediastream/MediaStreamSource.cpp

    r158849 r159769  
    4040#include "MediaStreamSourceCapabilities.h"
    4141#include "UUID.h"
    42 
    43 #include <wtf/PassOwnPtr.h>
    4442
    4543namespace WebCore {
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandler.cpp

    r157808 r159769  
    3535#include "RTCPeerConnectionHandler.h"
    3636
    37 #include <wtf/PassOwnPtr.h>
    38 
    3937namespace WebCore {
    4038class RTCPeerConnectionHandlerClient;
    4139
    42 static PassOwnPtr<RTCPeerConnectionHandler> createHandler(RTCPeerConnectionHandlerClient*)
     40static std::unique_ptr<RTCPeerConnectionHandler> createHandler(RTCPeerConnectionHandlerClient*)
    4341{
    4442    return nullptr;
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandler.h

    r158849 r159769  
    3535
    3636#include "MediaStreamPrivate.h"
    37 #include <wtf/PassOwnPtr.h>
    3837#include <wtf/PassRefPtr.h>
    3938
     
    6968};
    7069
    71 typedef PassOwnPtr<RTCPeerConnectionHandler> (*CreatePeerConnectionHandler)(RTCPeerConnectionHandlerClient*);
     70typedef std::unique_ptr<RTCPeerConnectionHandler> (*CreatePeerConnectionHandler)(RTCPeerConnectionHandlerClient*);
    7271
    7372class RTCPeerConnectionHandler {
     
    8988    virtual void removeStream(PassRefPtr<MediaStreamPrivate>) = 0;
    9089    virtual void getStats(PassRefPtr<RTCStatsRequest>) = 0;
    91     virtual PassOwnPtr<RTCDataChannelHandler> createDataChannel(const String& label, const RTCDataChannelInit&) = 0;
    92     virtual PassOwnPtr<RTCDTMFSenderHandler> createDTMFSender(PassRefPtr<MediaStreamSource>) = 0;
     90    virtual std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String& label, const RTCDataChannelInit&) = 0;
     91    virtual std::unique_ptr<RTCDTMFSenderHandler> createDTMFSender(PassRefPtr<MediaStreamSource>) = 0;
    9392    virtual void stop() = 0;
    94 
    95 protected:
    96     RTCPeerConnectionHandler() { }
    9793};
    9894
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandlerClient.h

    r158849 r159769  
    3434#if ENABLE(MEDIA_STREAM)
    3535
    36 #include <wtf/PassOwnPtr.h>
    3736#include <wtf/PassRefPtr.h>
    3837
     
    7978    virtual void didAddRemoteStream(PassRefPtr<MediaStreamPrivate>) = 0;
    8079    virtual void didRemoveRemoteStream(MediaStreamPrivate*) = 0;
    81     virtual void didAddRemoteDataChannel(PassOwnPtr<RTCDataChannelHandler>) = 0;
     80    virtual void didAddRemoteDataChannel(std::unique_ptr<RTCDataChannelHandler>) = 0;
    8281};
    8382
  • trunk/Source/WebCore/platform/mock/RTCNotifiersMock.cpp

    r157892 r159769  
    8585void RemoteDataChannelNotifier::fire()
    8686{
    87     m_client->didAddRemoteDataChannel(adoptPtr(new RTCDataChannelHandlerMock("RTCDataChannelHandlerMock", RTCDataChannelInit())));
     87    m_client->didAddRemoteDataChannel(std::make_unique<RTCDataChannelHandlerMock>("RTCDataChannelHandlerMock", RTCDataChannelInit()));
    8888}
    8989
  • trunk/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.cpp

    r158849 r159769  
    4040
    4141namespace WebCore {
    42 
    43 PassOwnPtr<RTCPeerConnectionHandler> RTCPeerConnectionHandlerMock::create(RTCPeerConnectionHandlerClient* client)
    44 {
    45     return adoptPtr(new RTCPeerConnectionHandlerMock(client));
    46 }
    4742
    4843RTCPeerConnectionHandlerMock::RTCPeerConnectionHandlerMock(RTCPeerConnectionHandlerClient* client)
     
    154149}
    155150
    156 PassOwnPtr<RTCDataChannelHandler> RTCPeerConnectionHandlerMock::createDataChannel(const String& label, const RTCDataChannelInit& init)
     151std::unique_ptr<RTCDataChannelHandler> RTCPeerConnectionHandlerMock::createDataChannel(const String& label, const RTCDataChannelInit& init)
    157152{
    158153    RefPtr<RemoteDataChannelNotifier> notifier = adoptRef(new RemoteDataChannelNotifier(m_client));
    159154    m_timerEvents.append(adoptRef(new TimerEvent(this, notifier)));
    160     return adoptPtr(new RTCDataChannelHandlerMock(label, init));
     155    return std::make_unique<RTCDataChannelHandlerMock>(label, init);
    161156}
    162157
    163 PassOwnPtr<RTCDTMFSenderHandler> RTCPeerConnectionHandlerMock::createDTMFSender(PassRefPtr<MediaStreamSource>)
     158std::unique_ptr<RTCDTMFSenderHandler> RTCPeerConnectionHandlerMock::createDTMFSender(PassRefPtr<MediaStreamSource>)
    164159{
    165160    // Requires a mock implementation of RTCDTMFSenderHandler.
    166161    // This must be implemented once the mock implementation of RTCDataChannelHandler is ready.
    167162    notImplemented();
    168     return 0;
     163    return nullptr;
    169164}
    170165
  • trunk/Source/WebCore/platform/mock/RTCPeerConnectionHandlerMock.h

    r158849 r159769  
    3737class RTCPeerConnectionHandlerMock FINAL : public RTCPeerConnectionHandler, public TimerEventBasedMock {
    3838public:
    39     static PassOwnPtr<RTCPeerConnectionHandler> create(RTCPeerConnectionHandlerClient*);
    4039    virtual ~RTCPeerConnectionHandlerMock() { }
    4140
     
    5352    virtual void removeStream(PassRefPtr<MediaStreamPrivate>) OVERRIDE;
    5453    virtual void getStats(PassRefPtr<RTCStatsRequest>) OVERRIDE;
    55     virtual PassOwnPtr<RTCDataChannelHandler> createDataChannel(const String& label, const RTCDataChannelInit&) OVERRIDE;
    56     virtual PassOwnPtr<RTCDTMFSenderHandler> createDTMFSender(PassRefPtr<MediaStreamSource>) OVERRIDE;
     54    virtual std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String& label, const RTCDataChannelInit&) OVERRIDE;
     55    virtual std::unique_ptr<RTCDTMFSenderHandler> createDTMFSender(PassRefPtr<MediaStreamSource>) OVERRIDE;
    5756    virtual void stop() OVERRIDE;
    5857
    5958protected:
    60     RTCPeerConnectionHandlerMock(RTCPeerConnectionHandlerClient*);
     59    explicit RTCPeerConnectionHandlerMock(RTCPeerConnectionHandlerClient*);
    6160
    6261private:
Note: See TracChangeset for help on using the changeset viewer.