Changeset 214030 in webkit


Ignore:
Timestamp:
Mar 15, 2017 11:10:34 PM (7 years ago)
Author:
jonlee@apple.com
Message:

Flatten RTC enum naming
https://bugs.webkit.org/show_bug.cgi?id=169664

Reviewed by Youenn Fablet.

Use consistent names of RTC enums throughout WebCore. This means surfacing
ICE enums out of PeerConnectionState. Keep the old names around for other
ports.

Add RTCIceConnectionState, RTCIceGatheringState, and RTCSignalingState enums.

  • CMakeLists.txt:
  • DerivedSources.make:
  • Modules/mediastream/RTCIceConnectionState.h: Added. The enum is defined in

PeerConnectionStates.h, so just include that file.

  • Modules/mediastream/RTCIceConnectionState.idl: Added.
  • Modules/mediastream/RTCIceGatheringState.h: Added.
  • Modules/mediastream/RTCIceGatheringState.idl: Added.
  • Modules/mediastream/RTCSignalingState.h: Added.
  • Modules/mediastream/RTCSignalingState.idl: Added.
  • WebCore.xcodeproj/project.pbxproj:
  • platform/mediastream/PeerConnectionStates.h: Move the existing enums into

WebCore, but keep aliases to the old names within the PeerConnectionStates
namespace.

Refactor to use the new enum names.

  • Modules/mediastream/MediaEndpointPeerConnection.cpp: Refactor.
  • Modules/mediastream/MediaEndpointPeerConnection.h:
  • Modules/mediastream/PeerConnectionBackend.cpp:
  • Modules/mediastream/PeerConnectionBackend.h:
  • Modules/mediastream/RTCConfiguration.h:
  • Modules/mediastream/RTCConfiguration.idl: Add FIXMEs for bringing this up

to spec.

  • Modules/mediastream/RTCIceTransport.h:
  • Modules/mediastream/RTCPeerConnection.cpp: Refactor the three functions

below to using the enum instead of returning strings. This allows remove of
the internal* versions of these functions.
(WebCore::RTCPeerConnection::signalingState): Deleted.
(WebCore::RTCPeerConnection::iceGatheringState): Deleted.
(WebCore::RTCPeerConnection::iceConnectionState): Deleted.

  • Modules/mediastream/RTCPeerConnection.h: Replace internalSignalingState,

internalIceGatheringState, and internalIceConnectionState.

  • Modules/mediastream/RTCPeerConnection.idl:
  • Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:
  • Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:
  • platform/mediastream/MediaEndpoint.h:
  • platform/mediastream/MediaEndpointConfiguration.cpp:
  • platform/mediastream/MediaEndpointConfiguration.h:
  • platform/mock/MockMediaEndpoint.cpp:
  • platform/mock/MockMediaEndpoint.h:
  • platform/mediastream/openwebrtc/MediaEndpointOwr.cpp:

(WebCore::MediaEndpointOwr::processIceTransportStateChange):

