Changeset 137441 in webkit


Ignore:
Timestamp:
Dec 12, 2012 2:42:40 AM (11 years ago)
Author:
tommyw@google.com
Message:

MediaStream API: Change the data channel descriptor pattern to a handler pattern
https://bugs.webkit.org/show_bug.cgi?id=104543

Reviewed by Kent Tamura.

Source/Platform:

In short the code is refactured to use the Handler/Client pattern (see RTCPeerConnectionHandler)
instead of the Descriptor pattern.
This will fix lifetime/memory/code structure issues in the chromium port.

  • Platform.gypi:
  • chromium/public/WebRTCDataChannel.h: Removed.
  • chromium/public/WebRTCDataChannelHandler.h: Added.

(WebKit):
(WebRTCDataChannelHandler):
(WebKit::WebRTCDataChannelHandler::~WebRTCDataChannelHandler):

  • chromium/public/WebRTCDataChannelHandlerClient.h: Added.

(WebKit):
(WebRTCDataChannelHandlerClient):
(WebKit::WebRTCDataChannelHandlerClient::~WebRTCDataChannelHandlerClient):

  • chromium/public/WebRTCPeerConnectionHandler.h:

(WebKit):
(WebKit::WebRTCPeerConnectionHandler::createDataChannel):

  • chromium/public/WebRTCPeerConnectionHandlerClient.h:

(WebKit):
(WebKit::WebRTCPeerConnectionHandlerClient::didAddRemoteDataChannel):

Source/WebCore:

In short the code is refactured to use the Handler/Client pattern (see RTCPeerConnectionHandler)
instead of the Descriptor pattern.
This will fix lifetime/memory/code structure issues in the chromium port.

Existing tests cover this patch.

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

(WebCore::RTCDataChannel::create):
(WebCore::RTCDataChannel::RTCDataChannel):
(WebCore::RTCDataChannel::~RTCDataChannel):
(WebCore::RTCDataChannel::label):
(WebCore::RTCDataChannel::reliable):
(WebCore::RTCDataChannel::readyState):
(WebCore::RTCDataChannel::bufferedAmount):
(WebCore::RTCDataChannel::send):
(WebCore::RTCDataChannel::close):
(WebCore::RTCDataChannel::didChangeReadyState):
(WebCore::RTCDataChannel::didReceiveStringData):
(WebCore::RTCDataChannel::didReceiveRawData):
(WebCore::RTCDataChannel::didDetectError):
(WebCore::RTCDataChannel::stop):

  • Modules/mediastream/RTCDataChannel.h:

(WebCore):
(RTCDataChannel):

  • Modules/mediastream/RTCPeerConnection.cpp:

(WebCore::RTCPeerConnection::didAddRemoteDataChannel):

  • Modules/mediastream/RTCPeerConnection.h:

(RTCPeerConnection):

  • WebCore.gypi:
  • platform/chromium/support/WebRTCDataChannel.cpp: Removed.
  • platform/mediastream/RTCDataChannelDescriptor.h: Removed.
  • platform/mediastream/RTCDataChannelHandler.h: Copied from Source/WebCore/platform/mediastream/RTCDataChannelDescriptor.cpp.

(WebCore):
(RTCDataChannelHandler):
(WebCore::RTCDataChannelHandler::~RTCDataChannelHandler):

  • platform/mediastream/RTCDataChannelHandlerClient.h: Renamed from Source/WebCore/platform/mediastream/RTCDataChannelDescriptor.cpp.

(WebCore):
(RTCDataChannelHandlerClient):
(WebCore::RTCDataChannelHandlerClient::~RTCDataChannelHandlerClient):

  • platform/mediastream/RTCPeerConnectionHandler.cpp:

(WebCore):
(WebCore::RTCPeerConnectionHandler::create):

  • platform/mediastream/RTCPeerConnectionHandler.h:

(WebCore):
(RTCPeerConnectionHandler):

  • platform/mediastream/RTCPeerConnectionHandlerClient.h:

(WebCore):
(RTCPeerConnectionHandlerClient):

  • platform/mediastream/chromium/RTCDataChannelHandlerChromium.cpp: Added.

(WebCore):
(WebCore::RTCDataChannelHandlerChromium::create):
(WebCore::RTCDataChannelHandlerChromium::RTCDataChannelHandlerChromium):
(WebCore::RTCDataChannelHandlerChromium::~RTCDataChannelHandlerChromium):
(WebCore::RTCDataChannelHandlerChromium::setClient):
(WebCore::RTCDataChannelHandlerChromium::label):
(WebCore::RTCDataChannelHandlerChromium::isReliable):
(WebCore::RTCDataChannelHandlerChromium::bufferedAmount):
(WebCore::RTCDataChannelHandlerChromium::sendStringData):
(WebCore::RTCDataChannelHandlerChromium::sendRawData):
(WebCore::RTCDataChannelHandlerChromium::close):
(WebCore::RTCDataChannelHandlerChromium::didChangeReadyState):
(WebCore::RTCDataChannelHandlerChromium::didReceiveStringData):
(WebCore::RTCDataChannelHandlerChromium::didReceiveRawData):
(WebCore::RTCDataChannelHandlerChromium::didDetectError):

  • platform/mediastream/chromium/RTCDataChannelHandlerChromium.h: Added.

(WebCore):
(RTCDataChannelHandlerChromium):

  • platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp:

(WebCore::RTCPeerConnectionHandlerChromium::createDataChannel):
(WebCore::RTCPeerConnectionHandlerChromium::didAddRemoteDataChannel):

  • platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h:

(WebCore):
(RTCPeerConnectionHandlerChromium):

Source/WebKit/chromium:

  • src/AssertMatchingEnums.cpp:

Tools:

Adding mocks to be able to test this refactoring.

  • DumpRenderTree/DumpRenderTree.gypi:
  • DumpRenderTree/chromium/MockWebRTCDataChannelHandler.cpp: Added.

(DataChannelReadyStateTask):
(DataChannelReadyStateTask::DataChannelReadyStateTask):
(MockWebRTCDataChannelHandler::MockWebRTCDataChannelHandler):
(MockWebRTCDataChannelHandler::setClient):
(MockWebRTCDataChannelHandler::bufferedAmount):
(MockWebRTCDataChannelHandler::sendStringData):
(MockWebRTCDataChannelHandler::sendRawData):
(MockWebRTCDataChannelHandler::close):

  • DumpRenderTree/chromium/MockWebRTCDataChannelHandler.h: Added.

(MockWebRTCDataChannelHandler):
(MockWebRTCDataChannelHandler::taskList):

  • DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp:

(RTCPeerConnectionReadyStateTask::RTCPeerConnectionReadyStateTask):
(RemoteDataChannelTask::RemoteDataChannelTask):
(MockWebRTCPeerConnectionHandler::createDataChannel):
(MockWebRTCPeerConnectionHandler::stop):

  • DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.h:

(MockWebRTCPeerConnectionHandler):

LayoutTests:

Expanding data channels tests.

  • fast/mediastream/RTCPeerConnection-datachannel-expected.txt:
  • fast/mediastream/RTCPeerConnection-datachannel.html:
