Changeset 130270 in webkit


Ignore:
Timestamp:
Oct 3, 2012 2:52:19 AM (11 years ago)
Author:
tommyw@google.com
Message:

MediaStream API: RTCPeerConnection should send down its handler via the FrameLoaderClient directly after creation.
https://bugs.webkit.org/show_bug.cgi?id=98149

Reviewed by Adam Barth.

Source/WebCore:

The chromium implementation needs to know which Frame created a PeerConnection so
that the right housekeeping can take place correctly.

Not testable in DRT, but have verified the change manually and with our pyautotests.

  • Modules/mediastream/RTCPeerConnection.cpp:

(WebCore::RTCPeerConnection::RTCPeerConnection):

  • loader/FrameLoaderClient.h:

(WebCore):
(FrameLoaderClient):
(WebCore::FrameLoaderClient::dispatchWillStartUsingPeerConnectionHandler):

  • platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp:

(WebCore::RTCPeerConnectionHandlerChromium::toWebRTCPeerConnectionHandler):
(WebCore):
(WebCore::RTCPeerConnectionHandlerChromium::RTCPeerConnectionHandlerChromium):
(WebCore::RTCPeerConnectionHandlerChromium::initialize):

  • platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h:

(RTCPeerConnectionHandlerChromium):

Source/WebKit/chromium:

Adding willStartUsingPeerConnectionHandler to the WebFrameClient.

  • public/WebFrameClient.h:

(WebKit):
(WebFrameClient):
(WebKit::WebFrameClient::willStartUsingPeerConnectionHandler):

  • src/FrameLoaderClientImpl.cpp:

(WebKit):
(WebKit::FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler):

  • src/FrameLoaderClientImpl.h:

(FrameLoaderClientImpl):