Location:
trunk/Source/WebCore
Files:
6 added
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/CMakeLists.txt

    r213992 r214030  
    242242    Modules/mediastream/RTCIceCandidate.idl
    243243    Modules/mediastream/RTCIceCandidateEvent.idl
     244    Modules/mediastream/RTCIceConnectionState.idl
     245    Modules/mediastream/RTCIceGatheringState.idl
    244246    Modules/mediastream/RTCIceServer.idl
    245247    Modules/mediastream/RTCOfferAnswerOptions.idl
     
    251253    Modules/mediastream/RTCRtpTransceiverDirection.idl
    252254    Modules/mediastream/RTCSessionDescription.idl
     255    Modules/mediastream/RTCSignalingState.idl
    253256    Modules/mediastream/RTCStatsReport.idl
    254257    Modules/mediastream/RTCTrackEvent.idl
  • trunk/Source/WebCore/ChangeLog

    r214027 r214030  
     12017-03-15  Jon Lee  <jonlee@apple.com>
     2
     3        Flatten RTC enum naming
     4        https://bugs.webkit.org/show_bug.cgi?id=169664
     5
     6        Reviewed by Youenn Fablet.
     7
     8        Use consistent names of RTC enums throughout WebCore. This means surfacing
     9        ICE enums out of PeerConnectionState. Keep the old names around for other
     10        ports.
     11
     12        Add RTCIceConnectionState, RTCIceGatheringState, and RTCSignalingState enums.
     13        * CMakeLists.txt:
     14        * DerivedSources.make:
     15        * Modules/mediastream/RTCIceConnectionState.h: Added. The enum is defined in
     16        PeerConnectionStates.h, so just include that file.
     17        * Modules/mediastream/RTCIceConnectionState.idl: Added.
     18        * Modules/mediastream/RTCIceGatheringState.h: Added.
     19        * Modules/mediastream/RTCIceGatheringState.idl: Added.
     20        * Modules/mediastream/RTCSignalingState.h: Added.
     21        * Modules/mediastream/RTCSignalingState.idl: Added.
     22        * WebCore.xcodeproj/project.pbxproj:
     23
     24        * platform/mediastream/PeerConnectionStates.h: Move the existing enums into
     25        WebCore, but keep aliases to the old names within the PeerConnectionStates
     26        namespace.
     27
     28        Refactor to use the new enum names.
     29        * Modules/mediastream/MediaEndpointPeerConnection.cpp: Refactor.
     30        * Modules/mediastream/MediaEndpointPeerConnection.h:
     31        * Modules/mediastream/PeerConnectionBackend.cpp:
     32        * Modules/mediastream/PeerConnectionBackend.h:
     33        * Modules/mediastream/RTCConfiguration.h:
     34        * Modules/mediastream/RTCConfiguration.idl: Add FIXMEs for bringing this up
     35        to spec.
     36        * Modules/mediastream/RTCIceTransport.h:
     37        * Modules/mediastream/RTCPeerConnection.cpp: Refactor the three functions
     38        below to using the enum instead of returning strings. This allows remove of
     39        the internal* versions of these functions.
     40        (WebCore::RTCPeerConnection::signalingState): Deleted.
     41        (WebCore::RTCPeerConnection::iceGatheringState): Deleted.
     42        (WebCore::RTCPeerConnection::iceConnectionState): Deleted.
     43        * Modules/mediastream/RTCPeerConnection.h: Replace internalSignalingState,
     44        internalIceGatheringState, and internalIceConnectionState.
     45        * Modules/mediastream/RTCPeerConnection.idl:
     46        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:
     47        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:
     48        * platform/mediastream/MediaEndpoint.h:
     49        * platform/mediastream/MediaEndpointConfiguration.cpp:
     50        * platform/mediastream/MediaEndpointConfiguration.h:
     51        * platform/mock/MockMediaEndpoint.cpp:
     52        * platform/mock/MockMediaEndpoint.h:
     53        * platform/mediastream/openwebrtc/MediaEndpointOwr.cpp:
     54        (WebCore::MediaEndpointOwr::processIceTransportStateChange):
     55
    1562017-03-15  Jer Noble  <jer.noble@apple.com>
    257
  • trunk/Source/WebCore/DerivedSources.make

    r213992 r214030  
    186186    $(WebCore)/Modules/mediastream/RTCIceCandidate.idl \
    187187    $(WebCore)/Modules/mediastream/RTCIceCandidateEvent.idl \
     188    $(WebCore)/Modules/mediastream/RTCIceConnectionState.idl \
     189    $(WebCore)/Modules/mediastream/RTCIceGatheringState.idl \
    188190    $(WebCore)/Modules/mediastream/RTCIceServer.idl \
    189191    $(WebCore)/Modules/mediastream/RTCOfferAnswerOptions.idl \
     
    195197    $(WebCore)/Modules/mediastream/RTCRtpTransceiverDirection.idl \
    196198    $(WebCore)/Modules/mediastream/RTCSessionDescription.idl \
     199    $(WebCore)/Modules/mediastream/RTCSignalingState.idl \
    197200    $(WebCore)/Modules/mediastream/RTCStatsReport.idl \
    198201    $(WebCore)/Modules/mediastream/RTCTrackEvent.idl \
  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.cpp

    r213992 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3031
    3132#include "config.h"
     33#include "MediaEndpointPeerConnection.h"
    3234
    3335#if ENABLE(WEB_RTC)
    34 #include "MediaEndpointPeerConnection.h"
    3536
    3637#include "EventNames.h"
     
    5859
    5960using namespace PeerConnection;
    60 using namespace PeerConnectionStates;
    6161
    6262using MediaDescriptionVector = Vector<PeerMediaDescription>;
     
    331331void MediaEndpointPeerConnection::setLocalDescriptionTask(RefPtr<RTCSessionDescription>&& description)
    332332{
    333     if (m_peerConnection.internalSignalingState() == SignalingState::Closed)
     333    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    334334        return;
    335335
     
    352352
    353353        if (result == MediaEndpoint::UpdateResult::SuccessWithIceRestart) {
    354             if (m_peerConnection.internalIceGatheringState() != IceGatheringState::Gathering)
    355                 m_peerConnection.updateIceGatheringState(IceGatheringState::Gathering);
    356 
    357             if (m_peerConnection.internalIceConnectionState() != IceConnectionState::Completed)
    358                 m_peerConnection.updateIceConnectionState(IceConnectionState::Connected);
     354            if (m_peerConnection.iceGatheringState() != RTCIceGatheringState::Gathering)
     355                m_peerConnection.updateIceGatheringState(RTCIceGatheringState::Gathering);
     356
     357            if (m_peerConnection.iceConnectionState() != RTCIceConnectionState::Completed)
     358                m_peerConnection.updateIceConnectionState(RTCIceConnectionState::Connected);
    359359
    360360            LOG_ERROR("ICE restart is not implemented");
     
    389389        clearNegotiationNeededState();
    390390
    391     SignalingState newSignalingState;
     391    RTCSignalingState newSignalingState;
    392392
    393393    // Update state and local descriptions according to setLocal/RemoteDescription processing model
     
    395395    case RTCSessionDescription::SdpType::Offer:
    396396        m_pendingLocalDescription = WTFMove(newDescription);
    397         newSignalingState = SignalingState::HaveLocalOffer;
     397        newSignalingState = RTCSignalingState::HaveLocalOffer;
    398398        break;
    399399
     
    403403        m_pendingLocalDescription = nullptr;
    404404        m_pendingRemoteDescription = nullptr;
    405         newSignalingState = SignalingState::Stable;
     405        newSignalingState = RTCSignalingState::Stable;
    406406        break;
    407407
    408408    case RTCSessionDescription::SdpType::Rollback:
    409409        m_pendingLocalDescription = nullptr;
    410         newSignalingState = SignalingState::Stable;
     410        newSignalingState = RTCSignalingState::Stable;
    411411        break;
    412412
    413413    case RTCSessionDescription::SdpType::Pranswer:
    414414        m_pendingLocalDescription = WTFMove(newDescription);
    415         newSignalingState = SignalingState::HaveLocalPrAnswer;
     415        newSignalingState = RTCSignalingState::HaveLocalPranswer;
    416416        break;
    417417    }
     
    419419    updateSignalingState(newSignalingState);
    420420
    421     if (m_peerConnection.internalIceGatheringState() == IceGatheringState::New && mediaDescriptions.size())
    422         m_peerConnection.updateIceGatheringState(IceGatheringState::Gathering);
     421    if (m_peerConnection.iceGatheringState() == RTCIceGatheringState::New && mediaDescriptions.size())
     422        m_peerConnection.updateIceGatheringState(RTCIceGatheringState::Gathering);
    423423
    424424    markAsNeedingNegotiation();
     
    553553        m_peerConnection.fireEvent(*event);
    554554
    555     SignalingState newSignalingState;
     555    RTCSignalingState newSignalingState;
    556556
    557557    // Update state and local descriptions according to setLocal/RemoteDescription processing model
     
    559559    case RTCSessionDescription::SdpType::Offer:
    560560        m_pendingRemoteDescription = WTFMove(newDescription);
    561         newSignalingState = SignalingState::HaveRemoteOffer;
     561        newSignalingState = RTCSignalingState::HaveRemoteOffer;
    562562        break;
    563563
     
    567567        m_pendingRemoteDescription = nullptr;
    568568        m_pendingLocalDescription = nullptr;
    569         newSignalingState = SignalingState::Stable;
     569        newSignalingState = RTCSignalingState::Stable;
    570570        break;
    571571
    572572    case RTCSessionDescription::SdpType::Rollback:
    573573        m_pendingRemoteDescription = nullptr;
    574         newSignalingState = SignalingState::Stable;
     574        newSignalingState = RTCSignalingState::Stable;
    575575        break;
    576576
    577577    case RTCSessionDescription::SdpType::Pranswer:
    578578        m_pendingRemoteDescription = WTFMove(newDescription);
    579         newSignalingState = SignalingState::HaveRemotePrAnswer;
     579        newSignalingState = RTCSignalingState::HaveRemotePranswer;
    580580        break;
    581581    }
     
    717717void MediaEndpointPeerConnection::replaceTrackTask(RTCRtpSender& sender, const String& mid, Ref<MediaStreamTrack>&& withTrack, DOMPromise<void>& promise)
    718718{
    719     if (m_peerConnection.internalSignalingState() == SignalingState::Closed)
     719    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    720720        return;
    721721
     
    796796    ASSERT(notifyingTransceiver);
    797797
    798     notifyingTransceiver->iceTransport().setGatheringState(RTCIceTransport::GatheringState::Complete);
     798    notifyingTransceiver->iceTransport().setGatheringState(RTCIceGatheringState::Complete);
    799799
    800800    // Don't notify the script if there are transceivers still gathering.
    801801    RTCRtpTransceiver* stillGatheringTransceiver = matchTransceiver(transceivers, [] (RTCRtpTransceiver& current) {
    802802        return !current.stopped() && !current.mid().isNull()
    803             && current.iceTransport().gatheringState() != RTCIceTransport::GatheringState::Complete;
     803            && current.iceTransport().gatheringState() != RTCIceGatheringState::Complete;
    804804    });
    805805    if (!stillGatheringTransceiver)
     
    807807}
    808808
    809 static RTCIceTransport::TransportState deriveAggregatedIceConnectionState(const Vector<RTCIceTransport::TransportState>& states)
     809static RTCIceTransportState deriveAggregatedIceConnectionState(const Vector<RTCIceTransportState>& states)
    810810{
    811811    unsigned newCount = 0;
     
    819819    for (auto& state : states) {
    820820        switch (state) {
    821         case RTCIceTransport::TransportState::New: ++newCount; break;
    822         case RTCIceTransport::TransportState::Checking: ++checkingCount; break;
    823         case RTCIceTransport::TransportState::Connected: ++connectedCount; break;
    824         case RTCIceTransport::TransportState::Completed: ++completedCount; break;
    825         case RTCIceTransport::TransportState::Failed: ++failedCount; break;
    826         case RTCIceTransport::TransportState::Disconnected: ++disconnectedCount; break;
    827         case RTCIceTransport::TransportState::Closed: ++closedCount; break;
     821        case RTCIceTransportState::New:
     822            ++newCount;
     823            break;
     824        case RTCIceTransportState::Checking:
     825            ++checkingCount;
     826            break;
     827        case RTCIceTransportState::Connected:
     828            ++connectedCount;
     829            break;
     830        case RTCIceTransportState::Completed:
     831            ++completedCount;
     832            break;
     833        case RTCIceTransportState::Failed:
     834            ++failedCount;
     835            break;
     836        case RTCIceTransportState::Disconnected:
     837            ++disconnectedCount;
     838            break;
     839        case RTCIceTransportState::Closed:
     840            ++closedCount;
     841            break;
    828842        }
    829843    }
     
    831845    // The aggregated RTCIceConnectionState is derived from the RTCIceTransportState of all RTCIceTransports.
    832846    if ((newCount > 0 && !checkingCount && !failedCount && !disconnectedCount) || (closedCount == states.size()))
    833         return RTCIceTransport::TransportState::New;
     847        return RTCIceTransportState::New;
    834848
    835849    if (checkingCount > 0 && !failedCount && !disconnectedCount)
    836         return RTCIceTransport::TransportState::Checking;
     850        return RTCIceTransportState::Checking;
    837851
    838852    if ((connectedCount + completedCount + closedCount) == states.size() && connectedCount > 0)
    839         return RTCIceTransport::TransportState::Connected;
     853        return RTCIceTransportState::Connected;
    840854
    841855    if ((completedCount + closedCount) == states.size() && completedCount > 0)
    842         return RTCIceTransport::TransportState::Completed;
     856        return RTCIceTransportState::Completed;
    843857
    844858    if (failedCount > 0)
    845         return RTCIceTransport::TransportState::Failed;
     859        return RTCIceTransportState::Failed;
    846860
    847861    if (disconnectedCount > 0) // Any failed caught above.
    848         return RTCIceTransport::TransportState::Disconnected;
     862        return RTCIceTransportState::Disconnected;
    849863
    850864    ASSERT_NOT_REACHED();
    851     return RTCIceTransport::TransportState::New;
    852 }
    853 
    854 void MediaEndpointPeerConnection::iceTransportStateChanged(const String& mid, MediaEndpoint::IceTransportState mediaEndpointIceTransportState)
     865    return RTCIceTransportState::New;
     866}
     867
     868void MediaEndpointPeerConnection::iceTransportStateChanged(const String& mid, RTCIceTransportState mediaEndpointIceTransportState)
    855869{
    856870    ASSERT(isMainThread());
     
    859873    ASSERT(transceiver);
    860874
    861     RTCIceTransport::TransportState transportState = static_cast<RTCIceTransport::TransportState>(mediaEndpointIceTransportState);
     875    RTCIceTransportState transportState = static_cast<RTCIceTransportState>(mediaEndpointIceTransportState);
    862876    transceiver->iceTransport().setTransportState(transportState);
    863877
    864878    // Determine if the script needs to be notified.
    865     Vector<RTCIceTransport::TransportState> transportStates;
     879    Vector<RTCIceTransportState> transportStates;
    866880    for (auto& transceiver : m_peerConnection.getTransceivers())
    867881        transportStates.append(transceiver->iceTransport().transportState());
    868882
    869     RTCIceTransport::TransportState derivedState = deriveAggregatedIceConnectionState(transportStates);
    870     m_peerConnection.updateIceConnectionState(static_cast<IceConnectionState>(derivedState));
     883    RTCIceTransportState derivedState = deriveAggregatedIceConnectionState(transportStates);
     884    m_peerConnection.updateIceConnectionState(static_cast<RTCIceConnectionState>(derivedState));
    871885}
    872886
  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.h

    r213736 r214030  
    11/*
    22 * Copyright (C) 2015, 2016 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3536#include "MediaEndpoint.h"
    3637#include "PeerConnectionBackend.h"
     38#include "RTCEnums.h"
    3739#include "RTCSessionDescription.h"
    3840#include <wtf/Function.h>
     
    98100    void gotIceCandidate(const String& mid, IceCandidate&&) final;
    99101    void doneGatheringCandidates(const String& mid) final;
    100     void iceTransportStateChanged(const String& mid, MediaEndpoint::IceTransportState) final;
     102    void iceTransportStateChanged(const String& mid, RTCIceTransportState) final;
    101103
    102104    std::unique_ptr<RTCDataChannelHandler> createDataChannelHandler(const String&, const RTCDataChannelInit&) final;
  • trunk/Source/WebCore/Modules/mediastream/PeerConnectionBackend.cpp

    r212745 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
    3  * Copyright (C) 2016 Apple INC. All rights reserved.
     3 * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
    44 *
    55 * Redistribution and use in source and binary forms, with or without
     
    4747{
    4848    ASSERT(!m_offerAnswerPromise);
    49     ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
     49    ASSERT(m_peerConnection.signalingState() != RTCSignalingState::Closed);
    5050
    5151    m_offerAnswerPromise = WTFMove(promise);
     
    5757    ASSERT(isMainThread());
    5858
    59     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     59    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    6060        return;
    6161
     
    6969    ASSERT(isMainThread());
    7070
    71     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     71    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    7272        return;
    7373
     
    8080{
    8181    ASSERT(!m_offerAnswerPromise);
    82     ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
     82    ASSERT(m_peerConnection.signalingState() != RTCSignalingState::Closed);
    8383
    8484    m_offerAnswerPromise = WTFMove(promise);
     
    9090    ASSERT(isMainThread());
    9191
    92     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     92    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    9393        return;
    9494
     
    102102    ASSERT(isMainThread());
    103103
    104     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     104    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    105105        return;
    106106
     
    110110}
    111111
    112 static inline bool isLocalDescriptionTypeValidForState(RTCSessionDescription::SdpType type, PeerConnectionStates::SignalingState state)
     112static inline bool isLocalDescriptionTypeValidForState(RTCSessionDescription::SdpType type, RTCSignalingState state)
    113113{
    114114    switch (state) {
    115     case PeerConnectionStates::SignalingState::Stable:
     115    case RTCSignalingState::Stable:
    116116        return type == RTCSessionDescription::SdpType::Offer;
    117     case PeerConnectionStates::SignalingState::HaveLocalOffer:
     117    case RTCSignalingState::HaveLocalOffer:
    118118        return type == RTCSessionDescription::SdpType::Offer;
    119     case PeerConnectionStates::SignalingState::HaveRemoteOffer:
     119    case RTCSignalingState::HaveRemoteOffer:
    120120        return type == RTCSessionDescription::SdpType::Answer || type == RTCSessionDescription::SdpType::Pranswer;
    121     case PeerConnectionStates::SignalingState::HaveLocalPrAnswer:
     121    case RTCSignalingState::HaveLocalPranswer:
    122122        return type == RTCSessionDescription::SdpType::Answer || type == RTCSessionDescription::SdpType::Pranswer;
    123123    default:
     
    131131void PeerConnectionBackend::setLocalDescription(RTCSessionDescription& sessionDescription, DOMPromise<void>&& promise)
    132132{
    133     ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
    134 
    135     if (!isLocalDescriptionTypeValidForState(sessionDescription.type(), m_peerConnection.internalSignalingState())) {
     133    ASSERT(m_peerConnection.signalingState() != RTCSignalingState::Closed);
     134
     135    if (!isLocalDescriptionTypeValidForState(sessionDescription.type(), m_peerConnection.signalingState())) {
    136136        promise.reject(INVALID_STATE_ERR, "Description type incompatible with current signaling state");
    137137        return;
     
    146146    ASSERT(isMainThread());
    147147
    148     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     148    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    149149        return;
    150150
     
    159159    ASSERT(isMainThread());
    160160
    161     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     161    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    162162        return;
    163163
     
    168168}
    169169
    170 static inline bool isRemoteDescriptionTypeValidForState(RTCSessionDescription::SdpType type, PeerConnectionStates::SignalingState state)
     170static inline bool isRemoteDescriptionTypeValidForState(RTCSessionDescription::SdpType type, RTCSignalingState state)
    171171{
    172172    switch (state) {
    173     case PeerConnectionStates::SignalingState::Stable:
     173    case RTCSignalingState::Stable:
    174174        return type == RTCSessionDescription::SdpType::Offer;
    175     case PeerConnectionStates::SignalingState::HaveLocalOffer:
     175    case RTCSignalingState::HaveLocalOffer:
    176176        return type == RTCSessionDescription::SdpType::Answer || type == RTCSessionDescription::SdpType::Pranswer;
    177     case PeerConnectionStates::SignalingState::HaveRemoteOffer:
     177    case RTCSignalingState::HaveRemoteOffer:
    178178        return type == RTCSessionDescription::SdpType::Offer;
    179     case PeerConnectionStates::SignalingState::HaveRemotePrAnswer:
     179    case RTCSignalingState::HaveRemotePranswer:
    180180        return type == RTCSessionDescription::SdpType::Answer || type == RTCSessionDescription::SdpType::Pranswer;
    181181    default:
     
    189189void PeerConnectionBackend::setRemoteDescription(RTCSessionDescription& sessionDescription, DOMPromise<void>&& promise)
    190190{
    191     ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
    192 
    193     if (!isRemoteDescriptionTypeValidForState(sessionDescription.type(), m_peerConnection.internalSignalingState())) {
     191    ASSERT(m_peerConnection.signalingState() != RTCSignalingState::Closed);
     192
     193    if (!isRemoteDescriptionTypeValidForState(sessionDescription.type(), m_peerConnection.signalingState())) {
    194194        promise.reject(INVALID_STATE_ERR, "Description type incompatible with current signaling state");
    195195        return;
     
    204204    ASSERT(isMainThread());
    205205
    206     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     206    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    207207        return;
    208208
     
    217217    ASSERT(isMainThread());
    218218
    219     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     219    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    220220        return;
    221221
     
    228228void PeerConnectionBackend::addIceCandidate(RTCIceCandidate& iceCandidate, DOMPromise<void>&& promise)
    229229{
    230     ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
     230    ASSERT(m_peerConnection.signalingState() != RTCSignalingState::Closed);
    231231
    232232    if (iceCandidate.sdpMid().isNull() && !iceCandidate.sdpMLineIndex()) {
     
    242242    ASSERT(isMainThread());
    243243
    244     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     244    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    245245        return;
    246246
     
    255255{
    256256    ASSERT(isMainThread());
    257     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Closed)
     257    if (m_peerConnection.signalingState() == RTCSignalingState::Closed)
    258258        return;
    259259
     
    333333
    334334    m_peerConnection.fireEvent(RTCIceCandidateEvent::create(false, false, nullptr));
    335     m_peerConnection.updateIceGatheringState(PeerConnectionStates::IceGatheringState::Complete);
    336 }
    337 
    338 void PeerConnectionBackend::updateSignalingState(PeerConnectionStates::SignalingState newSignalingState)
    339 {
    340     ASSERT(isMainThread());
    341 
    342     if (newSignalingState != m_peerConnection.internalSignalingState()) {
     335    m_peerConnection.updateIceGatheringState(RTCIceGatheringState::Complete);
     336}
     337
     338void PeerConnectionBackend::updateSignalingState(RTCSignalingState newSignalingState)
     339{
     340    ASSERT(isMainThread());
     341
     342    if (newSignalingState != m_peerConnection.signalingState()) {
    343343        m_peerConnection.setSignalingState(newSignalingState);
    344344        m_peerConnection.fireEvent(Event::create(eventNames().signalingstatechangeEvent, false, false));
     
    362362    m_negotiationNeeded = true;
    363363   
    364     if (m_peerConnection.internalSignalingState() == PeerConnectionStates::SignalingState::Stable)
     364    if (m_peerConnection.signalingState() == RTCSignalingState::Stable)
    365365        m_peerConnection.scheduleNegotiationNeededEvent();
    366366}
  • trunk/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h

    r213736 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3435
    3536#include "JSDOMPromise.h"
    36 #include "PeerConnectionStates.h"
     37#include "RTCEnums.h"
    3738
    3839namespace WebCore {
     
    111112    void doneGatheringCandidates();
    112113
    113     void updateSignalingState(PeerConnectionStates::SignalingState);
     114    void updateSignalingState(RTCSignalingState);
    114115
    115116    void createOfferSucceeded(String&&);
  • trunk/Source/WebCore/Modules/mediastream/RTCConfiguration.h

    r209695 r214030  
    11/*
    22 * Copyright (C) 2012 Google Inc. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3334#if ENABLE(WEB_RTC)
    3435
    35 #include "PeerConnectionStates.h"
     36#include "RTCEnums.h"
    3637#include "RTCIceServer.h"
    3738
    3839namespace WebCore {
    3940
    40 using RTCIceTransportPolicy = PeerConnectionStates::IceTransportPolicy;
    41 using RTCBundlePolicy = PeerConnectionStates::BundlePolicy;
    42 
    4341struct RTCConfiguration {
    44     using IceTransportPolicy = RTCIceTransportPolicy;
    45     using BundlePolicy = RTCBundlePolicy;
    46 
    4742    std::optional<Vector<RTCIceServer>> iceServers;
    48     IceTransportPolicy iceTransportPolicy;
    49     BundlePolicy bundlePolicy;
     43    RTCIceTransportPolicy iceTransportPolicy;
     44    RTCBundlePolicy bundlePolicy;
    5045};
    5146
  • trunk/Source/WebCore/Modules/mediastream/RTCConfiguration.idl

    r209695 r214030  
    11/*
    2  * Copyright (C) 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2014-2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2424 */
    2525
    26 enum RTCIceTransportPolicy { "relay", "all" };
    27 enum RTCBundlePolicy { "balanced", "max-compat", "max-bundle" };
     26[
     27    Conditional=WEB_RTC,
     28    EnabledAtRuntime=PeerConnection,
     29    ImplementedAs=RTCIceTransportPolicy
     30] enum RTCIceTransportPolicy {
     31    "relay",
     32    "all"
     33};
    2834
    2935[
    3036    Conditional=WEB_RTC,
     37    EnabledAtRuntime=PeerConnection,
     38    ImplementedAs=RTCBundlePolicy
     39] enum RTCBundlePolicy {
     40    "balanced",
     41    "max-compat",
     42    "max-bundle"
     43};
     44
     45[
     46    Conditional=WEB_RTC,
     47    EnabledAtRuntime=PeerConnection,
    3148    JSGenerateToJSObject,
    3249] dictionary RTCConfiguration {
     
    3451    RTCIceTransportPolicy iceTransportPolicy = "all";
    3552    RTCBundlePolicy bundlePolicy = "balanced";
     53    // FIXME 169662: missing rtcpMuxPolicy
     54    // FIXME 169662: missing peerIdentity
     55    // FIXME 169662: missing certificates
     56    // FIXME 169662: missing iceCandidatePoolSize
    3657};
  • trunk/Source/WebCore/Modules/mediastream/RTCIceTransport.h

    r206856 r214030  
    11/*
    22 * Copyright (C) 2016 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3334#if ENABLE(WEB_RTC)
    3435
    35 #include "PeerConnectionStates.h"
     36#include "RTCEnums.h"
    3637#include "ScriptWrappable.h"
    3738#include <wtf/RefCounted.h>
     
    4243class RTCIceTransport : public RefCounted<RTCIceTransport>, public ScriptWrappable {
    4344public:
    44 
    45     using TransportState = PeerConnectionStates::IceTransportState;
    46     using GatheringState = PeerConnectionStates::IceGatheringState;
    47 
    4845    static Ref<RTCIceTransport> create()
    4946    {
     
    5249    virtual ~RTCIceTransport() { }
    5350
    54     TransportState transportState() const { return m_transportState; }
    55     void setTransportState(TransportState state) { m_transportState = state; }
     51    RTCIceTransportState transportState() const { return m_transportState; }
     52    void setTransportState(RTCIceTransportState state) { m_transportState = state; }
    5653
    57     GatheringState gatheringState() const { return m_gatheringState; }
    58     void setGatheringState(GatheringState state) { m_gatheringState = state; }
     54    RTCIceGatheringState gatheringState() const { return m_gatheringState; }
     55    void setGatheringState(RTCIceGatheringState state) { m_gatheringState = state; }
    5956
    6057private:
    6158    RTCIceTransport() { };
    6259
    63     TransportState m_transportState { TransportState::New };
    64     GatheringState m_gatheringState { GatheringState::New };
     60    RTCIceTransportState m_transportState { RTCIceTransportState::New };
     61    RTCIceGatheringState m_gatheringState { RTCIceGatheringState::New };
    6562};
    6663
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r213992 r214030  
    5959
    6060using namespace PeerConnection;
    61 using namespace PeerConnectionStates;
    6261
    6362Ref<RTCPeerConnection> RTCPeerConnection::create(ScriptExecutionContext& context)
     
    6766    // RTCPeerConnection may send events at about any time during its lifetime.
    6867    // Let's make it uncollectable until the pc is closed by JS or the page stops it.
    69     if (peerConnection->m_signalingState != SignalingState::Closed) {
     68    if (peerConnection->m_signalingState != RTCSignalingState::Closed) {
    7069        peerConnection->setPendingActivity(peerConnection.ptr());
    7170        peerConnection->registerToController();
     
    9897ExceptionOr<Ref<RTCRtpSender>> RTCPeerConnection::addTrack(Ref<MediaStreamTrack>&& track, const Vector<std::reference_wrapper<MediaStream>>& streams)
    9998{
    100     if (m_signalingState == SignalingState::Closed)
     99    if (m_signalingState == RTCSignalingState::Closed)
    101100        return Exception { INVALID_STATE_ERR };
    102101
     
    154153ExceptionOr<void> RTCPeerConnection::removeTrack(RTCRtpSender& sender)
    155154{
    156     if (m_signalingState == SignalingState::Closed)
     155    if (m_signalingState == RTCSignalingState::Closed)
    157156        return Exception { INVALID_STATE_ERR };
    158157
     
    175174ExceptionOr<Ref<RTCRtpTransceiver>> RTCPeerConnection::addTransceiver(Ref<MediaStreamTrack>&& track, const RTCRtpTransceiverInit& init)
    176175{
    177     if (m_signalingState == SignalingState::Closed)
     176    if (m_signalingState == RTCSignalingState::Closed)
    178177        return Exception { INVALID_STATE_ERR };
    179178
     
    193192ExceptionOr<Ref<RTCRtpTransceiver>> RTCPeerConnection::addTransceiver(const String& kind, const RTCRtpTransceiverInit& init)
    194193{
    195     if (m_signalingState == SignalingState::Closed)
     194    if (m_signalingState == RTCSignalingState::Closed)
    196195        return Exception { INVALID_STATE_ERR };
    197196
     
    221220void RTCPeerConnection::queuedCreateOffer(RTCOfferOptions&& options, SessionDescriptionPromise&& promise)
    222221{
    223     if (m_signalingState == SignalingState::Closed) {
     222    if (m_signalingState == RTCSignalingState::Closed) {
    224223        promise.reject(INVALID_STATE_ERR);
    225224        return;
     
    231230void RTCPeerConnection::queuedCreateAnswer(RTCAnswerOptions&& options, SessionDescriptionPromise&& promise)
    232231{
    233     if (m_signalingState == SignalingState::Closed) {
     232    if (m_signalingState == RTCSignalingState::Closed) {
    234233        promise.reject(INVALID_STATE_ERR);
    235234        return;
     
    241240void RTCPeerConnection::queuedSetLocalDescription(RTCSessionDescription& description, DOMPromise<void>&& promise)
    242241{
    243     if (m_signalingState == SignalingState::Closed) {
     242    if (m_signalingState == RTCSignalingState::Closed) {
    244243        promise.reject(INVALID_STATE_ERR);
    245244        return;
     
    266265void RTCPeerConnection::queuedSetRemoteDescription(RTCSessionDescription& description, DOMPromise<void>&& promise)
    267266{
    268     if (m_signalingState == SignalingState::Closed) {
     267    if (m_signalingState == RTCSignalingState::Closed) {
    269268        promise.reject(INVALID_STATE_ERR);
    270269        return;
     
    291290void RTCPeerConnection::queuedAddIceCandidate(RTCIceCandidate& rtcCandidate, DOMPromise<void>&& promise)
    292291{
    293     if (m_signalingState == SignalingState::Closed) {
     292    if (m_signalingState == RTCSignalingState::Closed) {
    294293        promise.reject(INVALID_STATE_ERR);
    295294        return;
     
    299298}
    300299
    301 String RTCPeerConnection::signalingState() const
    302 {
    303     switch (m_signalingState) {
    304     case SignalingState::Stable:
    305         return ASCIILiteral("stable");
    306     case SignalingState::HaveLocalOffer:
    307         return ASCIILiteral("have-local-offer");
    308     case SignalingState::HaveRemoteOffer:
    309         return ASCIILiteral("have-remote-offer");
    310     case SignalingState::HaveLocalPrAnswer:
    311         return ASCIILiteral("have-local-pranswer");
    312     case SignalingState::HaveRemotePrAnswer:
    313         return ASCIILiteral("have-remote-pranswer");
    314     case SignalingState::Closed:
    315         return ASCIILiteral("closed");
    316     }
    317 
    318     ASSERT_NOT_REACHED();
    319     return String();
    320 }
    321 
    322 String RTCPeerConnection::iceGatheringState() const
    323 {
    324     switch (m_iceGatheringState) {
    325     case IceGatheringState::New:
    326         return ASCIILiteral("new");
    327     case IceGatheringState::Gathering:
    328         return ASCIILiteral("gathering");
    329     case IceGatheringState::Complete:
    330         return ASCIILiteral("complete");
    331     }
    332 
    333     ASSERT_NOT_REACHED();
    334     return String();
    335 }
    336 
    337 String RTCPeerConnection::iceConnectionState() const
    338 {
    339     switch (m_iceConnectionState) {
    340     case IceConnectionState::New:
    341         return ASCIILiteral("new");
    342     case IceConnectionState::Checking:
    343         return ASCIILiteral("checking");
    344     case IceConnectionState::Connected:
    345         return ASCIILiteral("connected");
    346     case IceConnectionState::Completed:
    347         return ASCIILiteral("completed");
    348     case IceConnectionState::Failed:
    349         return ASCIILiteral("failed");
    350     case IceConnectionState::Disconnected:
    351         return ASCIILiteral("disconnected");
    352     case IceConnectionState::Closed:
    353         return ASCIILiteral("closed");
    354     }
    355 
    356     ASSERT_NOT_REACHED();
    357     return String();
    358 }
    359 
    360300ExceptionOr<void> RTCPeerConnection::setConfiguration(RTCConfiguration&& configuration)
    361301{
    362     if (m_signalingState == SignalingState::Closed)
     302    if (m_signalingState == RTCSignalingState::Closed)
    363303        return Exception { INVALID_STATE_ERR };
    364304
     
    399339ExceptionOr<Ref<RTCDataChannel>> RTCPeerConnection::createDataChannel(ScriptExecutionContext& context, String&& label, RTCDataChannelInit&& options)
    400340{
    401     if (m_signalingState == SignalingState::Closed)
     341    if (m_signalingState == RTCSignalingState::Closed)
    402342        return Exception { INVALID_STATE_ERR };
    403343
     
    412352void RTCPeerConnection::close()
    413353{
    414     if (m_signalingState == SignalingState::Closed)
     354    if (m_signalingState == RTCSignalingState::Closed)
    415355        return;
    416356
    417357    m_backend->stop();
    418358
    419     m_iceConnectionState = IceConnectionState::Closed;
    420     m_signalingState = SignalingState::Closed;
     359    m_iceConnectionState = RTCIceConnectionState::Closed;
     360    m_signalingState = RTCSignalingState::Closed;
    421361
    422362    for (RTCRtpSender& sender : m_transceiverSet->senders())
     
    471411}
    472412
    473 void RTCPeerConnection::setSignalingState(SignalingState newState)
     413void RTCPeerConnection::setSignalingState(RTCSignalingState newState)
    474414{
    475415    m_signalingState = newState;
    476416}
    477417
    478 void RTCPeerConnection::updateIceGatheringState(IceGatheringState newState)
     418void RTCPeerConnection::updateIceGatheringState(RTCIceGatheringState newState)
    479419{
    480420    scriptExecutionContext()->postTask([protectedThis = makeRef(*this), newState](ScriptExecutionContext&) {
    481         if (protectedThis->m_signalingState == SignalingState::Closed || protectedThis->m_iceGatheringState == newState)
     421        if (protectedThis->m_signalingState == RTCSignalingState::Closed || protectedThis->m_iceGatheringState == newState)
    482422            return;
    483423
     
    487427}
    488428
    489 void RTCPeerConnection::updateIceConnectionState(IceConnectionState newState)
     429void RTCPeerConnection::updateIceConnectionState(RTCIceConnectionState newState)
    490430{
    491431    scriptExecutionContext()->postTask([protectedThis = makeRef(*this), newState](ScriptExecutionContext&) {
    492         if (protectedThis->m_signalingState == SignalingState::Closed || protectedThis->m_iceConnectionState == newState)
     432        if (protectedThis->m_signalingState == RTCSignalingState::Closed || protectedThis->m_iceConnectionState == newState)
    493433            return;
    494434
     
    501441{
    502442    scriptExecutionContext()->postTask([protectedThis = makeRef(*this)](ScriptExecutionContext&) {
    503         if (protectedThis->m_signalingState == SignalingState::Closed)
     443        if (protectedThis->m_signalingState == RTCSignalingState::Closed)
    504444            return;
    505445        if (!protectedThis->m_backend->isNegotiationNeeded())
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

    r213992 r214030  
    3939#include "EventTarget.h"
    4040#include "MediaStream.h"
    41 #include "RTCAnswerOptions.h"
    4241#include "RTCConfiguration.h"
    4342#include "RTCDataChannel.h"
    4443#include "RTCEnums.h"
    45 #include "RTCOfferOptions.h"
    4644#include "RTCRtpTransceiver.h"
    4745
     
    5654class RTCStatsCallback;
    5755
     56struct RTCAnswerOptions;
     57struct RTCOfferOptions;
    5858struct RTCRtpTransceiverInit {
    5959    RTCRtpTransceiverDirection direction;
     
    6565    virtual ~RTCPeerConnection();
    6666
    67     using AnswerOptions = RTCAnswerOptions;
    6867    using DataChannelInit = RTCDataChannelInit;
    69     using OfferAnswerOptions = RTCOfferAnswerOptions;
    70     using OfferOptions = RTCOfferOptions;
    7168
    7269    ExceptionOr<void> initializeWith(Document&, RTCConfiguration&&);
     
    9895    RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
    9996
    100     String signalingState() const;
     97    RTCSignalingState signalingState() const { return m_signalingState; }
    10198
    10299    void queuedAddIceCandidate(RTCIceCandidate&, DOMPromise<void>&&);
    103100
    104     String iceGatheringState() const;
    105     String iceConnectionState() const;
     101    RTCIceGatheringState iceGatheringState() const { return m_iceGatheringState; }
     102    RTCIceConnectionState iceConnectionState() const { return m_iceConnectionState; }
    106103
    107104    const RTCConfiguration& getConfiguration() const { return m_configuration; }
     
    126123    // API used by PeerConnectionBackend and relatives
    127124    void addTransceiver(Ref<RTCRtpTransceiver>&&);
    128     void setSignalingState(PeerConnectionStates::SignalingState);
    129     void updateIceGatheringState(PeerConnectionStates::IceGatheringState);
    130     void updateIceConnectionState(PeerConnectionStates::IceConnectionState);
     125    void setSignalingState(RTCSignalingState);
     126    void updateIceGatheringState(RTCIceGatheringState);
     127    void updateIceConnectionState(RTCIceConnectionState);
    131128
    132129    void scheduleNegotiationNeededEvent();
     
    134131    RTCRtpSenderClient& senderClient() { return *this; }
    135132    void fireEvent(Event&);
    136     PeerConnectionStates::SignalingState internalSignalingState() const { return m_signalingState; }
    137     PeerConnectionStates::IceGatheringState internalIceGatheringState() const { return m_iceGatheringState; }
    138     PeerConnectionStates::IceConnectionState internalIceConnectionState() const { return m_iceConnectionState; }
    139133
    140134    void disableICECandidateFiltering() { m_backend->disableICECandidateFiltering(); }
     
    162156    void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) final;
    163157
    164     PeerConnectionStates::SignalingState m_signalingState { PeerConnectionStates::SignalingState::Stable };
    165     PeerConnectionStates::IceGatheringState m_iceGatheringState { PeerConnectionStates::IceGatheringState::New };
    166     PeerConnectionStates::IceConnectionState m_iceConnectionState { PeerConnectionStates::IceConnectionState::New };
     158    RTCSignalingState m_signalingState { RTCSignalingState::Stable };
     159    RTCIceGatheringState m_iceGatheringState { RTCIceGatheringState::New };
     160    RTCIceConnectionState m_iceConnectionState { RTCIceConnectionState::New };
    167161
    168162    std::unique_ptr<RtpTransceiverSet> m_transceiverSet { std::unique_ptr<RtpTransceiverSet>(new RtpTransceiverSet()) };
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl

    r213992 r214030  
    9393    [JSBuiltin] Promise<void> addIceCandidate(RTCIceCandidate candidate);
    9494
    95     // FIXME 169644: convert to enum
    96     readonly attribute DOMString signalingState;
    97     // FIXME 169644: convert to enum
    98     readonly attribute DOMString iceGatheringState;
    99     // FIXME 169644: convert to enum
    100     readonly attribute DOMString iceConnectionState;
     95    readonly attribute RTCSignalingState signalingState;
     96    readonly attribute RTCIceGatheringState iceGatheringState;
     97    readonly attribute RTCIceConnectionState iceConnectionState;
    10198
    10299    // FIXME 169644: missing connectionState
  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp

    r213884 r214030  
    11/*
    2  * Copyright (C) 2017 Apple Inc.
     2 * Copyright (C) 2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    3939#include "RTCDataChannel.h"
    4040#include "RTCDataChannelEvent.h"
     41#include "RTCEnums.h"
    4142#include "RTCPeerConnection.h"
    4243#include "RTCSessionDescription.h"
     
    349350}
    350351
    351 static PeerConnectionStates::SignalingState signalingState(webrtc::PeerConnectionInterface::SignalingState state)
     352static RTCSignalingState signalingState(webrtc::PeerConnectionInterface::SignalingState state)
    352353{
    353354    switch (state) {
    354355    case webrtc::PeerConnectionInterface::kStable:
    355         return PeerConnectionStates::SignalingState::Stable;
     356        return RTCSignalingState::Stable;
    356357    case webrtc::PeerConnectionInterface::kHaveLocalOffer:
    357         return PeerConnectionStates::SignalingState::HaveLocalOffer;
     358        return RTCSignalingState::HaveLocalOffer;
    358359    case webrtc::PeerConnectionInterface::kHaveLocalPrAnswer:
    359         return PeerConnectionStates::SignalingState::HaveLocalPrAnswer;
     360        return RTCSignalingState::HaveLocalPranswer;
    360361    case webrtc::PeerConnectionInterface::kHaveRemoteOffer:
    361         return PeerConnectionStates::SignalingState::HaveRemoteOffer;
     362        return RTCSignalingState::HaveRemoteOffer;
    362363    case webrtc::PeerConnectionInterface::kHaveRemotePrAnswer:
    363         return PeerConnectionStates::SignalingState::HaveRemotePrAnswer;
     364        return RTCSignalingState::HaveRemotePranswer;
    364365    case webrtc::PeerConnectionInterface::kClosed:
    365         return PeerConnectionStates::SignalingState::Closed;
     366        return RTCSignalingState::Closed;
    366367    }
    367368}
     
    496497}
    497498
    498 static inline PeerConnectionStates::IceConnectionState iceConnectionState(webrtc::PeerConnectionInterface::IceConnectionState state)
     499static inline RTCIceConnectionState toRTCIceConnectionState(webrtc::PeerConnectionInterface::IceConnectionState state)
    499500{
    500501    switch (state) {
    501502    case webrtc::PeerConnectionInterface::kIceConnectionNew:
    502         return PeerConnectionStates::IceConnectionState::New;
     503        return RTCIceConnectionState::New;
    503504    case webrtc::PeerConnectionInterface::kIceConnectionChecking:
    504         return PeerConnectionStates::IceConnectionState::Checking;
     505        return RTCIceConnectionState::Checking;
    505506    case webrtc::PeerConnectionInterface::kIceConnectionConnected:
    506         return PeerConnectionStates::IceConnectionState::Connected;
     507        return RTCIceConnectionState::Connected;
    507508    case webrtc::PeerConnectionInterface::kIceConnectionCompleted:
    508         return PeerConnectionStates::IceConnectionState::Completed;
     509        return RTCIceConnectionState::Completed;
    509510    case webrtc::PeerConnectionInterface::kIceConnectionFailed:
    510         return PeerConnectionStates::IceConnectionState::Failed;
     511        return RTCIceConnectionState::Failed;
    511512    case webrtc::PeerConnectionInterface::kIceConnectionDisconnected:
    512         return PeerConnectionStates::IceConnectionState::Disconnected;
     513        return RTCIceConnectionState::Disconnected;
    513514    case webrtc::PeerConnectionInterface::kIceConnectionClosed:
    514         return PeerConnectionStates::IceConnectionState::Closed;
     515        return RTCIceConnectionState::Closed;
    515516    case webrtc::PeerConnectionInterface::kIceConnectionMax:
    516517        ASSERT_NOT_REACHED();
    517         return PeerConnectionStates::IceConnectionState::New;
     518        return RTCIceConnectionState::New;
    518519    }
    519520}
     
    521522void LibWebRTCMediaEndpoint::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState state)
    522523{
    523     auto connectionState = iceConnectionState(state);
     524    auto connectionState = toRTCIceConnectionState(state);
    524525    callOnMainThread([protectedThis = makeRef(*this), connectionState] {
    525526        if (protectedThis->isStopped())
    526527            return;
    527         if (protectedThis->m_peerConnectionBackend.connection().internalIceConnectionState() != connectionState)
     528        if (protectedThis->m_peerConnectionBackend.connection().iceConnectionState() != connectionState)
    528529            protectedThis->m_peerConnectionBackend.connection().updateIceConnectionState(connectionState);
    529530    });
  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp

    r213736 r214030  
    7474    webrtc::PeerConnectionInterface::RTCConfiguration rtcConfiguration;
    7575
    76     if (configuration.iceTransportPolicy == PeerConnectionStates::IceTransportPolicy::Relay)
     76    if (configuration.iceTransportPolicy == RTCIceTransportPolicy::Relay)
    7777        rtcConfiguration.type = webrtc::PeerConnectionInterface::kRelay;
    7878
     
    8181    // See https://bugs.webkit.org/show_bug.cgi?id=169389.
    8282
    83     if (configuration.bundlePolicy == PeerConnectionStates::BundlePolicy::MaxCompat)
     83    if (configuration.bundlePolicy == RTCBundlePolicy::MaxCompat)
    8484        rtcConfiguration.bundle_policy = webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
    8585
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r214027 r214030  
    14271427                316DCB311E78FB6C001B5F87 /* JSRTCAnswerOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316DCB2D1E78F496001B5F87 /* JSRTCAnswerOptions.cpp */; };
    14281428                316DCB321E78FB70001B5F87 /* JSRTCOfferOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316DCB2F1E78F496001B5F87 /* JSRTCOfferOptions.cpp */; };
     1429                316DCB371E790E1B001B5F87 /* RTCIceGatheringState.h in Headers */ = {isa = PBXBuildFile; fileRef = 316DCB341E790E1B001B5F87 /* RTCIceGatheringState.h */; };
     1430                316DCB3D1E790E2C001B5F87 /* RTCIceConnectionState.h in Headers */ = {isa = PBXBuildFile; fileRef = 316DCB3A1E790E2C001B5F87 /* RTCIceConnectionState.h */; };
     1431                316DCB431E790E3C001B5F87 /* RTCSignalingState.h in Headers */ = {isa = PBXBuildFile; fileRef = 316DCB401E790E3C001B5F87 /* RTCSignalingState.h */; };
     1432                316DCB4B1E7910A6001B5F87 /* JSRTCIceConnectionState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316DCB451E7910A6001B5F87 /* JSRTCIceConnectionState.cpp */; };
     1433                316DCB4C1E7910A6001B5F87 /* JSRTCIceConnectionState.h in Headers */ = {isa = PBXBuildFile; fileRef = 316DCB461E7910A6001B5F87 /* JSRTCIceConnectionState.h */; };
     1434                316DCB4D1E7910A6001B5F87 /* JSRTCIceGatheringState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316DCB471E7910A6001B5F87 /* JSRTCIceGatheringState.cpp */; };
     1435                316DCB4E1E7910A6001B5F87 /* JSRTCIceGatheringState.h in Headers */ = {isa = PBXBuildFile; fileRef = 316DCB481E7910A6001B5F87 /* JSRTCIceGatheringState.h */; };
     1436                316DCB4F1E7910A6001B5F87 /* JSRTCSignalingState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316DCB491E7910A6001B5F87 /* JSRTCSignalingState.cpp */; };
     1437                316DCB501E7910A6001B5F87 /* JSRTCSignalingState.h in Headers */ = {isa = PBXBuildFile; fileRef = 316DCB4A1E7910A6001B5F87 /* JSRTCSignalingState.h */; };
    14291438                316FE0710E6CCBEE00BF6088 /* JSCSSKeyframeRule.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316FE06D0E6CCBEE00BF6088 /* JSCSSKeyframeRule.cpp */; };
    14301439                316FE0720E6CCBEE00BF6088 /* JSCSSKeyframeRule.h in Headers */ = {isa = PBXBuildFile; fileRef = 316FE06E0E6CCBEE00BF6088 /* JSCSSKeyframeRule.h */; };
     
    89198928                316DCB2F1E78F496001B5F87 /* JSRTCOfferOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRTCOfferOptions.cpp; sourceTree = "<group>"; };
    89208929                316DCB301E78F496001B5F87 /* JSRTCOfferOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSRTCOfferOptions.h; sourceTree = "<group>"; };
     8930                316DCB341E790E1B001B5F87 /* RTCIceGatheringState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCIceGatheringState.h; sourceTree = "<group>"; };
     8931                316DCB351E790E1B001B5F87 /* RTCIceGatheringState.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RTCIceGatheringState.idl; sourceTree = "<group>"; };
     8932                316DCB3A1E790E2C001B5F87 /* RTCIceConnectionState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCIceConnectionState.h; sourceTree = "<group>"; };
     8933                316DCB3B1E790E2C001B5F87 /* RTCIceConnectionState.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RTCIceConnectionState.idl; sourceTree = "<group>"; };
     8934                316DCB401E790E3C001B5F87 /* RTCSignalingState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCSignalingState.h; sourceTree = "<group>"; };
     8935                316DCB411E790E3C001B5F87 /* RTCSignalingState.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RTCSignalingState.idl; sourceTree = "<group>"; };
     8936                316DCB451E7910A6001B5F87 /* JSRTCIceConnectionState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRTCIceConnectionState.cpp; sourceTree = "<group>"; };
     8937                316DCB461E7910A6001B5F87 /* JSRTCIceConnectionState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSRTCIceConnectionState.h; sourceTree = "<group>"; };
     8938                316DCB471E7910A6001B5F87 /* JSRTCIceGatheringState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRTCIceGatheringState.cpp; sourceTree = "<group>"; };
     8939                316DCB481E7910A6001B5F87 /* JSRTCIceGatheringState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSRTCIceGatheringState.h; sourceTree = "<group>"; };
     8940                316DCB491E7910A6001B5F87 /* JSRTCSignalingState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRTCSignalingState.cpp; sourceTree = "<group>"; };
     8941                316DCB4A1E7910A6001B5F87 /* JSRTCSignalingState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSRTCSignalingState.h; sourceTree = "<group>"; };
    89218942                316FE06D0E6CCBEE00BF6088 /* JSCSSKeyframeRule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCSSKeyframeRule.cpp; sourceTree = "<group>"; };
    89228943                316FE06E0E6CCBEE00BF6088 /* JSCSSKeyframeRule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCSSKeyframeRule.h; sourceTree = "<group>"; };
     
    1588515906                                07221B7517CEC32700848E51 /* RTCIceCandidateEvent.h */,
    1588615907                                07221B7617CEC32700848E51 /* RTCIceCandidateEvent.idl */,
     15908                                316DCB3A1E790E2C001B5F87 /* RTCIceConnectionState.h */,
     15909                                316DCB3B1E790E2C001B5F87 /* RTCIceConnectionState.idl */,
     15910                                316DCB341E790E1B001B5F87 /* RTCIceGatheringState.h */,
     15911                                316DCB351E790E1B001B5F87 /* RTCIceGatheringState.idl */,
    1588715912                                07AB996718DA3C010018771E /* RTCIceServer.h */,
    1588815913                                07AB996818DA3C010018771E /* RTCIceServer.idl */,
     
    1591215937                                07221B7B17CEC32700848E51 /* RTCSessionDescription.h */,
    1591315938                                07221B7C17CEC32700848E51 /* RTCSessionDescription.idl */,
     15939                                316DCB401E790E3C001B5F87 /* RTCSignalingState.h */,
     15940                                316DCB411E790E3C001B5F87 /* RTCSignalingState.idl */,
    1591415941                                07221B8417CEC32700848E51 /* RTCStatsReport.h */,
    1591515942                                07221B8517CEC32700848E51 /* RTCStatsReport.idl */,
     
    1610716134                                07969D9D17D14151007FF842 /* JSRTCIceCandidateEvent.cpp */,
    1610816135                                07969D9E17D14151007FF842 /* JSRTCIceCandidateEvent.h */,
     16136                                316DCB451E7910A6001B5F87 /* JSRTCIceConnectionState.cpp */,
     16137                                316DCB461E7910A6001B5F87 /* JSRTCIceConnectionState.h */,
     16138                                316DCB471E7910A6001B5F87 /* JSRTCIceGatheringState.cpp */,
     16139                                316DCB481E7910A6001B5F87 /* JSRTCIceGatheringState.h */,
    1610916140                                073794E919EE341E00E5A045 /* JSRTCIceServer.cpp */,
    1611016141                                073794EA19EE341E00E5A045 /* JSRTCIceServer.h */,
     
    1612516156                                07969DA117D14151007FF842 /* JSRTCSessionDescription.cpp */,
    1612616157                                07969DA217D14151007FF842 /* JSRTCSessionDescription.h */,
     16158                                316DCB491E7910A6001B5F87 /* JSRTCSignalingState.cpp */,
     16159                                316DCB4A1E7910A6001B5F87 /* JSRTCSignalingState.h */,
    1612716160                                07969DA717D14151007FF842 /* JSRTCStatsReport.cpp */,
    1612816161                                07969DA817D14151007FF842 /* JSRTCStatsReport.h */,
     
    2612226155                                512DD8F60D91E6AF000F89EE /* Archive.h in Headers */,
    2612326156                                512DD8FD0D91E6AF000F89EE /* ArchiveFactory.h in Headers */,
     26157                                316DCB4E1E7910A6001B5F87 /* JSRTCIceGatheringState.h in Headers */,
    2612426158                                512DD8FC0D91E6AF000F89EE /* ArchiveResource.h in Headers */,
    2612526159                                512DD8F80D91E6AF000F89EE /* ArchiveResourceCollection.h in Headers */,
     
    2719427228                                5185FCA91BB4C4E80012898F /* IDBRequest.h in Headers */,
    2719527229                                514129991C6976900059E714 /* IDBRequestCompletionEvent.h in Headers */,
     27230                                316DCB3D1E790E2C001B5F87 /* RTCIceConnectionState.h in Headers */,
    2719627231                                510A58FA1BACC7F200C19282 /* IDBRequestData.h in Headers */,
    2719727232                                5145B10A1BC48E2E00E86219 /* IDBResourceIdentifier.h in Headers */,
     
    2773427769                                E44613EE0CD681BB00FADA75 /* JSProgressEvent.h in Headers */,
    2773527770                                077664FD183E6B5C00133B92 /* JSQuickTimePluginReplacement.h in Headers */,
     27771                                316DCB371E790E1B001B5F87 /* RTCIceGatheringState.h in Headers */,
    2773627772                                B658FFA21522EF3A00DD5595 /* JSRadioNodeList.h in Headers */,
    2773727773                                65DF320209D1CC60000BE325 /* JSRange.h in Headers */,
     
    2804328079                                517A63C51B74318F00E7DCDC /* KeyedDecoderCF.h in Headers */,
    2804428080                                517A63C61B74319200E7DCDC /* KeyedEncoderCF.h in Headers */,
     28081                                316DCB4C1E7910A6001B5F87 /* JSRTCIceConnectionState.h in Headers */,
    2804528082                                A513B3D7114B1666001C429B /* KeyEventCocoa.h in Headers */,
    2804628083                                265541391489811C000DFC5D /* KeyEventCodesIOS.h in Headers */,
     
    2870828745                                436708D712D9CA4B00044234 /* RenderSVGResourceGradient.h in Headers */,
    2870928746                                436708D912D9CA4B00044234 /* RenderSVGResourceLinearGradient.h in Headers */,
     28747                                316DCB431E790E3C001B5F87 /* RTCSignalingState.h in Headers */,
    2871028748                                436708DB12D9CA4B00044234 /* RenderSVGResourceMarker.h in Headers */,
    2871128749                                436708DD12D9CA4B00044234 /* RenderSVGResourceMasker.h in Headers */,
     
    2928829326                                081DD49C13BA1A6000DC7627 /* SVGPropertyInfo.h in Headers */,
    2928929327                                088A0E0B126EF1DB00978F7A /* SVGPropertyTearOff.h in Headers */,
     29328                                316DCB501E7910A6001B5F87 /* JSRTCSignalingState.h in Headers */,
    2929029329                                088A0E0C126EF1DB00978F7A /* SVGPropertyTraits.h in Headers */,
    2929129330                                B2227A9A0D00BF220071B782 /* SVGRadialGradientElement.h in Headers */,
     
    3095130990                                E112F4711E3A861200D6CDFD /* Grid.cpp in Sources */,
    3095230991                                CDF7483E18FEBCEC0006ECC0 /* GridPositionsResolver.cpp in Sources */,
     30992                                316DCB4B1E7910A6001B5F87 /* JSRTCIceConnectionState.cpp in Sources */,
    3095330993                                E12DE7171E4B749C00F9ACCF /* GridTrackSizingAlgorithm.cpp in Sources */,
    3095430994                                F55B3DBF1251F12D003EF269 /* HiddenInputType.cpp in Sources */,
     
    3098631026                                A8EA79F90A1916DF00A8EF5F /* HTMLDirectoryElement.cpp in Sources */,
    3098731027                                A8EA7CB10A192B9C00A8EF5F /* HTMLDivElement.cpp in Sources */,
     31028                                316DCB4F1E7910A6001B5F87 /* JSRTCSignalingState.cpp in Sources */,
    3098831029                                A8EA79F50A1916DF00A8EF5F /* HTMLDListElement.cpp in Sources */,
    3098931030                                93F19A9108245E59001E9ABC /* HTMLDocument.cpp in Sources */,
     
    3132831369                                BC46C2020C0DDC8F0020CFC3 /* JSCSSPageRule.cpp in Sources */,
    3132931370                                14CF7B3309F6ECD700EB3665 /* JSCSSRule.cpp in Sources */,
     31371                                316DCB4D1E7910A6001B5F87 /* JSRTCIceGatheringState.cpp in Sources */,
    3133031372                                BC46C1EE0C0DDBDF0020CFC3 /* JSCSSRuleCustom.cpp in Sources */,
    3133131373                                A8D05FA70A23B301005E7203 /* JSCSSRuleList.cpp in Sources */,
  • trunk/Source/WebCore/platform/mediastream/MediaEndpoint.h

    r212329 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    6768    };
    6869
    69     using IceTransportState = PeerConnectionStates::IceTransportState;
    70 
    7170    virtual void setConfiguration(MediaEndpointConfiguration&&) = 0;
    7271
     
    9998    virtual void gotIceCandidate(const String& mid, IceCandidate&&) = 0;
    10099    virtual void doneGatheringCandidates(const String& mid) = 0;
    101     virtual void iceTransportStateChanged(const String& mid, MediaEndpoint::IceTransportState) = 0;
     100    virtual void iceTransportStateChanged(const String& mid, RTCIceTransportState) = 0;
    102101
    103102    virtual ~MediaEndpointClient() { }
  • trunk/Source/WebCore/platform/mediastream/MediaEndpointConfiguration.cpp

    r207818 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3637namespace WebCore {
    3738
    38 MediaEndpointConfiguration::MediaEndpointConfiguration(Vector<IceServerInfo>&& iceServers, IceTransportPolicy iceTransportPolicy, BundlePolicy bundlePolicy)
     39MediaEndpointConfiguration::MediaEndpointConfiguration(Vector<IceServerInfo>&& iceServers, RTCIceTransportPolicy iceTransportPolicy, RTCBundlePolicy bundlePolicy)
    3940    : iceServers(WTFMove(iceServers))
    4041    , iceTransportPolicy(iceTransportPolicy)
  • trunk/Source/WebCore/platform/mediastream/MediaEndpointConfiguration.h

    r207818 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3334#if ENABLE(WEB_RTC)
    3435
    35 #include "PeerConnectionStates.h"
     36#include "RTCEnums.h"
    3637#include "URL.h"
    3738#include <wtf/Vector.h>
     
    5051    };
    5152
    52     using IceTransportPolicy = PeerConnectionStates::IceTransportPolicy;
    53     using BundlePolicy = PeerConnectionStates::BundlePolicy;
    54 
    55     MediaEndpointConfiguration(Vector<IceServerInfo>&&, IceTransportPolicy, BundlePolicy);
     53    MediaEndpointConfiguration(Vector<IceServerInfo>&&, RTCIceTransportPolicy, RTCBundlePolicy);
    5654
    5755    Vector<IceServerInfo> iceServers;
    58     IceTransportPolicy iceTransportPolicy;
    59     BundlePolicy bundlePolicy;
     56    RTCIceTransportPolicy iceTransportPolicy;
     57    RTCBundlePolicy bundlePolicy;
    6058};
    6159
  • trunk/Source/WebCore/platform/mediastream/PeerConnectionStates.h

    r206856 r214030  
    11/*
    22 * Copyright (C) 2015, 2016 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3536namespace WebCore {
    3637
    37 namespace PeerConnectionStates {
    38 
    39 enum class SignalingState {
    40     Stable = 1,
    41     HaveLocalOffer = 2,
    42     HaveRemoteOffer = 3,
    43     HaveLocalPrAnswer = 4,
    44     HaveRemotePrAnswer = 5,
    45     Closed = 6
     38enum class RTCSignalingState {
     39    Stable,
     40    HaveLocalOffer,
     41    HaveRemoteOffer,
     42    HaveLocalPranswer,
     43    HaveRemotePranswer,
     44    Closed
    4645};
    4746
    48 enum class IceConnectionState {
    49     New = 1,
    50     Checking = 2,
    51     Connected = 3,
    52     Completed = 4,
    53     Failed = 5,
    54     Disconnected = 6,
    55     Closed = 7
     47enum class RTCIceConnectionState {
     48    New,
     49    Checking,
     50    Connected,
     51    Completed,
     52    Failed,
     53    Disconnected,
     54    Closed
    5655};
    5756
    58 enum class IceGatheringState {
    59     New = 1,
    60     Gathering = 2,
    61     Complete = 3
     57enum class RTCIceGatheringState {
     58    New,
     59    Gathering,
     60    Complete
    6261};
    6362
    64 enum class IceTransportState {
    65     New = 1,
    66     Checking = 2,
    67     Connected = 3,
    68     Completed = 4,
    69     Failed = 5,
    70     Disconnected = 6,
    71     Closed = 7
     63enum class RTCIceTransportState {
     64    New,
     65    Checking,
     66    Connected,
     67    Completed,
     68    Failed,
     69    Disconnected,
     70    Closed
    7271};
    7372
    74 enum class IceTransportPolicy {
     73enum class RTCIceTransportPolicy {
    7574    Relay,
    7675    All
    7776};
    7877
    79 enum class BundlePolicy {
     78enum class RTCBundlePolicy {
    8079    Balanced,
    8180    MaxCompat,
    8281    MaxBundle
    8382};
     83
     84
     85// FIXME: Remove once older code is upgraded
     86namespace PeerConnectionStates {
     87
     88using SignalingState = RTCSignalingState;
     89using IceConnectionState = RTCIceConnectionState;
     90using IceGatheringState = RTCIceGatheringState;
     91using IceTransportState = RTCIceTransportState;
     92using IceTransportPolicy = RTCIceTransportPolicy;
     93using BundlePolicy = RTCBundlePolicy;
    8494
    8595}
  • trunk/Source/WebCore/platform/mediastream/openwebrtc/MediaEndpointOwr.cpp

    r213884 r214030  
    446446        return;
    447447
    448     MediaEndpoint::IceTransportState transportState;
     448    RTCIceTransportState transportState;
    449449    switch (owrIceState) {
    450450    case OWR_ICE_STATE_CONNECTING:
    451         transportState = MediaEndpoint::IceTransportState::Checking;
     451        transportState = RTCIceTransportState::Checking;
    452452        break;
    453453    case OWR_ICE_STATE_CONNECTED:
    454         transportState = MediaEndpoint::IceTransportState::Connected;
     454        transportState = RTCIceTransportState::Connected;
    455455        break;
    456456    case OWR_ICE_STATE_READY:
    457         transportState = MediaEndpoint::IceTransportState::Completed;
     457        transportState = RTCIceTransportState::Completed;
    458458        break;
    459459    case OWR_ICE_STATE_FAILED:
    460         transportState = MediaEndpoint::IceTransportState::Failed;
     460        transportState = RTCIceTransportState::Failed;
    461461        break;
    462462    default:
  • trunk/Source/WebCore/platform/mock/MockMediaEndpoint.cpp

    r213884 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    278279    // Should go to:
    279280    // 'checking'
    280     m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Checking));
    281     m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Checking));
    282     m_iceTransportStateChanges.append(std::make_pair(m_mids[2], MediaEndpoint::IceTransportState::Checking));
     281    m_iceTransportStateChanges.append(std::make_pair(m_mids[0], RTCIceTransportState::Checking));
     282    m_iceTransportStateChanges.append(std::make_pair(m_mids[1], RTCIceTransportState::Checking));
     283    m_iceTransportStateChanges.append(std::make_pair(m_mids[2], RTCIceTransportState::Checking));
    283284
    284285    // 'connected'
    285     m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Connected));
    286     m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Completed));
    287     m_iceTransportStateChanges.append(std::make_pair(m_mids[2], MediaEndpoint::IceTransportState::Closed));
     286    m_iceTransportStateChanges.append(std::make_pair(m_mids[0], RTCIceTransportState::Connected));
     287    m_iceTransportStateChanges.append(std::make_pair(m_mids[1], RTCIceTransportState::Completed));
     288    m_iceTransportStateChanges.append(std::make_pair(m_mids[2], RTCIceTransportState::Closed));
    288289
    289290    // 'completed'
    290     m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Completed));
     291    m_iceTransportStateChanges.append(std::make_pair(m_mids[0], RTCIceTransportState::Completed));
    291292
    292293    // 'failed'
    293     m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Failed));
     294    m_iceTransportStateChanges.append(std::make_pair(m_mids[0], RTCIceTransportState::Failed));
    294295
    295296    // 'disconnected'
    296     m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Disconnected));
    297     m_iceTransportStateChanges.append(std::make_pair(m_mids[0], MediaEndpoint::IceTransportState::Closed));
     297    m_iceTransportStateChanges.append(std::make_pair(m_mids[1], RTCIceTransportState::Disconnected));
     298    m_iceTransportStateChanges.append(std::make_pair(m_mids[0], RTCIceTransportState::Closed));
    298299
    299300    // 'new'
    300     m_iceTransportStateChanges.append(std::make_pair(m_mids[1], MediaEndpoint::IceTransportState::Closed));
     301    m_iceTransportStateChanges.append(std::make_pair(m_mids[1], RTCIceTransportState::Closed));
    301302
    302303    // Reverse order to use takeLast() while keeping the above order
  • trunk/Source/WebCore/platform/mock/MockMediaEndpoint.h

    r209416 r214030  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2017 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
     
    3435
    3536#include "MediaEndpoint.h"
     37#include "RTCEnums.h"
    3638#include "Timer.h"
    3739
     
    8688    Timer m_iceCandidateTimer;
    8789
    88     Vector<std::pair<String, MediaEndpoint::IceTransportState>> m_iceTransportStateChanges;
     90    Vector<std::pair<String, RTCIceTransportState>> m_iceTransportStateChanges;
    8991    Timer m_iceTransportTimer;
    9092
Note: See TracChangeset for help on using the changeset viewer.