Changeset 127425 in webkit


Ignore:
Timestamp:
Sep 3, 2012 9:08:07 AM (12 years ago)
Author:
tommyw@google.com
Message:

MediaStream API: Add Ice-related functionality to RTCPeerConnection
https://bugs.webkit.org/show_bug.cgi?id=95565

Reviewed by Adam Barth.

Source/Platform:

  • Platform.gypi:
  • chromium/public/WebRTCICECandidateDescriptor.h: Copied from Source/Platform/chromium/public/WebRTCPeerConnectionHandlerClient.h.

(WebCore):
(WebKit):
(WebRTCICECandidateDescriptor):
(WebKit::WebRTCICECandidateDescriptor::WebRTCICECandidateDescriptor):
(WebKit::WebRTCICECandidateDescriptor::~WebRTCICECandidateDescriptor):
(WebKit::WebRTCICECandidateDescriptor::operator=):
(WebKit::WebRTCICECandidateDescriptor::isNull):

  • chromium/public/WebRTCPeerConnectionHandler.h:

(WebKit):
(WebRTCPeerConnectionHandler):

  • chromium/public/WebRTCPeerConnectionHandlerClient.h:

(WebKit):
(WebRTCPeerConnectionHandlerClient):

Source/WebCore:

Adds all Ice-related functionality to RTCPeerConnection, including
events, callbacks and methods.

Test: fast/mediastream/RTCPeerConnection-ice.html

  • CMakeLists.txt:
  • GNUmakefile.list.am:
  • Modules/mediastream/RTCIceCandidateEvent.cpp: Added.

(WebCore):
(WebCore::RTCIceCandidateEvent::create):
(WebCore::RTCIceCandidateEvent::RTCIceCandidateEvent):
(WebCore::RTCIceCandidateEvent::~RTCIceCandidateEvent):
(WebCore::RTCIceCandidateEvent::candidate):
(WebCore::RTCIceCandidateEvent::interfaceName):

  • Modules/mediastream/RTCIceCandidateEvent.h: Added.

(WebCore):
(RTCIceCandidateEvent):

  • Modules/mediastream/RTCIceCandidateEvent.idl: Added.
  • Modules/mediastream/RTCPeerConnection.cpp:

(WebCore::RTCPeerConnection::RTCPeerConnection):
(WebCore::RTCPeerConnection::updateIce):
(WebCore):
(WebCore::RTCPeerConnection::addIceCandidate):
(WebCore::RTCPeerConnection::iceState):
(WebCore::RTCPeerConnection::close):
(WebCore::RTCPeerConnection::didGenerateIceCandidate):
(WebCore::RTCPeerConnection::didChangeIceState):
(WebCore::RTCPeerConnection::stop):
(WebCore::RTCPeerConnection::changeIceState):

  • Modules/mediastream/RTCPeerConnection.h:

(RTCPeerConnection):

  • Modules/mediastream/RTCPeerConnection.idl:
  • WebCore.gypi:
  • dom/EventNames.h:

(WebCore):

  • dom/EventNames.in:
  • platform/chromium/support/WebRTCICECandidateDescriptor.cpp: Copied from Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp.

(WebKit):
(WebKit::WebRTCICECandidateDescriptor::WebRTCICECandidateDescriptor):
(WebKit::WebRTCICECandidateDescriptor::assign):
(WebKit::WebRTCICECandidateDescriptor::reset):
(WebKit::WebRTCICECandidateDescriptor::initialize):
(WebKit::WebRTCICECandidateDescriptor::operator PassRefPtr<WebCore::RTCIceCandidateDescriptor>):
(WebKit::WebRTCICECandidateDescriptor::candidate):
(WebKit::WebRTCICECandidateDescriptor::sdpMid):
(WebKit::WebRTCICECandidateDescriptor::sdpMLineIndex):

  • platform/mediastream/RTCIceCandidateDescriptor.h:

(WebCore::RTCIceCandidateDescriptor::candidate):
(WebCore::RTCIceCandidateDescriptor::sdpMid):
(WebCore::RTCIceCandidateDescriptor::sdpMLineIndex):

  • platform/mediastream/RTCPeerConnectionHandler.h:

(WebCore):
(RTCPeerConnectionHandler):

  • platform/mediastream/RTCPeerConnectionHandlerClient.h:

(WebCore):
(RTCPeerConnectionHandlerClient):

  • platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp:

(WebCore::RTCPeerConnectionHandlerChromium::updateIce):
(WebCore):
(WebCore::RTCPeerConnectionHandlerChromium::addIceCandidate):
(WebCore::RTCPeerConnectionHandlerChromium::didGenerateICECandidate):
(WebCore::RTCPeerConnectionHandlerChromium::didChangeICEState):

  • platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h:

(WebKit):
(RTCPeerConnectionHandlerChromium):

Source/WebKit/chromium:

  • src/AssertMatchingEnums.cpp:

Tools:

  • DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp:

(MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler):
(MockWebRTCPeerConnectionHandler::updateICE):
(MockWebRTCPeerConnectionHandler::addICECandidate):

  • DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.h:

(MockWebRTCPeerConnectionHandler):

LayoutTests:

  • fast/mediastream/RTCPeerConnection-ice-expected.txt: Added.
  • fast/mediastream/RTCPeerConnection-ice.html: Added.