Location:
trunk/Source
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r130269 r130270  
     12012-10-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: RTCPeerConnection should send down its handler via the FrameLoaderClient directly after creation.
     4        https://bugs.webkit.org/show_bug.cgi?id=98149
     5
     6        Reviewed by Adam Barth.
     7
     8        The chromium implementation needs to know which Frame created a PeerConnection so
     9        that the right housekeeping can take place correctly.
     10
     11        Not testable in DRT, but have verified the change manually and with our pyautotests.
     12
     13        * Modules/mediastream/RTCPeerConnection.cpp:
     14        (WebCore::RTCPeerConnection::RTCPeerConnection):
     15        * loader/FrameLoaderClient.h:
     16        (WebCore):
     17        (FrameLoaderClient):
     18        (WebCore::FrameLoaderClient::dispatchWillStartUsingPeerConnectionHandler):
     19        * platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp:
     20        (WebCore::RTCPeerConnectionHandlerChromium::toWebRTCPeerConnectionHandler):
     21        (WebCore):
     22        (WebCore::RTCPeerConnectionHandlerChromium::RTCPeerConnectionHandlerChromium):
     23        (WebCore::RTCPeerConnectionHandlerChromium::initialize):
     24        * platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h:
     25        (RTCPeerConnectionHandlerChromium):
     26
    1272012-10-03  Eugene Klyuchnikov  <eustas.bug@gmail.com>
    228
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r129908 r130270  
    3636
    3737#include "ArrayValue.h"
     38#include "Document.h"
    3839#include "Event.h"
    3940#include "ExceptionCode.h"
     41#include "Frame.h"
     42#include "FrameLoaderClient.h"
    4043#include "MediaConstraintsImpl.h"
    4144#include "MediaStreamEvent.h"
     
    131134    , m_remoteStreams(MediaStreamList::create())
    132135{
     136    ASSERT(m_scriptExecutionContext->isDocument());
     137    Document* document = static_cast<Document*>(m_scriptExecutionContext);
     138
     139    if (!document->frame()) {
     140        ec = NOT_SUPPORTED_ERR;
     141        return;
     142    }
     143
    133144    m_peerHandler = RTCPeerConnectionHandler::create(this);
    134     if (!m_peerHandler || !m_peerHandler->initialize(configuration, constraints))
     145    if (!m_peerHandler) {
    135146        ec = NOT_SUPPORTED_ERR;
     147        return;
     148    }
     149
     150    document->frame()->loader()->client()->dispatchWillStartUsingPeerConnectionHandler(m_peerHandler.get());
     151
     152    if (!m_peerHandler->initialize(configuration, constraints)) {
     153        ec = NOT_SUPPORTED_ERR;
     154        return;
     155    }
    136156}
    137157
  • trunk/Source/WebCore/loader/FrameLoaderClient.h

    r129964 r130270  
    9797    class ResourceRequest;
    9898    class ResourceResponse;
     99#if ENABLE(MEDIA_STREAM)
     100    class RTCPeerConnectionHandler;
     101#endif
    99102    class SecurityOrigin;
    100103    class SharedBuffer;
     
    342345        virtual void dispatchDidReconnectDOMWindowExtensionToGlobalObject(DOMWindowExtension*) { }
    343346        virtual void dispatchWillDestroyGlobalObjectForDOMWindowExtension(DOMWindowExtension*) { }
     347
     348#if ENABLE(MEDIA_STREAM)
     349        virtual void dispatchWillStartUsingPeerConnectionHandler(RTCPeerConnectionHandler*) { }
     350#endif
    344351    };
    345352
  • trunk/Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.cpp

    r129908 r130270  
    5656namespace WebCore {
    5757
     58WebKit::WebRTCPeerConnectionHandler* RTCPeerConnectionHandlerChromium::toWebRTCPeerConnectionHandler(RTCPeerConnectionHandler* handler)
     59{
     60    return static_cast<RTCPeerConnectionHandlerChromium*>(handler)->m_webHandler.get();
     61}
     62
    5863PassOwnPtr<RTCPeerConnectionHandler> RTCPeerConnectionHandler::create(RTCPeerConnectionHandlerClient* client)
    5964{
     
    6570{
    6671    ASSERT(m_client);
     72    m_webHandler = adoptPtr(WebKit::Platform::current()->createRTCPeerConnectionHandler(this));
    6773}
    6874
     
    7379bool RTCPeerConnectionHandlerChromium::initialize(PassRefPtr<RTCConfiguration> configuration, PassRefPtr<MediaConstraints> constraints)
    7480{
    75     m_webHandler = adoptPtr(WebKit::Platform::current()->createRTCPeerConnectionHandler(this));
    76     return m_webHandler ? m_webHandler->initialize(configuration, constraints) : false;
     81    if (!m_webHandler)
     82        return false;
     83
     84    return m_webHandler->initialize(configuration, constraints);
    7785}
    7886
  • trunk/Source/WebCore/platform/mediastream/chromium/RTCPeerConnectionHandlerChromium.h

    r129908 r130270  
    5050class RTCPeerConnectionHandlerChromium : public RTCPeerConnectionHandler, public WebKit::WebRTCPeerConnectionHandlerClient {
    5151public:
    52     RTCPeerConnectionHandlerChromium(RTCPeerConnectionHandlerClient*);
     52    explicit RTCPeerConnectionHandlerChromium(RTCPeerConnectionHandlerClient*);
    5353    virtual ~RTCPeerConnectionHandlerChromium();
    5454
     
    7676    virtual void didRemoveRemoteStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE;
    7777
     78    static WebKit::WebRTCPeerConnectionHandler* toWebRTCPeerConnectionHandler(RTCPeerConnectionHandler*);
     79
    7880private:
    7981    OwnPtr<WebKit::WebRTCPeerConnectionHandler> m_webHandler;
  • trunk/Source/WebKit/chromium/ChangeLog

    r130268 r130270  
     12012-10-03  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: RTCPeerConnection should send down its handler via the FrameLoaderClient directly after creation.
     4        https://bugs.webkit.org/show_bug.cgi?id=98149
     5
     6        Reviewed by Adam Barth.
     7
     8        Adding willStartUsingPeerConnectionHandler to the WebFrameClient.
     9
     10        * public/WebFrameClient.h:
     11        (WebKit):
     12        (WebFrameClient):
     13        (WebKit::WebFrameClient::willStartUsingPeerConnectionHandler):
     14        * src/FrameLoaderClientImpl.cpp:
     15        (WebKit):
     16        (WebKit::FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler):
     17        * src/FrameLoaderClientImpl.h:
     18        (FrameLoaderClientImpl):
     19
    1202012-10-03  Peter Kotwicz  <pkotwicz@google.com>
    221
  • trunk/Source/WebKit/chromium/public/WebFrameClient.h

    r129846 r130270  
    6363class WebNode;
    6464class WebPlugin;
     65class WebRTCPeerConnectionHandler;
    6566class WebSharedWorker;
    6667class WebSharedWorkerClient;
     
    399400    virtual void willOpenSocketStream(WebSocketStreamHandle*) { }
    400401
     402    // MediaStream -----------------------------------------------------
     403
     404    // A new WebRTCPeerConnectionHandler is created.
     405    virtual void willStartUsingPeerConnectionHandler(WebFrame*, WebRTCPeerConnectionHandler*) { }
     406
    401407    // Messages ------------------------------------------------------
    402408
  • trunk/Source/WebKit/chromium/src/FrameLoaderClientImpl.cpp

    r129947 r130270  
    5858#include "ResourceHandleInternal.h"
    5959#include "ResourceLoader.h"
     60#if ENABLE(MEDIA_STREAM)
     61#include "RTCPeerConnectionHandlerChromium.h"
     62#endif
    6063#include "Settings.h"
    6164#include "SocketStreamHandleInternal.h"
     
    16391642}
    16401643
     1644#if ENABLE(MEDIA_STREAM)
     1645void FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler(RTCPeerConnectionHandler* handler)
     1646{
     1647    m_webFrame->client()->willStartUsingPeerConnectionHandler(webFrame(), RTCPeerConnectionHandlerChromium::toWebRTCPeerConnectionHandler(handler));
     1648}
     1649#endif
     1650
     1651
    16411652} // namespace WebKit
  • trunk/Source/WebKit/chromium/src/FrameLoaderClientImpl.h

    r129545 r130270  
    221221    virtual void dispatchWillOpenSocketStream(WebCore::SocketStreamHandle*) OVERRIDE;
    222222
     223#if ENABLE(MEDIA_STREAM)
     224    virtual void dispatchWillStartUsingPeerConnectionHandler(WebCore::RTCPeerConnectionHandler*) OVERRIDE;
     225#endif
     226
    223227private:
    224228    void makeDocumentView();
Note: See TracChangeset for help on using the changeset viewer.