Location:
trunk
Files:
6 added
3 deleted
26 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r137440 r137441  
     12012-12-12  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Change the data channel descriptor pattern to a handler pattern
     4        https://bugs.webkit.org/show_bug.cgi?id=104543
     5
     6        Reviewed by Kent Tamura.
     7
     8        Expanding data channels tests.
     9
     10        * fast/mediastream/RTCPeerConnection-datachannel-expected.txt:
     11        * fast/mediastream/RTCPeerConnection-datachannel.html:
     12
    1132012-12-12  Zan Dobersek  <zandobersek@gmail.com>
    214
  • trunk/LayoutTests/fast/mediastream/RTCPeerConnection-datachannel-expected.txt

    r134970 r137441  
    44
    55
     6PASS dc = pc.createDataChannel("label1"); did not throw exception.
    67PASS dc.reliable is true
     8PASS dc = pc.createDataChannel("label2", {}); did not throw exception.
    79PASS dc.reliable is true
     10PASS dc = pc.createDataChannel("label3", {reliable:true}); did not throw exception.
    811PASS dc.reliable is true
     12PASS dc = pc.createDataChannel("label3", {reliable:false}); did not throw exception.
    913PASS dc.reliable is false
    1014PASS pc_onopen was called
     15PASS dc = pc.createDataChannel("label"); did not throw exception.
    1116PASS dc.readyState is 'connecting'
    1217PASS pc_ondatachannel was called
    13 PASS event.channel.readyState is 'open'
    1418PASS dc_onopen was called
    1519PASS dc.readyState is 'open'
  • trunk/LayoutTests/fast/mediastream/RTCPeerConnection-datachannel.html

    r134970 r137441  
    7171function pc_ondatachannel(e) {
    7272    testPassed("pc_ondatachannel was called");
    73     event = e;
    74     shouldBe("event.channel.readyState", "'open'");
    7573}
    7674
    7775function pc_onopen() {
    7876    testPassed("pc_onopen was called");
    79     dc = pc.createDataChannel("label");
     77    shouldNotThrow('dc = pc.createDataChannel("label");');
    8078    shouldBe("dc.readyState", "'connecting'");
    8179    dc.onopen = dc_onopen;
     
    8381
    8482pc = new webkitRTCPeerConnection(null, null);
    85 dc = pc.createDataChannel("label1");
     83shouldNotThrow('dc = pc.createDataChannel("label1");');
    8684shouldBe("dc.reliable", "true");
    87 dc = pc.createDataChannel("label2", {});
     85shouldNotThrow('dc = pc.createDataChannel("label2", {});');
    8886shouldBe("dc.reliable", "true");
    89 dc = pc.createDataChannel("label3", {reliable:true});
     87shouldNotThrow('dc = pc.createDataChannel("label3", {reliable:true});');
    9088shouldBe("dc.reliable", "true");
    91 dc = pc.createDataChannel("label3", {reliable:false});
     89shouldNotThrow('dc = pc.createDataChannel("label3", {reliable:false});');
    9290shouldBe("dc.reliable", "false");
    9391
  • trunk/Source/Platform/ChangeLog

    r137335 r137441  
     12012-12-12  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Change the data channel descriptor pattern to a handler pattern
     4        https://bugs.webkit.org/show_bug.cgi?id=104543
     5
     6        Reviewed by Kent Tamura.
     7
     8        In short the code is refactured to use the Handler/Client pattern (see RTCPeerConnectionHandler)
     9        instead of the Descriptor pattern.
     10        This will fix lifetime/memory/code structure issues in the chromium port.
     11
     12        * Platform.gypi:
     13        * chromium/public/WebRTCDataChannel.h: Removed.
     14        * chromium/public/WebRTCDataChannelHandler.h: Added.
     15        (WebKit):
     16        (WebRTCDataChannelHandler):
     17        (WebKit::WebRTCDataChannelHandler::~WebRTCDataChannelHandler):
     18        * chromium/public/WebRTCDataChannelHandlerClient.h: Added.
     19        (WebKit):
     20        (WebRTCDataChannelHandlerClient):
     21        (WebKit::WebRTCDataChannelHandlerClient::~WebRTCDataChannelHandlerClient):
     22        * chromium/public/WebRTCPeerConnectionHandler.h:
     23        (WebKit):
     24        (WebKit::WebRTCPeerConnectionHandler::createDataChannel):
     25        * chromium/public/WebRTCPeerConnectionHandlerClient.h:
     26        (WebKit):
     27        (WebKit::WebRTCPeerConnectionHandlerClient::didAddRemoteDataChannel):
     28
    1292012-12-11  James Robinson  <jamesr@chromium.org>
    230
  • trunk/Source/Platform/Platform.gypi

    r137256 r137441  
    101101            'chromium/public/WebPrivatePtr.h',
    102102            'chromium/public/WebRTCConfiguration.h',
    103             'chromium/public/WebRTCDataChannel.h',
     103            'chromium/public/WebRTCDataChannelHandler.h',
     104            'chromium/public/WebRTCDataChannelHandlerClient.h',
    104105            'chromium/public/WebRTCICECandidate.h',
    105106            'chromium/public/WebRTCPeerConnectionHandler.h',
  • trunk/Source/Platform/chromium/public/WebRTCPeerConnectionHandler.h

    r131494 r137441  
    3636class WebMediaStreamDescriptor;
    3737class WebRTCConfiguration;
    38 class WebRTCDataChannel;
     38class WebRTCDataChannelHandler;
    3939class WebRTCICECandidate;
    4040class WebRTCPeerConnectionHandlerClient;
     
    6363    // FIXME: Remove default implementation when clients have changed.
    6464    virtual void getStats(const WebRTCStatsRequest&) { }
     65    virtual WebRTCDataChannelHandler* createDataChannel(const WebString& label, bool reliable) { return 0; }
    6566    virtual void stop() = 0;
    66 
    67     // RTCDataChannel
    68     virtual bool openDataChannel(const WebRTCDataChannel&) { return false; }
    69     virtual bool sendStringData(const WebRTCDataChannel&, const WebString&) { return false; }
    70     virtual bool sendRawData(const WebRTCDataChannel&, const char*, size_t) { return false; }
    71     virtual void closeDataChannel(const WebRTCDataChannel&) { }
    7267};
    7368
  • trunk/Source/Platform/chromium/public/WebRTCPeerConnectionHandlerClient.h

    r134976 r137441  
    3434namespace WebKit {
    3535class WebMediaStreamDescriptor;
    36 class WebRTCDataChannel;
     36class WebRTCDataChannelHandler;
    3737class WebRTCICECandidate;
    3838
     
    8282    virtual void didAddRemoteStream(const WebMediaStreamDescriptor&) = 0;
    8383    virtual void didRemoveRemoteStream(const WebMediaStreamDescriptor&) = 0;
    84     virtual void didAddRemoteDataChannel(const WebRTCDataChannel&) { }
     84    virtual void didAddRemoteDataChannel(WebRTCDataChannelHandler*) { }
    8585};
    8686
  • trunk/Source/WebCore/CMakeLists.txt

    r137422 r137441  
    19951995    platform/mediastream/MediaStreamCenter.cpp
    19961996    platform/mediastream/MediaStreamSource.cpp
    1997     platform/mediastream/RTCDataChannelDescriptor.cpp
    19981997    platform/mediastream/RTCIceCandidateDescriptor.cpp
    19991998    platform/mediastream/RTCPeerConnectionHandler.cpp
  • trunk/Source/WebCore/ChangeLog

    r137438 r137441  
     12012-12-12  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Change the data channel descriptor pattern to a handler pattern
     4        https://bugs.webkit.org/show_bug.cgi?id=104543
     5
     6        Reviewed by Kent Tamura.
     7
     8        In short the code is refactured to use the Handler/Client pattern (see RTCPeerConnectionHandler)
     9        instead of the Descriptor pattern.
     10        This will fix lifetime/memory/code structure issues in the chromium port.
     11
     12        Existing tests cover this patch.
     13
     14        * CMakeLists.txt:
     15        * GNUmakefile.list.am:
     16        * Modules/mediastream/RTCDataChannel.cpp:
     17        (WebCore::RTCDataChannel::create):
     18        (WebCore::RTCDataChannel::RTCDataChannel):
     19        (WebCore::RTCDataChannel::~RTCDataChannel):
     20        (WebCore::RTCDataChannel::label):
     21        (WebCore::RTCDataChannel::reliable):
     22        (WebCore::RTCDataChannel::readyState):
     23        (WebCore::RTCDataChannel::bufferedAmount):
     24        (WebCore::RTCDataChannel::send):
     25        (WebCore::RTCDataChannel::close):
     26        (WebCore::RTCDataChannel::didChangeReadyState):
     27        (WebCore::RTCDataChannel::didReceiveStringData):
     28        (WebCore::RTCDataChannel::didReceiveRawData):
     29        (WebCore::RTCDataChannel::didDetectError):
     30        (WebCore::RTCDataChannel::stop):
     31        * Modules/mediastream/RTCDataChannel.h:
     32        (WebCore):
     33        (RTCDataChannel):
     34        * Modules/mediastream/RTCPeerConnection.cpp:
     35        (WebCore::RTCPeerConnection::didAddRemoteDataChannel):
     36        * Modules/mediastream/RTCPeerConnection.h:
     37        (RTCPeerConnection):
     38        * WebCore.gypi:
     39        * platform/chromium/support/WebRTCDataChannel.cpp: Removed.
     40        * platform/mediastream/RTCDataChannelDescriptor.h: Removed.
     41        * platform/mediastream/RTCDataChannelHandler.h: Copied from Source/WebCore/platform/mediastream/RTCDataChannelDescriptor.cpp.
     42        (WebCore):
     43        (RTCDataChannelHandler):
     44        (WebCore::RTCDataChannelHandler::~RTCDataChannelHandler):
     45        * platform/mediastream/RTCDataChannelHandlerClient.h: Renamed from Source/WebCore/platform/mediastream/RTCDataChannelDescriptor.cpp.
     46        (WebCore):
     47        (RTCDataChannelHandlerClient):
     48        (WebCore::RTCDataChannelHandlerClient::~RTCDataChannelHandlerClient):
     49        * platform/mediastream/RTCPeerConnectionHandler.cpp:
     50        (WebCore):
     51        (WebCore::RTCPeerConnectionHandler::create):
     52        * platform/mediastream/RTCPeerConnectionHandler.h:
     53        (WebCore):
     54        (RTCPeerConnectionHandler):
     55        * platform/mediastream/RTCPeerConnectionHandlerClient.h:
     56        (WebCore):
     57        (RTCPeerConnectionHandlerClient):
     58        * platform/mediastream/chromium/RTCDataChannelHandlerChromium.cpp: Added.
     59        (WebCore):
     60        (WebCore::RTCDataChannelHandlerChromium::create):
     61        (WebCore::RTCDataChannelHandlerChromium::RTCDataChannelHandlerChromium):
     62        (WebCore::RTCDataChannelHandlerChromium::~RTCDataChannelHandlerChromium):
     63        (WebCore::RTCDataChannelHandlerChromium::setClient):
     64        (WebCore::RTCDataChannelHandlerChromium::label):
     65        (WebCore::RTCDataChannelHandlerChromium::isReliable):
     66        (WebCore::RTCDataChannelHandlerChromium::bufferedAmount):
     67        (WebCore::RTCDataChannelHandlerChromium::sendStringData):
     68        (WebCore::RTCDataChannelHandlerChromium::sendRawData):
     69        (WebCore::RTCDataChannelHandlerChromium::close):
     70        (WebCore::RTCDataChannelHandlerChromium::didChangeReadyState):
     71        (WebCore::RTCDataChannelHandlerChromium::didReceiveStringData):
     72        (WebCore::RTCDataChannelHandlerChromium::didReceiveRawData):
     73        (WebCore::RTCDataChannelHandlerChromium::didDetectError):
     74        * platform/mediastream/chromium/RTCDataChannelHandlerChromium.h: Added.
     75        (WebCore):
     76        (RTCDataChannelHandlerChromium):
     77        * platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp:
     78        (WebCore::RTCPeerConnectionHandlerChromium::createDataChannel):
     79        (WebCore::RTCPeerConnectionHandlerChromium::didAddRemoteDataChannel):
     80        * platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h:
     81        (WebCore):
     82        (RTCPeerConnectionHandlerChromium):
     83
    1842012-12-12  Huang Dongsung  <luxtella@company100.net>
    285
  • trunk/Source/WebCore/GNUmakefile.list.am

    r137422 r137441  
    56765676        Source/WebCore/platform/mediastream/MediaStreamSourcesQueryClient.h \
    56775677        Source/WebCore/platform/mediastream/RTCConfiguration.h \
    5678         Source/WebCore/platform/mediastream/RTCDataChannelDescriptor.cpp \
    5679         Source/WebCore/platform/mediastream/RTCDataChannelDescriptor.h \
     5678        Source/WebCore/platform/mediastream/RTCDataChannelHandler.h \
     5679        Source/WebCore/platform/mediastream/RTCDataChannelHandlerClient.h \
    56805680        Source/WebCore/platform/mediastream/RTCIceCandidateDescriptor.cpp \
    56815681        Source/WebCore/platform/mediastream/RTCIceCandidateDescriptor.h \
  • trunk/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp

    r134440 r137441  
    3333#include "ExceptionCode.h"
    3434#include "MessageEvent.h"
     35#include "RTCDataChannelHandler.h"
    3536#include "RTCPeerConnectionHandler.h"
    3637#include "ScriptExecutionContext.h"
     
    4041namespace WebCore {
    4142
    42 PassRefPtr<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext* context, RTCPeerConnectionHandler* handler, const String& label, bool reliable, ExceptionCode& ec)
    43 {
    44     ASSERT(handler);
    45     RefPtr<RTCDataChannel> dataChannel = create(context, handler, RTCDataChannelDescriptor::create(label, reliable));
    46     if (!handler->openDataChannel(dataChannel->descriptor())) {
     43PassRefPtr<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext* context, RTCPeerConnectionHandler* peerConnectionHandler, const String& label, bool reliable, ExceptionCode& ec)
     44{
     45    OwnPtr<RTCDataChannelHandler> handler = peerConnectionHandler->createDataChannel(label, reliable);
     46    if (!handler) {
    4747        ec = NOT_SUPPORTED_ERR;
    4848        return 0;
    4949    }
    50     return dataChannel.release();
    51 }
    52 
    53 PassRefPtr<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext* context, RTCPeerConnectionHandler* handler, PassRefPtr<RTCDataChannelDescriptor> descriptor)
     50    return adoptRef(new RTCDataChannel(context, handler.release()));
     51}
     52
     53PassRefPtr<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext* context, PassOwnPtr<RTCDataChannelHandler> handler)
    5454{
    5555    ASSERT(handler);
    56     ASSERT(descriptor);
    57     return adoptRef(new RTCDataChannel(context, handler, descriptor));
    58 }
    59 
    60 RTCDataChannel::RTCDataChannel(ScriptExecutionContext* context, RTCPeerConnectionHandler* handler, PassRefPtr<RTCDataChannelDescriptor> descriptor)
     56    return adoptRef(new RTCDataChannel(context, handler));
     57}
     58
     59RTCDataChannel::RTCDataChannel(ScriptExecutionContext* context, PassOwnPtr<RTCDataChannelHandler> handler)
    6160    : m_scriptExecutionContext(context)
     61    , m_handler(handler)
    6262    , m_stopped(false)
    63     , m_descriptor(descriptor)
     63    , m_readyState(ReadyStateConnecting)
    6464    , m_binaryType(BinaryTypeArrayBuffer)
    65     , m_handler(handler)
    6665    , m_scheduledEventTimer(this, &RTCDataChannel::scheduledEventTimerFired)
    6766{
    68     m_descriptor->setClient(this);
     67    m_handler->setClient(this);
    6968}
    7069
    7170RTCDataChannel::~RTCDataChannel()
    7271{
    73     m_descriptor->setClient(0);
    7472}
    7573
    7674String RTCDataChannel::label() const
    7775{
    78     return m_descriptor->label();
     76    return m_handler->label();
    7977}
    8078
    8179bool RTCDataChannel::reliable() const
    8280{
    83     return m_descriptor->reliable();
     81    return m_handler->isReliable();
    8482}
    8583
    8684String RTCDataChannel::readyState() const
    8785{
    88     switch (m_descriptor->readyState()) {
    89     case RTCDataChannelDescriptor::ReadyStateConnecting:
     86    switch (m_readyState) {
     87    case ReadyStateConnecting:
    9088        return ASCIILiteral("connecting");
    91     case RTCDataChannelDescriptor::ReadyStateOpen:
     89    case ReadyStateOpen:
    9290        return ASCIILiteral("open");
    93     case RTCDataChannelDescriptor::ReadyStateClosing:
     91    case ReadyStateClosing:
    9492        return ASCIILiteral("closing");
    95     case RTCDataChannelDescriptor::ReadyStateClosed:
     93    case ReadyStateClosed:
    9694        return ASCIILiteral("closed");
    9795    }
     
    103101unsigned long RTCDataChannel::bufferedAmount() const
    104102{
    105     return m_descriptor->bufferedAmount();
     103    return m_handler->bufferedAmount();
    106104}
    107105
     
    130128void RTCDataChannel::send(const String& data, ExceptionCode& ec)
    131129{
    132     if (m_descriptor->readyState() != RTCDataChannelDescriptor::ReadyStateOpen) {
     130    if (m_readyState != ReadyStateOpen) {
    133131        ec = INVALID_STATE_ERR;
    134132        return;
    135133    }
    136     if (!m_handler->sendStringData(descriptor(), data)) {
     134    if (!m_handler->sendStringData(data)) {
    137135        // FIXME: Decide what the right exception here is.
    138136        ec = SYNTAX_ERR;
     
    142140void RTCDataChannel::send(PassRefPtr<ArrayBuffer> prpData, ExceptionCode& ec)
    143141{
    144     if (m_descriptor->readyState() != RTCDataChannelDescriptor::ReadyStateOpen) {
     142    if (m_readyState != ReadyStateOpen) {
    145143        ec = INVALID_STATE_ERR;
    146144        return;
     
    155153    const char* dataPointer = static_cast<const char*>(data->data());
    156154
    157     if (!m_handler->sendRawData(descriptor(), dataPointer, dataLength)) {
     155    if (!m_handler->sendRawData(dataPointer, dataLength)) {
    158156        // FIXME: Decide what the right exception here is.
    159157        ec = SYNTAX_ERR;
     
    178176        return;
    179177
    180     m_handler->closeDataChannel(descriptor());
    181 }
    182 
    183 void RTCDataChannel::readyStateChanged()
    184 {
    185     if (m_stopped)
    186         return;
    187 
    188     switch (m_descriptor->readyState()) {
    189     case RTCDataChannelDescriptor::ReadyStateOpen:
     178    m_handler->close();
     179}
     180
     181void RTCDataChannel::didChangeReadyState(ReadyState newState)
     182{
     183    if (m_stopped || m_readyState == ReadyStateClosed)
     184        return;
     185
     186    m_readyState = newState;
     187
     188    switch (m_readyState) {
     189    case ReadyStateOpen:
    190190        scheduleDispatchEvent(Event::create(eventNames().openEvent, false, false));
    191191        break;
    192     case RTCDataChannelDescriptor::ReadyStateClosed:
     192    case ReadyStateClosed:
    193193        scheduleDispatchEvent(Event::create(eventNames().closeEvent, false, false));
    194194        break;
     
    198198}
    199199
    200 void RTCDataChannel::dataArrived(const String& text)
     200void RTCDataChannel::didReceiveStringData(const String& text)
    201201{
    202202    if (m_stopped)
     
    206206}
    207207
    208 void RTCDataChannel::dataArrived(const char* data, size_t dataLength)
     208void RTCDataChannel::didReceiveRawData(const char* data, size_t dataLength)
    209209{
    210210    if (m_stopped)
     
    223223}
    224224
    225 void RTCDataChannel::error()
     225void RTCDataChannel::didDetectError()
    226226{
    227227    if (m_stopped)
     
    231231}
    232232
    233 RTCDataChannelDescriptor* RTCDataChannel::descriptor()
    234 {
    235     return m_descriptor.get();
    236 }
    237 
    238233const AtomicString& RTCDataChannel::interfaceName() const
    239234{
     
    249244{
    250245    m_stopped = true;
    251     m_handler = 0;
    252     m_descriptor->setClient(0);
     246    m_handler->setClient(0);
    253247    m_scriptExecutionContext = 0;
    254248}
  • trunk/Source/WebCore/Modules/mediastream/RTCDataChannel.h

    r134207 r137441  
    2828#if ENABLE(MEDIA_STREAM)
    2929
    30 #include "ActiveDOMObject.h"
    3130#include "EventTarget.h"
    32 #include "RTCDataChannelDescriptor.h"
     31#include "RTCDataChannelHandlerClient.h"
    3332#include "Timer.h"
    3433#include <wtf/RefCounted.h>
    3534
    3635namespace WebCore {
     36
    3737class Blob;
     38class RTCDataChannelHandler;
    3839class RTCPeerConnectionHandler;
    3940
    40 class RTCDataChannel : public RefCounted<RTCDataChannel>, public EventTarget, public RTCDataChannelDescriptorClient {
     41class RTCDataChannel : public RefCounted<RTCDataChannel>, public EventTarget, public RTCDataChannelHandlerClient {
    4142public:
    4243    static PassRefPtr<RTCDataChannel> create(ScriptExecutionContext*, RTCPeerConnectionHandler*, const String& label, bool reliable, ExceptionCode&);
    43     static PassRefPtr<RTCDataChannel> create(ScriptExecutionContext*, RTCPeerConnectionHandler*, PassRefPtr<RTCDataChannelDescriptor>);
     44    static PassRefPtr<RTCDataChannel> create(ScriptExecutionContext*, PassOwnPtr<RTCDataChannelHandler>);
    4445    ~RTCDataChannel();
    4546
    4647    String label() const;
    47 
    4848    bool reliable() const;
    49 
    5049    String readyState() const;
    51 
    5250    unsigned long bufferedAmount() const;
    5351
     
    6765    DEFINE_ATTRIBUTE_EVENT_LISTENER(message);
    6866
    69     RTCDataChannelDescriptor* descriptor();
    7067    void stop();
    7168
     
    7875
    7976private:
    80     RTCDataChannel(ScriptExecutionContext*, RTCPeerConnectionHandler*, PassRefPtr<RTCDataChannelDescriptor>);
     77    RTCDataChannel(ScriptExecutionContext*, PassOwnPtr<RTCDataChannelHandler>);
    8178
    8279    void scheduleDispatchEvent(PassRefPtr<Event>);
     
    9188    ScriptExecutionContext* m_scriptExecutionContext;
    9289
    93     // RTCDataChannelDescriptor::Owner
    94     virtual void readyStateChanged() OVERRIDE;
    95     virtual void dataArrived(const String&) OVERRIDE;
    96     virtual void dataArrived(const char*, size_t) OVERRIDE;
    97     virtual void error() OVERRIDE;
     90    // RTCDataChannelHandlerClient
     91    virtual void didChangeReadyState(ReadyState) OVERRIDE;
     92    virtual void didReceiveStringData(const String&) OVERRIDE;
     93    virtual void didReceiveRawData(const char*, size_t) OVERRIDE;
     94    virtual void didDetectError() OVERRIDE;
     95
     96    OwnPtr<RTCDataChannelHandler> m_handler;
    9897
    9998    bool m_stopped;
    100     RefPtr<RTCDataChannelDescriptor> m_descriptor;
    10199
     100    ReadyState m_readyState;
    102101    enum BinaryType {
    103102        BinaryTypeBlob,
     
    105104    };
    106105    BinaryType m_binaryType;
    107 
    108     // Not owned by this class.
    109     RTCPeerConnectionHandler* m_handler;
    110106
    111107    Timer<RTCDataChannel> m_scheduledEventTimer;
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r134976 r137441  
    4646#include "RTCDataChannel.h"
    4747#include "RTCDataChannelEvent.h"
     48#include "RTCDataChannelHandler.h"
    4849#include "RTCErrorCallback.h"
    4950#include "RTCIceCandidate.h"
     
    540541}
    541542
    542 void RTCPeerConnection::didAddRemoteDataChannel(PassRefPtr<RTCDataChannelDescriptor> channelDescriptor)
     543void RTCPeerConnection::didAddRemoteDataChannel(PassOwnPtr<RTCDataChannelHandler> handler)
    543544{
    544545    ASSERT(scriptExecutionContext()->isContextThread());
     
    547548        return;
    548549
    549     RefPtr<RTCDataChannel> channel = RTCDataChannel::create(scriptExecutionContext(), m_peerHandler.get(), channelDescriptor);
     550    RefPtr<RTCDataChannel> channel = RTCDataChannel::create(scriptExecutionContext(), handler);
    550551    m_dataChannels.append(channel);
    551552
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

    r134976 r137441  
    115115    virtual void didAddRemoteStream(PassRefPtr<MediaStreamDescriptor>) OVERRIDE;
    116116    virtual void didRemoveRemoteStream(MediaStreamDescriptor*) OVERRIDE;
    117     virtual void didAddRemoteDataChannel(PassRefPtr<RTCDataChannelDescriptor>) OVERRIDE;
     117    virtual void didAddRemoteDataChannel(PassOwnPtr<RTCDataChannelHandler>) OVERRIDE;
    118118
    119119    // EventTarget
  • trunk/Source/WebCore/WebCore.gypi

    r137422 r137441  
    43004300            'platform/mediastream/MediaStreamSource.h',
    43014301            'platform/mediastream/RTCConfiguration.h',
    4302             'platform/mediastream/RTCDataChannelDescriptor.cpp',
    4303             'platform/mediastream/RTCDataChannelDescriptor.h',
     4302            'platform/mediastream/RTCDataChannelHandler.h',
     4303            'platform/mediastream/RTCDataChannelHandlerClient.h',
    43044304            'platform/mediastream/RTCIceCandidateDescriptor.cpp',
    43054305            'platform/mediastream/RTCIceCandidateDescriptor.h',
     
    43134313            'platform/mediastream/chromium/MediaStreamCenterChromium.cpp',
    43144314            'platform/mediastream/chromium/MediaStreamCenterChromium.h',
     4315            'platform/mediastream/chromium/RTCDataChannelHandlerChromium.cpp',
     4316            'platform/mediastream/chromium/RTCDataChannelHandlerChromium.h',
    43154317            'platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp',
    43164318            'platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h',
     
    71107112            'platform/chromium/support/WebPrerender.cpp',
    71117113            'platform/chromium/support/WebRTCConfiguration.cpp',
    7112             'platform/chromium/support/WebRTCDataChannel.cpp',
    71137114            'platform/chromium/support/WebRTCICECandidate.cpp',
    71147115            'platform/chromium/support/WebRTCSessionDescription.cpp',
  • trunk/Source/WebCore/platform/mediastream/RTCDataChannelHandler.h

    r137440 r137441  
    2323 */
    2424
    25 #include "config.h"
     25#ifndef RTCDataChannelHandler_h
     26#define RTCDataChannelHandler_h
    2627
    2728#if ENABLE(MEDIA_STREAM)
    2829
    29 #include "RTCDataChannelDescriptor.h"
     30#include <wtf/text/WTFString.h>
    3031
    3132namespace WebCore {
    3233
    33 PassRefPtr<RTCDataChannelDescriptor> RTCDataChannelDescriptor::create(const String& label, bool reliable)
    34 {
    35     return adoptRef(new RTCDataChannelDescriptor(label, reliable));
    36 }
     34class RTCDataChannelHandlerClient;
    3735
    38 RTCDataChannelDescriptor::RTCDataChannelDescriptor(const String& label, bool reliable)
    39     : m_client(0)
    40     , m_label(label)
    41     , m_reliable(reliable)
    42     , m_readyState(ReadyStateConnecting)
    43     , m_bufferedAmount(0)
    44 {
    45 }
     36class RTCDataChannelHandler {
     37public:
     38    virtual ~RTCDataChannelHandler() { }
    4639
    47 RTCDataChannelDescriptor::~RTCDataChannelDescriptor()
    48 {
    49 }
     40    virtual void setClient(RTCDataChannelHandlerClient*) = 0;
    5041
    51 void RTCDataChannelDescriptor::readyStateChanged(ReadyState readyState)
    52 {
    53     ASSERT(m_readyState != ReadyStateClosed);
    54     if (m_readyState != readyState) {
    55         m_readyState = readyState;
    56         if (m_client)
    57             m_client->readyStateChanged();
    58     }
    59 }
     42    virtual String label() = 0;
     43    virtual bool isReliable() = 0;
     44    virtual unsigned long bufferedAmount() = 0;
    6045
    61 void RTCDataChannelDescriptor::dataArrived(const String& data)
    62 {
    63     ASSERT(m_readyState != ReadyStateClosed);
    64     if (m_client)
    65         m_client->dataArrived(data);
    66 }
    67 
    68 void RTCDataChannelDescriptor::dataArrived(const char* data, size_t dataLength)
    69 {
    70     ASSERT(m_readyState != ReadyStateClosed);
    71     if (m_client)
    72         m_client->dataArrived(data, dataLength);
    73 }
    74 
    75 void RTCDataChannelDescriptor::error()
    76 {
    77     ASSERT(m_readyState != ReadyStateClosed);
    78     if (m_client)
    79         m_client->error();
    80 }
     46    virtual bool sendStringData(const String&) = 0;
     47    virtual bool sendRawData(const char*, size_t) = 0;
     48    virtual void close() = 0;
     49};
    8150
    8251} // namespace WebCore
    8352
    8453#endif // ENABLE(MEDIA_STREAM)
     54
     55#endif // RTCDataChannelHandler_h
  • trunk/Source/WebCore/platform/mediastream/RTCDataChannelHandlerClient.h

    r137440 r137441  
    2323 */
    2424
    25 #include "config.h"
     25#ifndef RTCDataChannelHandlerClient_h
     26#define RTCDataChannelHandlerClient_h
    2627
    2728#if ENABLE(MEDIA_STREAM)
    2829
    29 #include "RTCDataChannelDescriptor.h"
    30 
    3130namespace WebCore {
    3231
    33 PassRefPtr<RTCDataChannelDescriptor> RTCDataChannelDescriptor::create(const String& label, bool reliable)
    34 {
    35     return adoptRef(new RTCDataChannelDescriptor(label, reliable));
    36 }
     32class RTCDataChannelHandlerClient {
     33public:
     34    enum ReadyState {
     35        ReadyStateConnecting = 0,
     36        ReadyStateOpen = 1,
     37        ReadyStateClosing = 2,
     38        ReadyStateClosed = 3,
     39    };
    3740
    38 RTCDataChannelDescriptor::RTCDataChannelDescriptor(const String& label, bool reliable)
    39     : m_client(0)
    40     , m_label(label)
    41     , m_reliable(reliable)
    42     , m_readyState(ReadyStateConnecting)
    43     , m_bufferedAmount(0)
    44 {
    45 }
     41    virtual ~RTCDataChannelHandlerClient() { }
    4642
    47 RTCDataChannelDescriptor::~RTCDataChannelDescriptor()
    48 {
    49 }
    50 
    51 void RTCDataChannelDescriptor::readyStateChanged(ReadyState readyState)
    52 {
    53     ASSERT(m_readyState != ReadyStateClosed);
    54     if (m_readyState != readyState) {
    55         m_readyState = readyState;
    56         if (m_client)
    57             m_client->readyStateChanged();
    58     }
    59 }
    60 
    61 void RTCDataChannelDescriptor::dataArrived(const String& data)
    62 {
    63     ASSERT(m_readyState != ReadyStateClosed);
    64     if (m_client)
    65         m_client->dataArrived(data);
    66 }
    67 
    68 void RTCDataChannelDescriptor::dataArrived(const char* data, size_t dataLength)
    69 {
    70     ASSERT(m_readyState != ReadyStateClosed);
    71     if (m_client)
    72         m_client->dataArrived(data, dataLength);
    73 }
    74 
    75 void RTCDataChannelDescriptor::error()
    76 {
    77     ASSERT(m_readyState != ReadyStateClosed);
    78     if (m_client)
    79         m_client->error();
    80 }
     43    virtual void didChangeReadyState(ReadyState) = 0;
     44    virtual void didReceiveStringData(const String&) = 0;
     45    virtual void didReceiveRawData(const char*, size_t) = 0;
     46    virtual void didDetectError() = 0;
     47};
    8148
    8249} // namespace WebCore
    8350
    8451#endif // ENABLE(MEDIA_STREAM)
     52
     53#endif // RTCDataChannelHandlerClient_h
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandler.cpp

    r131372 r137441  
    3535#include "RTCPeerConnectionHandler.h"
    3636
    37 #include "RTCPeerConnectionHandlerClient.h"
    38 #include "RTCSessionDescriptionDescriptor.h"
    3937#include <wtf/PassOwnPtr.h>
    4038
    4139namespace WebCore {
     40class RTCPeerConnectionHandlerClient;
    4241
    43 // Dummy implementations below for ports that build with MEDIA_STREAM enabled by default.
    44 
    45 class RTCPeerConnectionHandlerDummy : public RTCPeerConnectionHandler {
    46 public:
    47     RTCPeerConnectionHandlerDummy(RTCPeerConnectionHandlerClient*);
    48     virtual ~RTCPeerConnectionHandlerDummy();
    49 
    50     virtual bool initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) OVERRIDE;
    51 
    52     virtual void createOffer(PassRefPtr<RTCSessionDescriptionRequest>, PassRefPtr<MediaConstraints>) OVERRIDE;
    53     virtual void createAnswer(PassRefPtr<RTCSessionDescriptionRequest>, PassRefPtr<MediaConstraints>) OVERRIDE;
    54     virtual void setLocalDescription(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCSessionDescriptionDescriptor>) OVERRIDE;
    55     virtual void setRemoteDescription(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCSessionDescriptionDescriptor>) OVERRIDE;
    56     virtual PassRefPtr<RTCSessionDescriptionDescriptor> localDescription() OVERRIDE;
    57     virtual PassRefPtr<RTCSessionDescriptionDescriptor> remoteDescription() OVERRIDE;
    58     virtual bool updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>) OVERRIDE;
    59     virtual bool addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>) OVERRIDE;
    60     virtual bool addStream(PassRefPtr<MediaStreamDescriptor>, PassRefPtr<MediaConstraints>) OVERRIDE;
    61     virtual void removeStream(PassRefPtr<MediaStreamDescriptor>) OVERRIDE;
    62     virtual void getStats(PassRefPtr<RTCStatsRequest>) OVERRIDE;
    63     virtual void stop() OVERRIDE;
    64 
    65     // RTCDataChannel.
    66     virtual bool openDataChannel(PassRefPtr<RTCDataChannelDescriptor>) OVERRIDE;
    67     virtual bool sendStringData(PassRefPtr<RTCDataChannelDescriptor>, const String&) OVERRIDE;
    68     virtual bool sendRawData(PassRefPtr<RTCDataChannelDescriptor>, const char*, size_t) OVERRIDE;
    69     virtual void closeDataChannel(PassRefPtr<RTCDataChannelDescriptor>) OVERRIDE;
    70 
    71 private:
    72     RTCPeerConnectionHandlerClient* m_client;
    73 };
    74 
    75 PassOwnPtr<RTCPeerConnectionHandler> RTCPeerConnectionHandler::create(RTCPeerConnectionHandlerClient* client)
     42PassOwnPtr<RTCPeerConnectionHandler> RTCPeerConnectionHandler::create(RTCPeerConnectionHandlerClient*)
    7643{
    77     return adoptPtr(new RTCPeerConnectionHandlerDummy(client));
    78 }
    79 
    80 RTCPeerConnectionHandlerDummy::RTCPeerConnectionHandlerDummy(RTCPeerConnectionHandlerClient* client)
    81     : m_client(client)
    82 {
    83     ASSERT(m_client);
    84 }
    85 
    86 RTCPeerConnectionHandlerDummy::~RTCPeerConnectionHandlerDummy()
    87 {
    88 }
    89 
    90 bool RTCPeerConnectionHandlerDummy::initialize(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>)
    91 {
    92     return false;
    93 }
    94 
    95 void RTCPeerConnectionHandlerDummy::createOffer(PassRefPtr<RTCSessionDescriptionRequest>, PassRefPtr<MediaConstraints>)
    96 {
    97 }
    98 
    99 void RTCPeerConnectionHandlerDummy::createAnswer(PassRefPtr<RTCSessionDescriptionRequest>, PassRefPtr<MediaConstraints>)
    100 {
    101 }
    102 
    103 void RTCPeerConnectionHandlerDummy::setLocalDescription(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCSessionDescriptionDescriptor>)
    104 {
    105 }
    106 
    107 void RTCPeerConnectionHandlerDummy::setRemoteDescription(PassRefPtr<RTCVoidRequest>, PassRefPtr<RTCSessionDescriptionDescriptor>)
    108 {
    109 }
    110 
    111 PassRefPtr<RTCSessionDescriptionDescriptor> RTCPeerConnectionHandlerDummy::localDescription()
    112 {
    113     return 0;
    114 }
    115 
    116 PassRefPtr<RTCSessionDescriptionDescriptor> RTCPeerConnectionHandlerDummy::remoteDescription()
    117 {
    118     return 0;
    119 }
    120 
    121 bool RTCPeerConnectionHandlerDummy::addStream(PassRefPtr<MediaStreamDescriptor>, PassRefPtr<MediaConstraints>)
    122 {
    123     return false;
    124 }
    125 
    126 void RTCPeerConnectionHandlerDummy::removeStream(PassRefPtr<MediaStreamDescriptor>)
    127 {
    128 }
    129 
    130 bool RTCPeerConnectionHandlerDummy::updateIce(PassRefPtr<RTCConfiguration>, PassRefPtr<MediaConstraints>)
    131 {
    132     return false;
    133 }
    134 
    135 bool RTCPeerConnectionHandlerDummy::addIceCandidate(PassRefPtr<RTCIceCandidateDescriptor>)
    136 {
    137     return false;
    138 }
    139 
    140 void RTCPeerConnectionHandlerDummy::getStats(PassRefPtr<RTCStatsRequest>)
    141 {
    142 }
    143 
    144 void RTCPeerConnectionHandlerDummy::stop()
    145 {
    146 }
    147 
    148 bool RTCPeerConnectionHandlerDummy::openDataChannel(PassRefPtr<RTCDataChannelDescriptor>)
    149 {
    150     return false;
    151 }
    152 
    153 bool RTCPeerConnectionHandlerDummy::sendStringData(PassRefPtr<RTCDataChannelDescriptor>, const String&)
    154 {
    155     return false;
    156 }
    157 
    158 bool RTCPeerConnectionHandlerDummy::sendRawData(PassRefPtr<RTCDataChannelDescriptor>, const char*, size_t)
    159 {
    160     return false;
    161 }
    162 
    163 void RTCPeerConnectionHandlerDummy::closeDataChannel(PassRefPtr<RTCDataChannelDescriptor>)
    164 {
     44    return nullptr;
    16545}
    16646
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandler.h

    r131372 r137441  
    4242class MediaConstraints;
    4343class RTCConfiguration;
    44 class RTCDataChannelDescriptor;
     44class RTCDataChannelHandler;
    4545class RTCIceCandidateDescriptor;
    4646class RTCPeerConnectionHandlerClient;
     
    7070    virtual void stop() = 0;
    7171
    72     // RTCDataChannel.
    73     virtual bool openDataChannel(PassRefPtr<RTCDataChannelDescriptor>) = 0;
    74     virtual bool sendStringData(PassRefPtr<RTCDataChannelDescriptor>, const String&) = 0;
    75     virtual bool sendRawData(PassRefPtr<RTCDataChannelDescriptor>, const char*, size_t) = 0;
    76     virtual void closeDataChannel(PassRefPtr<RTCDataChannelDescriptor>) = 0;
     72    // RTCDataChannel
     73    virtual PassOwnPtr<RTCDataChannelHandler> createDataChannel(const String& label, bool reliable) = 0;
    7774
    7875protected:
  • trunk/Source/WebCore/platform/mediastream/RTCPeerConnectionHandlerClient.h

    r134976 r137441  
    3939
    4040class MediaStreamDescriptor;
    41 class RTCDataChannelDescriptor;
     41class RTCDataChannelHandler;
    4242class RTCIceCandidateDescriptor;
    4343
     
    8787    virtual void didAddRemoteStream(PassRefPtr<MediaStreamDescriptor>) = 0;
    8888    virtual void didRemoveRemoteStream(MediaStreamDescriptor*) = 0;
    89 
    90     // RTCDataChannel.
    91     virtual void didAddRemoteDataChannel(PassRefPtr<RTCDataChannelDescriptor>) = 0;
     89    virtual void didAddRemoteDataChannel(PassOwnPtr<RTCDataChannelHandler>) = 0;
    9290};
    9391
  • trunk/Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp

    r134976 r137441  
    3737#include "MediaConstraints.h"
    3838#include "RTCConfiguration.h"
    39 #include "RTCDataChannelDescriptor.h"
     39#include "RTCDataChannelHandlerChromium.h"
     40#include "RTCDataChannelHandlerClient.h"
    4041#include "RTCIceCandidateDescriptor.h"
    4142#include "RTCPeerConnectionHandlerClient.h"
     
    4849#include <public/WebMediaStreamDescriptor.h>
    4950#include <public/WebRTCConfiguration.h>
    50 #include <public/WebRTCDataChannel.h>
     51#include <public/WebRTCDataChannelHandler.h>
    5152#include <public/WebRTCICECandidate.h>
    5253#include <public/WebRTCSessionDescription.h>
     
    149150}
    150151
    151 bool RTCPeerConnectionHandlerChromium::openDataChannel(PassRefPtr<RTCDataChannelDescriptor> dataChannel)
    152 {
    153     return m_webHandler->openDataChannel(dataChannel);
    154 }
    155 
    156 bool RTCPeerConnectionHandlerChromium::sendStringData(PassRefPtr<RTCDataChannelDescriptor> dataChannel, const String& data)
    157 {
    158     return m_webHandler->sendStringData(dataChannel, data);
    159 }
    160 
    161 bool RTCPeerConnectionHandlerChromium::sendRawData(PassRefPtr<RTCDataChannelDescriptor> dataChannel, const char* data, size_t dataLength)
    162 {
    163     return m_webHandler->sendRawData(dataChannel, data, dataLength);
    164 }
    165 
    166 void RTCPeerConnectionHandlerChromium::closeDataChannel(PassRefPtr<RTCDataChannelDescriptor> dataChannel)
    167 {
    168     return m_webHandler->closeDataChannel(dataChannel);
     152PassOwnPtr<RTCDataChannelHandler> RTCPeerConnectionHandlerChromium::createDataChannel(const String& label, bool reliable)
     153{
     154    WebKit::WebRTCDataChannelHandler* webHandler = m_webHandler->createDataChannel(label, reliable);
     155    if (!webHandler)
     156        return nullptr;
     157
     158    return RTCDataChannelHandlerChromium::create(webHandler);
    169159}
    170160
     
    209199}
    210200
    211 void RTCPeerConnectionHandlerChromium::didAddRemoteDataChannel(const WebKit::WebRTCDataChannel& dataChannel)
    212 {
    213     m_client->didAddRemoteDataChannel(dataChannel);
     201void RTCPeerConnectionHandlerChromium::didAddRemoteDataChannel(WebKit::WebRTCDataChannelHandler* webHandler)
     202{
     203    ASSERT(webHandler);
     204    m_client->didAddRemoteDataChannel(RTCDataChannelHandlerChromium::create(webHandler));
    214205}
    215206
  • trunk/Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h

    r134976 r137441  
    4343namespace WebKit {
    4444class WebMediaStreamDescriptor;
    45 class WebRTCDataChannel;
    4645class WebRTCICECandidate;
    4746}
    4847
    4948namespace WebCore {
     49
     50class RTCDataChannelHandler;
    5051
    5152class RTCPeerConnectionHandlerChromium : public RTCPeerConnectionHandler, public WebKit::WebRTCPeerConnectionHandlerClient {
     
    6970    virtual void removeStream(PassRefPtr<MediaStreamDescriptor>) OVERRIDE;
    7071    virtual void getStats(PassRefPtr<RTCStatsRequest>) OVERRIDE;
     72    virtual PassOwnPtr<RTCDataChannelHandler> createDataChannel(const String& label, bool reliable) OVERRIDE;
    7173    virtual void stop() OVERRIDE;
    72 
    73     virtual bool openDataChannel(PassRefPtr<RTCDataChannelDescriptor>) OVERRIDE;
    74     virtual bool sendStringData(PassRefPtr<RTCDataChannelDescriptor>, const String&) OVERRIDE;
    75     virtual bool sendRawData(PassRefPtr<RTCDataChannelDescriptor>, const char*, size_t) OVERRIDE;
    76     virtual void closeDataChannel(PassRefPtr<RTCDataChannelDescriptor>) OVERRIDE;
    7774
    7875    // WebKit::WebRTCPeerConnectionHandlerClient implementation.
     
    8481    virtual void didAddRemoteStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
    8582    virtual void didRemoveRemoteStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
    86     virtual void didAddRemoteDataChannel(const WebKit::WebRTCDataChannel&) OVERRIDE;
     83    virtual void didAddRemoteDataChannel(WebKit::WebRTCDataChannelHandler*) OVERRIDE;
    8784
    8885    static WebKit::WebRTCPeerConnectionHandler* toWebRTCPeerConnectionHandler(RTCPeerConnectionHandler*);
  • trunk/Source/WebKit/chromium/ChangeLog

    r137414 r137441  
     12012-12-12  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Change the data channel descriptor pattern to a handler pattern
     4        https://bugs.webkit.org/show_bug.cgi?id=104543
     5
     6        Reviewed by Kent Tamura.
     7
     8        * src/AssertMatchingEnums.cpp:
     9
    1102012-12-11  Dominic Mazzoni  <dmazzoni@google.com>
    211
  • trunk/Source/WebKit/chromium/src/AssertMatchingEnums.cpp

    r136846 r137441  
    6666#include "NotificationClient.h"
    6767#include "PageVisibilityState.h"
    68 #include "RTCDataChannelDescriptor.h"
     68#include "RTCDataChannelHandlerClient.h"
    6969#include "RTCPeerConnectionHandlerClient.h"
    7070#include "ReferrerPolicy.h"
     
    119119#include <public/WebFilterOperation.h>
    120120#include <public/WebMediaStreamSource.h>
    121 #include <public/WebRTCDataChannel.h>
    122 #include <public/WebRTCPeerConnectionHandler.h>
     121#include <public/WebRTCDataChannelHandlerClient.h>
    123122#include <public/WebRTCPeerConnectionHandlerClient.h>
    124123#include <public/WebReferrerPolicy.h>
     
    587586COMPILE_ASSERT_MATCHING_ENUM(WebRTCPeerConnectionHandlerClient::ICEStateWaiting, RTCPeerConnectionHandlerClient::IceStateWaiting);
    588587
    589 COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannel::ReadyStateConnecting, RTCDataChannelDescriptor::ReadyStateConnecting);
    590 COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannel::ReadyStateOpen, RTCDataChannelDescriptor::ReadyStateOpen);
    591 COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannel::ReadyStateClosing, RTCDataChannelDescriptor::ReadyStateClosing);
    592 COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannel::ReadyStateClosed, RTCDataChannelDescriptor::ReadyStateClosed);
     588COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannelHandlerClient::ReadyStateConnecting, RTCDataChannelHandlerClient::ReadyStateConnecting);
     589COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannelHandlerClient::ReadyStateOpen, RTCDataChannelHandlerClient::ReadyStateOpen);
     590COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannelHandlerClient::ReadyStateClosing, RTCDataChannelHandlerClient::ReadyStateClosing);
     591COMPILE_ASSERT_MATCHING_ENUM(WebRTCDataChannelHandlerClient::ReadyStateClosed, RTCDataChannelHandlerClient::ReadyStateClosed);
    593592#endif
    594593
  • trunk/Tools/ChangeLog

    r137439 r137441  
     12012-12-12  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Change the data channel descriptor pattern to a handler pattern
     4        https://bugs.webkit.org/show_bug.cgi?id=104543
     5
     6        Reviewed by Kent Tamura.
     7
     8        Adding mocks to be able to test this refactoring.
     9
     10        * DumpRenderTree/DumpRenderTree.gypi:
     11        * DumpRenderTree/chromium/MockWebRTCDataChannelHandler.cpp: Added.
     12        (DataChannelReadyStateTask):
     13        (DataChannelReadyStateTask::DataChannelReadyStateTask):
     14        (MockWebRTCDataChannelHandler::MockWebRTCDataChannelHandler):
     15        (MockWebRTCDataChannelHandler::setClient):
     16        (MockWebRTCDataChannelHandler::bufferedAmount):
     17        (MockWebRTCDataChannelHandler::sendStringData):
     18        (MockWebRTCDataChannelHandler::sendRawData):
     19        (MockWebRTCDataChannelHandler::close):
     20        * DumpRenderTree/chromium/MockWebRTCDataChannelHandler.h: Added.
     21        (MockWebRTCDataChannelHandler):
     22        (MockWebRTCDataChannelHandler::taskList):
     23        * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp:
     24        (RTCPeerConnectionReadyStateTask::RTCPeerConnectionReadyStateTask):
     25        (RemoteDataChannelTask::RemoteDataChannelTask):
     26        (MockWebRTCPeerConnectionHandler::createDataChannel):
     27        (MockWebRTCPeerConnectionHandler::stop):
     28        * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.h:
     29        (MockWebRTCPeerConnectionHandler):
     30
    1312012-12-12  Jochen Eisinger  <jochen@chromium.org>
    232
  • trunk/Tools/DumpRenderTree/DumpRenderTree.gypi

    r137256 r137441  
    2525            'chromium/MockWebRTCPeerConnectionHandler.cpp',
    2626            'chromium/MockWebRTCPeerConnectionHandler.h',
     27            'chromium/MockWebRTCDataChannelHandler.cpp',
     28            'chromium/MockWebRTCDataChannelHandler.h',
    2729            'chromium/MockWebSpeechInputController.cpp',
    2830            'chromium/MockWebSpeechInputController.h',
  • trunk/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp

    r134970 r137441  
    3535
    3636#include "MockConstraints.h"
     37#include "MockWebRTCDataChannelHandler.h"
    3738#include "Task.h"
    3839#include <public/WebMediaConstraints.h>
     
    129130};
    130131
    131 class StringDataTask : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
    132 public:
    133     StringDataTask(MockWebRTCPeerConnectionHandler* object, const WebRTCDataChannel& dataChannel, const WebString& data)
    134         : WebMethodTask<MockWebRTCPeerConnectionHandler>(object)
    135         , m_dataChannel(dataChannel)
    136         , m_data(data)
    137     {
    138     }
    139 
    140     virtual void runIfValid() OVERRIDE
    141     {
    142         m_dataChannel.dataArrived(m_data);
    143     }
    144 
    145 private:
    146     WebRTCDataChannel m_dataChannel;
    147     WebString m_data;
    148 };
    149 
    150 class CharPtrDataTask : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
    151 public:
    152     CharPtrDataTask(MockWebRTCPeerConnectionHandler* object, const WebRTCDataChannel& dataChannel, const char* data, size_t length)
    153         : WebMethodTask<MockWebRTCPeerConnectionHandler>(object)
    154         , m_dataChannel(dataChannel)
    155         , m_length(length)
    156     {
    157         m_data = new char[m_length];
    158         memcpy(m_data, data, m_length);
    159     }
    160 
    161     virtual void runIfValid() OVERRIDE
    162     {
    163         m_dataChannel.dataArrived(m_data, m_length);
    164         delete [] m_data;
    165     }
    166 
    167 private:
    168     WebRTCDataChannel m_dataChannel;
    169     char* m_data;
    170     size_t m_length;
    171 };
    172 
    173 class DataChannelReadyStateTask : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
    174 public:
    175     DataChannelReadyStateTask(MockWebRTCPeerConnectionHandler* object, const WebRTCDataChannel& dataChannel, WebRTCDataChannel::ReadyState state)
    176         : WebMethodTask<MockWebRTCPeerConnectionHandler>(object)
    177         , m_dataChannel(dataChannel)
    178         , m_state(state)
    179     {
    180     }
    181 
    182     virtual void runIfValid() OVERRIDE
    183     {
    184         m_dataChannel.readyStateChanged(m_state);
    185     }
    186 
    187 private:
    188     WebRTCDataChannel m_dataChannel;
    189     WebRTCDataChannel::ReadyState m_state;
    190 };
    191 
    192132class RTCPeerConnectionReadyStateTask : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
    193133public:
     
    207147    WebRTCPeerConnectionHandlerClient* m_client;
    208148    WebRTCPeerConnectionHandlerClient::ReadyState m_state;
     149};
     150
     151class RemoteDataChannelTask : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
     152public:
     153    RemoteDataChannelTask(MockWebRTCPeerConnectionHandler* object, WebRTCPeerConnectionHandlerClient* client)
     154        : WebMethodTask<MockWebRTCPeerConnectionHandler>(object)
     155        , m_client(client)
     156    {
     157    }
     158
     159    virtual void runIfValid() OVERRIDE
     160    {
     161        WebRTCDataChannelHandler* remoteDataChannel = new MockWebRTCDataChannelHandler("MockRemoteDataChannel", true);
     162        m_client->didAddRemoteDataChannel(remoteDataChannel);
     163    }
     164
     165private:
     166    WebRTCPeerConnectionHandlerClient* m_client;
    209167};
    210168
     
    328286}
    329287
     288WebRTCDataChannelHandler* MockWebRTCPeerConnectionHandler::createDataChannel(const WebString& label, bool reliable)
     289{
     290    postTask(new RemoteDataChannelTask(this, m_client));
     291
     292    return new MockWebRTCDataChannelHandler(label, reliable);
     293}
     294
    330295void MockWebRTCPeerConnectionHandler::stop()
    331296{
     
    333298}
    334299
    335 bool MockWebRTCPeerConnectionHandler::openDataChannel(const WebRTCDataChannel& dataChannel)
    336 {
    337     if (m_stopped)
    338         return false;
    339 
    340     WebRTCDataChannel remoteDataChannel;
    341     remoteDataChannel.initialize("MockRemoteDataChannel", dataChannel.reliable());
    342     remoteDataChannel.readyStateChanged(WebRTCDataChannel::ReadyStateOpen);
    343     m_client->didAddRemoteDataChannel(remoteDataChannel);
    344 
    345     postTask(new DataChannelReadyStateTask(this, dataChannel, WebRTCDataChannel::ReadyStateOpen));
    346     return true;
    347 }
    348 
    349 void MockWebRTCPeerConnectionHandler::closeDataChannel(const WebRTCDataChannel& dataChannel)
    350 {
    351     postTask(new DataChannelReadyStateTask(this, dataChannel, WebRTCDataChannel::ReadyStateClosed));
    352 }
    353 
    354 bool MockWebRTCPeerConnectionHandler::sendStringData(const WebRTCDataChannel& dataChannel, const WebString& data)
    355 {
    356     if (m_stopped)
    357         return false;
    358 
    359     dataChannel.dataArrived(data);
    360     return true;
    361 }
    362 
    363 bool MockWebRTCPeerConnectionHandler::sendRawData(const WebRTCDataChannel& dataChannel, const char* data, size_t length)
    364 {
    365     if (m_stopped)
    366         return false;
    367 
    368     dataChannel.dataArrived(data, length);
    369     return true;
    370 }
    371 
    372300#endif // ENABLE(MEDIA_STREAM)
  • trunk/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.h

    r132138 r137441  
    3535
    3636#include "WebTask.h"
    37 #include <public/WebRTCDataChannel.h>
    3837#include <public/WebRTCPeerConnectionHandler.h>
    3938#include <public/WebRTCSessionDescription.h>
     
    6261    virtual void removeStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
    6362    virtual void getStats(const WebKit::WebRTCStatsRequest&) OVERRIDE;
     63    virtual WebKit::WebRTCDataChannelHandler* createDataChannel(const WebKit::WebString& label, bool reliable) OVERRIDE;
    6464    virtual void stop() OVERRIDE;
    65 
    66     virtual bool openDataChannel(const WebKit::WebRTCDataChannel&) OVERRIDE;
    67     virtual bool sendStringData(const WebKit::WebRTCDataChannel&, const WebKit::WebString&) OVERRIDE;
    68     virtual bool sendRawData(const WebKit::WebRTCDataChannel&, const char*, size_t) OVERRIDE;
    69     virtual void closeDataChannel(const WebKit::WebRTCDataChannel&) OVERRIDE;
    7065
    7166    // WebTask related methods
Note: See TracChangeset for help on using the changeset viewer.