Location:
trunk
Files:
5 added
25 edited
2 copied

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r127418 r127425  
     12012-09-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Add Ice-related functionality to RTCPeerConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=95565
     5
     6        Reviewed by Adam Barth.
     7
     8        * fast/mediastream/RTCPeerConnection-ice-expected.txt: Added.
     9        * fast/mediastream/RTCPeerConnection-ice.html: Added.
     10
    1112012-09-03  Alexander Pavlov  <apavlov@chromium.org>
    212
  • trunk/Source/Platform/ChangeLog

    r127365 r127425  
     12012-09-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Add Ice-related functionality to RTCPeerConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=95565
     5
     6        Reviewed by Adam Barth.
     7
     8        * Platform.gypi:
     9        * chromium/public/WebRTCICECandidateDescriptor.h: Copied from Source/Platform/chromium/public/WebRTCPeerConnectionHandlerClient.h.
     10        (WebCore):
     11        (WebKit):
     12        (WebRTCICECandidateDescriptor):
     13        (WebKit::WebRTCICECandidateDescriptor::WebRTCICECandidateDescriptor):
     14        (WebKit::WebRTCICECandidateDescriptor::~WebRTCICECandidateDescriptor):
     15        (WebKit::WebRTCICECandidateDescriptor::operator=):
     16        (WebKit::WebRTCICECandidateDescriptor::isNull):
     17        * chromium/public/WebRTCPeerConnectionHandler.h:
     18        (WebKit):
     19        (WebRTCPeerConnectionHandler):
     20        * chromium/public/WebRTCPeerConnectionHandlerClient.h:
     21        (WebKit):
     22        (WebRTCPeerConnectionHandlerClient):
     23
    1242012-09-01  Tommy Widenflycht  <tommyw@google.com>
    225
  • trunk/Source/Platform/Platform.gypi

    r127225 r127425  
    105105            'chromium/public/WebPrivatePtr.h',
    106106            'chromium/public/WebRTCConfiguration.h',
     107            'chromium/public/WebRTCICECandidateDescriptor.h',
    107108            'chromium/public/WebRTCPeerConnectionHandler.h',
    108109            'chromium/public/WebRTCPeerConnectionHandlerClient.h',
  • trunk/Source/Platform/chromium/public/WebRTCICECandidateDescriptor.h

    r127423 r127425  
    2929 */
    3030
    31 #ifndef WebRTCPeerConnectionHandlerClient_h
    32 #define WebRTCPeerConnectionHandlerClient_h
     31#ifndef WebRTCICECandidateDescriptor_h
     32#define WebRTCICECandidateDescriptor_h
     33
     34#include "WebCommon.h"
     35#include "WebPrivatePtr.h"
     36
     37namespace WebCore {
     38class RTCIceCandidateDescriptor;
     39}
    3340
    3441namespace WebKit {
    35 class WebMediaStreamDescriptor;
    3642
    37 class WebRTCPeerConnectionHandlerClient {
     43class WebString;
     44
     45class WebRTCICECandidateDescriptor {
    3846public:
    39     enum ReadyState {
    40         ReadyStateNew = 1,
    41         ReadyStateOpening = 2,
    42         ReadyStateActive = 3,
    43         ReadyStateClosing = 4,
    44         ReadyStateClosed = 5
    45     };
     47    WebRTCICECandidateDescriptor() { }
     48    WebRTCICECandidateDescriptor(const WebRTCICECandidateDescriptor& other) { assign(other); }
     49    ~WebRTCICECandidateDescriptor() { reset(); }
    4650
    47     virtual ~WebRTCPeerConnectionHandlerClient() { }
     51    WebRTCICECandidateDescriptor& operator=(const WebRTCICECandidateDescriptor& other)
     52    {
     53        assign(other);
     54        return *this;
     55    }
    4856
    49     virtual void didChangeReadyState(ReadyState) = 0;
    50     virtual void didAddRemoteStream(const WebMediaStreamDescriptor&) = 0;
    51     virtual void didRemoveRemoteStream(const WebMediaStreamDescriptor&) = 0;
     57    WEBKIT_EXPORT void assign(const WebRTCICECandidateDescriptor&);
     58
     59    WEBKIT_EXPORT void initialize(const WebString& candidate, const WebString& sdpMid, unsigned short sdpMLineIndex);
     60    WEBKIT_EXPORT void reset();
     61    bool isNull() const { return m_private.isNull(); }
     62
     63    WEBKIT_EXPORT WebString candidate() const;
     64    WEBKIT_EXPORT WebString sdpMid() const;
     65    WEBKIT_EXPORT unsigned short sdpMLineIndex() const;
     66
     67#if WEBKIT_IMPLEMENTATION
     68    WebRTCICECandidateDescriptor(WebCore::RTCIceCandidateDescriptor*);
     69    WebRTCICECandidateDescriptor(WTF::PassRefPtr<WebCore::RTCIceCandidateDescriptor>);
     70
     71    operator WTF::PassRefPtr<WebCore::RTCIceCandidateDescriptor>() const;
     72#endif
     73
     74private:
     75    WebPrivatePtr<WebCore::RTCIceCandidateDescriptor> m_private;
    5276};
    5377
    5478} // namespace WebKit
    5579
    56 #endif // WebRTCPeerConnectionHandlerClient_h
     80#endif // WebRTCICECandidateDescriptor_h
  • trunk/Source/Platform/chromium/public/WebRTCPeerConnectionHandler.h

    r127365 r127425  
    3636class WebMediaStreamDescriptor;
    3737class WebRTCConfiguration;
     38class WebRTCICECandidateDescriptor;
    3839class WebRTCPeerConnectionHandlerClient;
    3940
     
    4445    virtual bool initialize(const WebRTCConfiguration&, const WebMediaConstraints&) = 0;
    4546
     47    virtual bool updateICE(const WebRTCConfiguration&, const WebMediaConstraints&) = 0;
     48    virtual bool addICECandidate(const WebRTCICECandidateDescriptor&) = 0;
    4649    virtual bool addStream(const WebMediaStreamDescriptor&, const WebMediaConstraints&) = 0;
    4750    virtual void removeStream(const WebMediaStreamDescriptor&) = 0;
  • trunk/Source/Platform/chromium/public/WebRTCPeerConnectionHandlerClient.h

    r127365 r127425  
    3434namespace WebKit {
    3535class WebMediaStreamDescriptor;
     36class WebRTCICECandidateDescriptor;
    3637
    3738class WebRTCPeerConnectionHandlerClient {
     
    4546    };
    4647
     48    enum ICEState {
     49        ICEStateNew = 1,
     50        ICEStateGathering = 2,
     51        ICEStateWaiting = 3,
     52        ICEStateChecking = 4,
     53        ICEStateConnected = 5,
     54        ICEStateCompleted = 6,
     55        ICEStateFailed = 7,
     56        ICEStateClosed = 8
     57    };
     58
    4759    virtual ~WebRTCPeerConnectionHandlerClient() { }
    4860
     61    virtual void didGenerateICECandidate(const WebRTCICECandidateDescriptor&) = 0;
    4962    virtual void didChangeReadyState(ReadyState) = 0;
     63    virtual void didChangeICEState(ICEState) = 0;
    5064    virtual void didAddRemoteStream(const WebMediaStreamDescriptor&) = 0;
    5165    virtual void didRemoveRemoteStream(const WebMediaStreamDescriptor&) = 0;
  • trunk/Source/WebCore/CMakeLists.txt

    r127178 r127425  
    224224    Modules/mediastream/PeerConnection00.idl
    225225    Modules/mediastream/RTCIceCandidate.idl
     226    Modules/mediastream/RTCIceCandidateEvent.idl
    226227    Modules/mediastream/RTCPeerConnection.idl
    227228    Modules/mediastream/RTCSessionDescription.idl
     
    856857    Modules/mediastream/PeerConnection00.cpp
    857858    Modules/mediastream/RTCIceCandidate.cpp
     859    Modules/mediastream/RTCIceCandidateEvent.cpp
    858860    Modules/mediastream/RTCPeerConnection.cpp
    859861    Modules/mediastream/RTCSessionDescription.cpp
  • trunk/Source/WebCore/ChangeLog

    r127423 r127425  
     12012-09-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Add Ice-related functionality to RTCPeerConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=95565
     5
     6        Reviewed by Adam Barth.
     7
     8        Adds all Ice-related functionality to RTCPeerConnection, including
     9        events, callbacks and methods.
     10
     11        Test: fast/mediastream/RTCPeerConnection-ice.html
     12
     13        * CMakeLists.txt:
     14        * GNUmakefile.list.am:
     15        * Modules/mediastream/RTCIceCandidateEvent.cpp: Added.
     16        (WebCore):
     17        (WebCore::RTCIceCandidateEvent::create):
     18        (WebCore::RTCIceCandidateEvent::RTCIceCandidateEvent):
     19        (WebCore::RTCIceCandidateEvent::~RTCIceCandidateEvent):
     20        (WebCore::RTCIceCandidateEvent::candidate):
     21        (WebCore::RTCIceCandidateEvent::interfaceName):
     22        * Modules/mediastream/RTCIceCandidateEvent.h: Added.
     23        (WebCore):
     24        (RTCIceCandidateEvent):
     25        * Modules/mediastream/RTCIceCandidateEvent.idl: Added.
     26        * Modules/mediastream/RTCPeerConnection.cpp:
     27        (WebCore::RTCPeerConnection::RTCPeerConnection):
     28        (WebCore::RTCPeerConnection::updateIce):
     29        (WebCore):
     30        (WebCore::RTCPeerConnection::addIceCandidate):
     31        (WebCore::RTCPeerConnection::iceState):
     32        (WebCore::RTCPeerConnection::close):
     33        (WebCore::RTCPeerConnection::didGenerateIceCandidate):
     34        (WebCore::RTCPeerConnection::didChangeIceState):
     35        (WebCore::RTCPeerConnection::stop):
     36        (WebCore::RTCPeerConnection::changeIceState):
     37        * Modules/mediastream/RTCPeerConnection.h:
     38        (RTCPeerConnection):
     39        * Modules/mediastream/RTCPeerConnection.idl:
     40        * WebCore.gypi:
     41        * dom/EventNames.h:
     42        (WebCore):
     43        * dom/EventNames.in:
     44        * platform/chromium/support/WebRTCICECandidateDescriptor.cpp: Copied from Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp.
     45        (WebKit):
     46        (WebKit::WebRTCICECandidateDescriptor::WebRTCICECandidateDescriptor):
     47        (WebKit::WebRTCICECandidateDescriptor::assign):
     48        (WebKit::WebRTCICECandidateDescriptor::reset):
     49        (WebKit::WebRTCICECandidateDescriptor::initialize):
     50        (WebKit::WebRTCICECandidateDescriptor::operator PassRefPtr<WebCore::RTCIceCandidateDescriptor>):
     51        (WebKit::WebRTCICECandidateDescriptor::candidate):
     52        (WebKit::WebRTCICECandidateDescriptor::sdpMid):
     53        (WebKit::WebRTCICECandidateDescriptor::sdpMLineIndex):
     54        * platform/mediastream/RTCIceCandidateDescriptor.h:
     55        (WebCore::RTCIceCandidateDescriptor::candidate):
     56        (WebCore::RTCIceCandidateDescriptor::sdpMid):
     57        (WebCore::RTCIceCandidateDescriptor::sdpMLineIndex):
     58        * platform/mediastream/RTCPeerConnectionHandler.h:
     59        (WebCore):
     60        (RTCPeerConnectionHandler):
     61        * platform/mediastream/RTCPeerConnectionHandlerClient.h:
     62        (WebCore):
     63        (RTCPeerConnectionHandlerClient):
     64        * platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp:
     65        (WebCore::RTCPeerConnectionHandlerChromium::updateIce):
     66        (WebCore):
     67        (WebCore::RTCPeerConnectionHandlerChromium::addIceCandidate):
     68        (WebCore::RTCPeerConnectionHandlerChromium::didGenerateICECandidate):
     69        (WebCore::RTCPeerConnectionHandlerChromium::didChangeICEState):
     70        * platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h:
     71        (WebKit):
     72        (RTCPeerConnectionHandlerChromium):
     73
    1742012-09-03  Allan Sandfeld Jensen  <allan.jensen@nokia.com>
    275
  • trunk/Source/WebCore/GNUmakefile.list.am

    r127217 r127425  
    630630        DerivedSources/WebCore/JSRTCIceCandidate.cpp \
    631631        DerivedSources/WebCore/JSRTCIceCandidate.h \
     632        DerivedSources/WebCore/JSRTCIceCandidateEvent.cpp \
     633        DerivedSources/WebCore/JSRTCIceCandidateEvent.h \
    632634        DerivedSources/WebCore/JSRTCPeerConnection.cpp \
    633635        DerivedSources/WebCore/JSRTCPeerConnection.h \
     
    12251227        $(WebCore)/Modules/mediastream/PeerConnection00.idl \
    12261228        $(WebCore)/Modules/mediastream/RTCIceCandidate.idl \
     1229        $(WebCore)/Modules/mediastream/RTCIceCandidateEvent.idl \
    12271230        $(WebCore)/Modules/mediastream/RTCPeerConnection.idl \
    12281231        $(WebCore)/Modules/mediastream/RTCSessionDescription.idl \
     
    19201923        Source/WebCore/Modules/mediastream/RTCIceCandidate.cpp \
    19211924        Source/WebCore/Modules/mediastream/RTCIceCandidate.h \
     1925        Source/WebCore/Modules/mediastream/RTCIceCandidateEvent.cpp \
     1926        Source/WebCore/Modules/mediastream/RTCIceCandidateEvent.h \
    19221927        Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp \
    19231928        Source/WebCore/Modules/mediastream/RTCPeerConnection.h \
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r127365 r127425  
    4141#include "MediaStreamEvent.h"
    4242#include "RTCConfiguration.h"
     43#include "RTCIceCandidate.h"
     44#include "RTCIceCandidateDescriptor.h"
     45#include "RTCIceCandidateEvent.h"
    4346#include "ScriptExecutionContext.h"
    4447
     
    115118    : ActiveDOMObject(context, this)
    116119    , m_readyState(ReadyStateNew)
     120    , m_iceState(IceStateClosed)
    117121    , m_localStreams(MediaStreamList::create())
    118122    , m_remoteStreams(MediaStreamList::create())
     
    127131}
    128132
     133void RTCPeerConnection::updateIce(const Dictionary& rtcConfiguration, const Dictionary& mediaConstraints, ExceptionCode& ec)
     134{
     135    if (m_readyState == ReadyStateClosing || m_readyState == ReadyStateClosed) {
     136        ec = INVALID_STATE_ERR;
     137        return;
     138    }
     139
     140    RefPtr<RTCConfiguration> configuration = parseConfiguration(rtcConfiguration, ec);
     141    if (ec)
     142        return;
     143
     144    RefPtr<MediaConstraints> constraints = MediaConstraintsImpl::create(mediaConstraints, ec);
     145    if (ec)
     146        return;
     147
     148    bool valid = m_peerHandler->updateIce(configuration, constraints);
     149    if (!valid)
     150        ec = SYNTAX_ERR;
     151}
     152
     153void RTCPeerConnection::addIceCandidate(RTCIceCandidate* iceCandidate, ExceptionCode& ec)
     154{
     155    if (m_readyState == ReadyStateClosing || m_readyState == ReadyStateClosed) {
     156        ec = INVALID_STATE_ERR;
     157        return;
     158    }
     159
     160    if (!iceCandidate) {
     161        ec = TYPE_MISMATCH_ERR;
     162        return;
     163    }
     164
     165    bool valid = m_peerHandler->addIceCandidate(iceCandidate->descriptor());
     166    if (!valid)
     167        ec = SYNTAX_ERR;
     168}
     169
    129170String RTCPeerConnection::readyState() const
    130171{
    131172    switch (m_readyState) {
    132173    case ReadyStateNew:
    133         return "new";
     174        return ASCIILiteral("new");
    134175    case ReadyStateOpening:
    135         return "opening";
     176        return ASCIILiteral("opening");
    136177    case ReadyStateActive:
    137         return "active";
     178        return ASCIILiteral("active");
    138179    case ReadyStateClosing:
    139         return "closing";
     180        return ASCIILiteral("closing");
    140181    case ReadyStateClosed:
    141         return "closed";
     182        return ASCIILiteral("closed");
    142183    }
    143184
    144185    ASSERT_NOT_REACHED();
    145     return "";
     186    return ASCIILiteral("");
     187}
     188
     189String RTCPeerConnection::iceState() const
     190{
     191    switch (m_iceState) {
     192    case IceStateNew:
     193        return ASCIILiteral("new");
     194    case IceStateGathering:
     195        return ASCIILiteral("gathering");
     196    case IceStateWaiting:
     197        return ASCIILiteral("waiting");
     198    case IceStateChecking:
     199        return ASCIILiteral("checking");
     200    case IceStateConnected:
     201        return ASCIILiteral("connected");
     202    case IceStateCompleted:
     203        return ASCIILiteral("completed");
     204    case IceStateFailed:
     205        return ASCIILiteral("failed");
     206    case IceStateClosed:
     207        return ASCIILiteral("closed");
     208    }
     209
     210    ASSERT_NOT_REACHED();
     211    return ASCIILiteral("");
    146212}
    147213
     
    210276    }
    211277
     278    changeIceState(IceStateClosed);
    212279    changeReadyState(ReadyStateClosed);
    213280    stop();
    214281}
    215282
     283void RTCPeerConnection::didGenerateIceCandidate(PassRefPtr<RTCIceCandidateDescriptor> iceCandidateDescriptor)
     284{
     285    ASSERT(scriptExecutionContext()->isContextThread());
     286    if (!iceCandidateDescriptor)
     287        dispatchEvent(RTCIceCandidateEvent::create(false, false, 0));
     288    else {
     289        RefPtr<RTCIceCandidate> iceCandidate = RTCIceCandidate::create(iceCandidateDescriptor);
     290        dispatchEvent(RTCIceCandidateEvent::create(false, false, iceCandidate.release()));
     291    }
     292}
     293
    216294void RTCPeerConnection::didChangeReadyState(ReadyState newState)
    217295{
     
    220298}
    221299
     300void RTCPeerConnection::didChangeIceState(IceState newState)
     301{
     302    ASSERT(scriptExecutionContext()->isContextThread());
     303    changeIceState(newState);
     304}
     305
    222306void RTCPeerConnection::didAddRemoteStream(PassRefPtr<MediaStreamDescriptor> streamDescriptor)
    223307{
     
    262346void RTCPeerConnection::stop()
    263347{
     348    m_iceState = IceStateClosed;
    264349    m_readyState = ReadyStateClosed;
    265350
     
    304389}
    305390
     391void RTCPeerConnection::changeIceState(IceState iceState)
     392{
     393    if (iceState == m_iceState || m_readyState == ReadyStateClosed)
     394        return;
     395
     396    m_iceState = iceState;
     397    dispatchEvent(Event::create(eventNames().icechangeEvent, false, false));
     398}
     399
    306400} // namespace WebCore
    307401
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

    r127365 r127425  
    4040#include "MediaStream.h"
    4141#include "MediaStreamList.h"
     42#include "RTCIceCandidate.h"
    4243#include "RTCPeerConnectionHandler.h"
    4344#include "RTCPeerConnectionHandlerClient.h"
     
    5657    String readyState() const;
    5758
     59    void updateIce(const Dictionary& rtcConfiguration, const Dictionary& mediaConstraints, ExceptionCode&);
     60
     61    void addIceCandidate(RTCIceCandidate*, ExceptionCode&);
     62
     63    String iceState() const;
     64
    5865    MediaStreamList* localStreams() const;
     66
    5967    MediaStreamList* remoteStreams() const;
     68
    6069    void addStream(const PassRefPtr<MediaStream>, const Dictionary& mediaConstraints, ExceptionCode&);
     70
    6171    void removeStream(MediaStream*, ExceptionCode&);
    6272
    6373    void close(ExceptionCode&);
    6474
     75    DEFINE_ATTRIBUTE_EVENT_LISTENER(icecandidate);
    6576    DEFINE_ATTRIBUTE_EVENT_LISTENER(open);
    6677    DEFINE_ATTRIBUTE_EVENT_LISTENER(statechange);
    6778    DEFINE_ATTRIBUTE_EVENT_LISTENER(addstream);
    6879    DEFINE_ATTRIBUTE_EVENT_LISTENER(removestream);
     80    DEFINE_ATTRIBUTE_EVENT_LISTENER(icechange);
    6981
    7082    // RTCPeerConnectionHandlerClient
     83    virtual void didGenerateIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>) OVERRIDE;
    7184    virtual void didChangeReadyState(ReadyState) OVERRIDE;
     85    virtual void didChangeIceState(IceState) OVERRIDE;
    7286    virtual void didAddRemoteStream(PassRefPtr<MediaStreamDescriptor>) OVERRIDE;
    7387    virtual void didRemoveRemoteStream(MediaStreamDescriptor*) OVERRIDE;
     
    96110
    97111    void changeReadyState(ReadyState);
     112    void changeIceState(IceState);
    98113
    99114    ReadyState m_readyState;
     115    IceState m_iceState;
    100116
    101117    RefPtr<MediaStreamList> m_localStreams;
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl

    r127365 r127425  
    3434        Conditional=MEDIA_STREAM,
    3535        ActiveDOMObject,
    36         Constructor(in Dictionary rtcICEServers, in [Optional=DefaultIsUndefined] Dictionary mediaConstraints),
     36        Constructor(in Dictionary rtcIceServers, in [Optional=DefaultIsUndefined] Dictionary mediaConstraints),
    3737        ConstructorRaisesException,
    3838        CallWith=ScriptExecutionContext,
     
    4040    ] RTCPeerConnection {
    4141        readonly attribute DOMString readyState;
     42
     43        void updateIce(in [Optional=DefaultIsUndefined] Dictionary configuration, in [Optional=DefaultIsUndefined] Dictionary mediaConstraints)
     44            raises(DOMException);
     45
     46        void addIceCandidate(in RTCIceCandidate candidate)
     47            raises(DOMException);
     48
     49        readonly attribute DOMString iceState;
    4250
    4351        readonly attribute MediaStreamList localStreams;
     
    5260            raises(DOMException);
    5361
     62        attribute EventListener onicecandidate;
    5463        attribute EventListener onopen;
    5564        attribute EventListener onstatechange;
    5665        attribute EventListener onaddstream;
    5766        attribute EventListener onremovestream;
     67        attribute EventListener onicechange;
    5868
    5969        // EventTarget interface
  • trunk/Source/WebCore/WebCore.gypi

    r127417 r127425  
    864864            'Modules/mediastream/PeerConnection00.idl',
    865865            'Modules/mediastream/RTCIceCandidate.idl',
     866            'Modules/mediastream/RTCIceCandidateEvent.idl',
    866867            'Modules/mediastream/RTCPeerConnection.idl',
    867868            'Modules/mediastream/RTCSessionDescription.idl',
     
    16061607            'Modules/mediastream/RTCIceCandidate.cpp',
    16071608            'Modules/mediastream/RTCIceCandidate.h',
     1609            'Modules/mediastream/RTCIceCandidateEvent.cpp',
     1610            'Modules/mediastream/RTCIceCandidateEvent.h',
    16081611            'Modules/mediastream/RTCPeerConnection.cpp',
    16091612            'Modules/mediastream/RTCPeerConnection.h',
     
    83388341            'platform/chromium/support/WebPrerender.cpp',
    83398342            'platform/chromium/support/WebRTCConfiguration.cpp',
     8343            'platform/chromium/support/WebRTCICECandidateDescriptor.cpp',
    83408344            'platform/chromium/support/WebScrollbarThemeGeometryNative.cpp',
    83418345            'platform/chromium/support/WebScrollbarThemeGeometryNative.h',
  • trunk/Source/WebCore/dom/EventNames.h

    r125850 r127425  
    228228    macro(mute) \
    229229    macro(unmute) \
     230    macro(icechange) \
     231    macro(icecandidate) \
    230232    \
    231233    macro(show) \
  • trunk/Source/WebCore/dom/EventNames.in

    r125850 r127425  
    3232MediaStreamEvent conditional=MEDIA_STREAM
    3333MediaStreamTrackEvent conditional=MEDIA_STREAM
     34RTCIceCandidateEvent conditional=MEDIA_STREAM
    3435SpeechInputEvent conditional=INPUT_SPEECH
    3536SpeechRecognitionError conditional=SCRIPTED_SPEECH
  • trunk/Source/WebCore/platform/chromium/support/WebRTCICECandidateDescriptor.cpp

    r127423 r127425  
    2929 */
    3030
    31 #ifndef MockWebRTCPeerConnectionHandler_h
    32 #define MockWebRTCPeerConnectionHandler_h
     31#include "config.h"
    3332
    3433#if ENABLE(MEDIA_STREAM)
    35 #include <public/WebRTCPeerConnectionHandler.h>
     34
     35#include <public/WebRTCICECandidateDescriptor.h>
     36
     37#include "RTCIceCandidateDescriptor.h"
     38#include <public/WebString.h>
     39
     40using namespace WebCore;
    3641
    3742namespace WebKit {
    38 class WebRTCPeerConnectionHandlerClient;
    39 };
    4043
    41 class MockWebRTCPeerConnectionHandler : public WebKit::WebRTCPeerConnectionHandler {
    42 public:
    43     explicit MockWebRTCPeerConnectionHandler(WebKit::WebRTCPeerConnectionHandlerClient*);
     44WebRTCICECandidateDescriptor::WebRTCICECandidateDescriptor(RTCIceCandidateDescriptor* iceCandidate)
     45    : m_private(iceCandidate)
     46{
     47}
    4448
    45     virtual bool initialize(const WebKit::WebRTCConfiguration&, const WebKit::WebMediaConstraints&) OVERRIDE;
     49WebRTCICECandidateDescriptor::WebRTCICECandidateDescriptor(PassRefPtr<RTCIceCandidateDescriptor> iceCandidate)
     50    : m_private(iceCandidate)
     51{
     52}
    4653
    47     virtual bool addStream(const WebKit::WebMediaStreamDescriptor&, const WebKit::WebMediaConstraints&) OVERRIDE;
    48     virtual void removeStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
    49     virtual void stop() OVERRIDE;
     54void WebRTCICECandidateDescriptor::assign(const WebRTCICECandidateDescriptor& other)
     55{
     56    m_private = other.m_private;
     57}
    5058
    51 private:
    52     MockWebRTCPeerConnectionHandler() { }
     59void WebRTCICECandidateDescriptor::reset()
     60{
     61    m_private.reset();
     62}
    5363
    54     WebKit::WebRTCPeerConnectionHandlerClient* m_client;
    55 };
     64void WebRTCICECandidateDescriptor::initialize(const WebString& candidate, const WebString& sdpMid, unsigned short sdpMLineIndex)
     65{
     66    m_private = RTCIceCandidateDescriptor::create(candidate, sdpMid, sdpMLineIndex);
     67}
     68
     69WebRTCICECandidateDescriptor::operator PassRefPtr<WebCore::RTCIceCandidateDescriptor>() const
     70{
     71    return m_private.get();
     72}
     73
     74WebString WebRTCICECandidateDescriptor::candidate() const
     75{
     76    ASSERT(!m_private.isNull());
     77    return m_private->candidate();
     78}
     79
     80WebString WebRTCICECandidateDescriptor::sdpMid() const
     81{
     82    ASSERT(!m_private.isNull());
     83    return m_private->sdpMid();
     84}
     85
     86unsigned short WebRTCICECandidateDescriptor::sdpMLineIndex() const
     87{
     88    ASSERT(!m_private.isNull());
     89    return m_private->sdpMLineIndex();
     90}
     91
     92} // namespace WebKit
    5693
    5794#endif // ENABLE(MEDIA_STREAM)
    5895
    59 #endif // MockWebRTCPeerConnectionHandler_h
    60 
  • trunk/Source/WebCore/platform/mediastream/RTCIceCandidateDescriptor.h

    r126328 r127425  
    4545    virtual ~RTCIceCandidateDescriptor();
    4646
    47     const String& candidate() { return m_candidate; }
    48     const String& sdpMid() { return m_sdpMid; }
    49     unsigned short sdpMLineIndex() { return m_sdpMLineIndex; }
     47    const String& candidate() const { return m_candidate; }
     48    const String& sdpMid() const { return m_sdpMid; }
     49    unsigned short sdpMLineIndex() const { return m_sdpMLineIndex; }
    5050
    5151private:
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandler.cpp

    r127365 r127425  
    4949    virtual bool initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) OVERRIDE;
    5050
     51    virtual bool updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) OVERRIDE;
     52    virtual bool addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>) OVERRIDE;
    5153    virtual bool addStream(PassRefPtr<MediaStreamDescriptor>, PassRefPtr<MediaConstraints>) OVERRIDE;
    5254    virtual void removeStream(PassRefPtr<MediaStreamDescriptor>) OVERRIDE;
     
    8688}
    8789
     90bool RTCPeerConnectionHandlerDummy::updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>)
     91{
     92    return false;
     93}
     94
     95bool RTCPeerConnectionHandlerDummy::addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>)
     96{
     97    return false;
     98}
     99
    88100void RTCPeerConnectionHandlerDummy::stop()
    89101{
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandler.h

    r127365 r127425  
    4242class MediaConstraints;
    4343class RTCConfiguration;
     44class RTCIceCandidateDescriptor;
    4445class RTCPeerConnectionHandlerClient;
    4546
     
    5152    virtual bool initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) = 0;
    5253
     54    virtual bool updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) = 0;
     55    virtual bool addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>) = 0;
    5356    virtual bool addStream(PassRefPtr<MediaStreamDescriptor>, PassRefPtr<MediaConstraints>) = 0;
    5457    virtual void removeStream(PassRefPtr<MediaStreamDescriptor>) = 0;
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandlerClient.h

    r127365 r127425  
    3939
    4040class MediaStreamDescriptor;
     41class RTCIceCandidateDescriptor;
    4142
    4243class RTCPeerConnectionHandlerClient {
     
    5051    };
    5152
     53    enum IceState {
     54        IceStateNew = 1,
     55        IceStateGathering = 2,
     56        IceStateWaiting = 3,
     57        IceStateChecking = 4,
     58        IceStateConnected = 5,
     59        IceStateCompleted = 6,
     60        IceStateFailed = 7,
     61        IceStateClosed = 8
     62    };
     63
    5264    virtual ~RTCPeerConnectionHandlerClient() { }
    5365
     66    virtual void didGenerateIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>) = 0;
    5467    virtual void didChangeReadyState(ReadyState) = 0;
     68    virtual void didChangeIceState(IceState) = 0;
    5569    virtual void didAddRemoteStream(PassRefPtr<MediaStreamDescriptor>) = 0;
    5670    virtual void didRemoveRemoteStream(MediaStreamDescriptor*) = 0;
  • trunk/Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp

    r127365 r127425  
    3737#include "MediaConstraints.h"
    3838#include "RTCConfiguration.h"
     39#include "RTCIceCandidateDescriptor.h"
    3940#include "RTCPeerConnectionHandlerClient.h"
    4041#include <public/Platform.h>
     
    4243#include <public/WebMediaStreamDescriptor.h>
    4344#include <public/WebRTCConfiguration.h>
     45#include <public/WebRTCICECandidateDescriptor.h>
    4446#include <wtf/PassOwnPtr.h>
    4547
     
    6567    m_webHandler = adoptPtr(WebKit::Platform::current()->createRTCPeerConnectionHandler(this));
    6668    return m_webHandler ? m_webHandler->initialize(configuration, constraints) : false;
     69}
     70
     71bool RTCPeerConnectionHandlerChromium::updateIce(PassRefPtr<RTCConfiguration> configuration, PassRefPtr<MediaConstraints> constraints)
     72{
     73    if (!m_webHandler)
     74        return false;
     75
     76    return m_webHandler->updateICE(configuration, constraints);
     77}
     78
     79bool RTCPeerConnectionHandlerChromium::addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor> iceCandidate)
     80{
     81    if (!m_webHandler)
     82        return false;
     83
     84    return m_webHandler->addICECandidate(iceCandidate);
    6785}
    6886
     
    91109}
    92110
     111void RTCPeerConnectionHandlerChromium::didGenerateICECandidate(const WebKit::WebRTCICECandidateDescriptor& iceCandidate)
     112{
     113    m_client->didGenerateIceCandidate(iceCandidate);
     114}
     115
    93116void RTCPeerConnectionHandlerChromium::didChangeReadyState(WebKit::WebRTCPeerConnectionHandlerClient::ReadyState state)
    94117{
    95118    m_client->didChangeReadyState(static_cast<RTCPeerConnectionHandlerClient::ReadyState>(state));
     119}
     120
     121void RTCPeerConnectionHandlerChromium::didChangeICEState(WebKit::WebRTCPeerConnectionHandlerClient::ICEState state)
     122{
     123    m_client->didChangeIceState(static_cast<RTCPeerConnectionHandlerClient::IceState>(state));
    96124}
    97125
  • trunk/Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h

    r127365 r127425  
    4343namespace WebKit {
    4444class WebMediaStreamDescriptor;
     45class WebRTCICECandidateDescriptor;
    4546}
    4647
     
    5455    virtual bool initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) OVERRIDE;
    5556
     57    virtual bool updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) OVERRIDE;
     58    virtual bool addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>) OVERRIDE;
    5659    virtual bool addStream(PassRefPtr<MediaStreamDescriptor>, PassRefPtr<MediaConstraints>) OVERRIDE;
    5760    virtual void removeStream(PassRefPtr<MediaStreamDescriptor>) OVERRIDE;
     
    5962
    6063    // WebKit::WebRTCPeerConnectionHandlerClient implementation.
     64    virtual void didGenerateICECandidate(const WebKit::WebRTCICECandidateDescriptor&) OVERRIDE;
    6165    virtual void didChangeReadyState(WebKit::WebRTCPeerConnectionHandlerClient::ReadyState) OVERRIDE;
     66    virtual void didChangeICEState(WebKit::WebRTCPeerConnectionHandlerClient::ICEState) OVERRIDE;
    6267    virtual void didAddRemoteStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
    6368    virtual void didRemoveRemoteStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
  • trunk/Source/WebKit/chromium/ChangeLog

    r127378 r127425  
     12012-09-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Add Ice-related functionality to RTCPeerConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=95565
     5
     6        Reviewed by Adam Barth.
     7
     8        * src/AssertMatchingEnums.cpp:
     9
    1102012-09-01  James Robinson  <jamesr@chromium.org>
    211
  • trunk/Source/WebKit/chromium/src/AssertMatchingEnums.cpp

    r127365 r127425  
    603603COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ReadyStateClosing, RTCPeerConnectionHandlerClient::ReadyStateClosing);
    604604COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ReadyStateClosed, RTCPeerConnectionHandlerClient::ReadyStateClosed);
     605
     606COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateNew, RTCPeerConnectionHandlerClient::IceStateNew);
     607COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateGathering, RTCPeerConnectionHandlerClient::IceStateGathering);
     608COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateWaiting, RTCPeerConnectionHandlerClient::IceStateWaiting);
     609COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateChecking, RTCPeerConnectionHandlerClient::IceStateChecking);
     610COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateConnected, RTCPeerConnectionHandlerClient::IceStateConnected);
     611COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateCompleted, RTCPeerConnectionHandlerClient::IceStateCompleted);
     612COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateFailed, RTCPeerConnectionHandlerClient::IceStateFailed);
     613COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateClosed, RTCPeerConnectionHandlerClient::IceStateClosed);
    605614#endif
    606615
  • trunk/Tools/ChangeLog

    r127411 r127425  
     12012-09-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Add Ice-related functionality to RTCPeerConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=95565
     5
     6        Reviewed by Adam Barth.
     7
     8        * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp:
     9        (MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler):
     10        (MockWebRTCPeerConnectionHandler::updateICE):
     11        (MockWebRTCPeerConnectionHandler::addICECandidate):
     12        * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.h:
     13        (MockWebRTCPeerConnectionHandler):
     14
    1152012-09-03  Christophe Dumez  <christophe.dumez@intel.com>
    216
  • trunk/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp

    r127365 r127425  
    8787}
    8888
     89bool MockWebRTCPeerConnectionHandler::updateICE(const WebRTCConfiguration&, const WebMediaConstraints&)
     90{
     91    m_client->didChangeICEState(WebRTCPeerConnectionHandlerClient::ICEStateGathering);
     92    return true;
     93}
     94
     95bool MockWebRTCPeerConnectionHandler::addICECandidate(const WebRTCICECandidateDescriptor& iceCandidate)
     96{
     97    m_client->didGenerateICECandidate(iceCandidate);
     98    return true;
     99}
     100
    89101bool MockWebRTCPeerConnectionHandler::addStream(const WebMediaStreamDescriptor& stream, const WebMediaConstraints&)
    90102{
  • trunk/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.h

    r127365 r127425  
    4545    virtual bool initialize(const WebKit::WebRTCConfiguration&, const WebKit::WebMediaConstraints&) OVERRIDE;
    4646
     47    virtual bool updateICE(const WebKit::WebRTCConfiguration&, const WebKit::WebMediaConstraints&) OVERRIDE;
     48    virtual bool addICECandidate(const WebKit::WebRTCICECandidateDescriptor&) OVERRIDE;
    4749    virtual bool addStream(const WebKit::WebMediaStreamDescriptor&, const WebKit::WebMediaConstraints&) OVERRIDE;
    4850    virtual void removeStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
Note: See TracChangeset for help on using the changeset viewer.