ChangeLog

2011-05-31  Tommy Widenflycht  <tommyw@google.com>

        Reviewed by NOBODY (OOPS!).

        Media Stream API: integrate the Track List objects into the existing code.

        https://bugs.webkit.org/show_bug.cgi?id=60205

        Tests for the Media Stream API will be provided by the bug 56587.

        * dom/ExclusiveTrackList.cpp:

        (WebCore::ExclusiveTrackList::select):

        (WebCore::ExclusiveTrackList::trackFailed):

        * dom/ExclusiveTrackList.h:

        * dom/GeneratedStream.cpp:

        (WebCore::GeneratedStream::create):

        (WebCore::GeneratedStream::GeneratedStream):

        (WebCore::GeneratedStream::streamEnded):

        (WebCore::GeneratedStream::audioTracks):

        (WebCore::GeneratedStream::videoTracks):

        (WebCore::GeneratedStream::stop):

        * dom/GeneratedStream.h:

        * dom/GeneratedStream.idl:

        * dom/MultipleTrackList.cpp:

        (WebCore::MultipleTrackList::trackFailed):

        (WebCore::MultipleTrackList::enable):

        (WebCore::MultipleTrackList::disable):

        * dom/MultipleTrackList.h:

        * dom/Stream.h:

        * dom/TrackList.cpp:

        (WebCore::TrackList::clear):

        (WebCore::TrackList::associateStream):

        (WebCore::TrackList::associatedStreamLabel):

        (WebCore::TrackList::trackFailed):

        (WebCore::TrackList::scriptExecutionContext):

        * dom/TrackList.h:

        * page/MediaStreamClient.h:

        * page/MediaStreamController.cpp:

        (WebCore::MediaStreamController::enableAudioTrack):

        (WebCore::MediaStreamController::disableAudioTrack):

        (WebCore::MediaStreamController::selectVideoTrack):

        (WebCore::MediaStreamController::streamGenerated):

        (WebCore::MediaStreamController::audioTrackFailed):

        (WebCore::MediaStreamController::videoTrackFailed):

        * page/MediaStreamController.h:

        * page/MediaStreamFrameController.cpp:

        (WebCore::MediaStreamFrameController::unregister):

        (WebCore::MediaStreamFrameController::enterDetachedState):

        (WebCore::MediaStreamFrameController::disconnectFrame):

        (WebCore::MediaStreamFrameController::enableAudioTrack):

        (WebCore::MediaStreamFrameController::disableAudioTrack):

        (WebCore::MediaStreamFrameController::selectVideoTrack):

        (WebCore::MediaStreamFrameController::streamGenerated):

        (WebCore::MediaStreamFrameController::audioTrackFailed):

        (WebCore::MediaStreamFrameController::videoTrackFailed):

        * page/MediaStreamFrameController.h:

        (WebCore::MediaStreamFrameController::ClientBase::isGenericClient):

        (WebCore::MediaStreamFrameController::GenericClient::GenericClient):

        (WebCore::MediaStreamFrameController::GenericClient::~GenericClient):

        (WebCore::MediaStreamFrameController::GenericClient::isGenericClient):

        (WebCore::MediaStreamFrameController::GenericClient::unregister):

2011-05-31  Oliver Varga  <Varga.Oliver@stud.u-szeged.hu>

        Reviewed by Nikolas Zimmermann.

Source/WebCore/dom/ExclusiveTrackList.cpp

@@void ExclusiveTrackList::select(long index, ExceptionCode& ec)

        return;

    m_selectedIndex = index;

#if ENABLE(MEDIA_STREAM)

    if (mediaStreamFrameController())

        mediaStreamFrameController()->selectVideoTrack(associatedStreamLabel(), index);

#endif

    postChangeEvent();

}

#if ENABLE(MEDIA_STREAM)

void ExclusiveTrackList::trackFailed(unsigned long index)

{

    if (m_selectedIndex == static_cast<long>(index))

        m_selectedIndex = NoSelection;

    TrackList::trackFailed(index);

}

#endif

ExclusiveTrackList* ExclusiveTrackList::toExclusiveTrackList()

{

    return this;

Source/WebCore/dom/ExclusiveTrackList.h

@@public:

    virtual void clear();

#if ENABLE(MEDIA_STREAM)

    virtual void trackFailed(unsigned long index);

#endif

    // EventTarget implementation.

    virtual ExclusiveTrackList* toExclusiveTrackList();

Source/WebCore/dom/GeneratedStream.cpp

#include "Event.h"

#include "EventNames.h"

32#include "ExclusiveTrackList.h"

3233#include "MediaStreamFrameController.h"

34#include "MultipleTrackList.h"

#include "ScriptExecutionContext.h"

namespace WebCore {

@@public:

    Callback m_callback;

};

60 PassRefPtr<GeneratedStream> GeneratedStream::create(MediaStreamFrameController* frameController, const String& label)

62PassRefPtr<GeneratedStream> GeneratedStream::create(MediaStreamFrameController* frameController, const String& label, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks)

6163{

62 return adoptRef(new GeneratedStream(frameController, label));

64 return adoptRef(new GeneratedStream(frameController, label, audioTracks, videoTracks));

6365}

6466

65 GeneratedStream::GeneratedStream(MediaStreamFrameController* frameController, const String& label)

67GeneratedStream::GeneratedStream(MediaStreamFrameController* frameController, const String& label, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks)

6668 : Stream(frameController, label, true)

69 , m_audioTracks(audioTracks)

70 , m_videoTracks(videoTracks)

6771{

    ASSERT(m_audioTracks);

    ASSERT(m_videoTracks);

    m_audioTracks->associateStream(label);

    m_videoTracks->associateStream(label);

}

GeneratedStream::~GeneratedStream()

@@void GeneratedStream::detachEmbedder()

    Stream::detachEmbedder();

}

void GeneratedStream::streamEnded()

{

    m_audioTracks->clear();

    m_videoTracks->clear();

    Stream::streamEnded();

}

PassRefPtr<MultipleTrackList> GeneratedStream::audioTracks() const

{

    return m_audioTracks;

}

PassRefPtr<ExclusiveTrackList> GeneratedStream::videoTracks() const

{

    return m_videoTracks;

}

void GeneratedStream::stop()

{

    if (!mediaStreamFrameController() || m_readyState == ENDED)

        return;

    mediaStreamFrameController()->stopGeneratedStream(label());

119 m_audioTracks->clear();

120 m_videoTracks->clear();

    m_readyState = ENDED;

Source/WebCore/dom/GeneratedStream.h

namespace WebCore {

class ExclusiveTrackList;

class MultipleTrackList;

3538class GeneratedStream : public Stream {

3639public:

37 // FIXME: add audio and video tracks when available.

38 static PassRefPtr<GeneratedStream> create(MediaStreamFrameController*, const String& label);

40 static PassRefPtr<GeneratedStream> create(MediaStreamFrameController*, const String& label, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks);

    virtual ~GeneratedStream();

    void stop();

    PassRefPtr<MultipleTrackList> audioTracks() const;

    PassRefPtr<ExclusiveTrackList> videoTracks() const;

4348 // MediaStreamFrameController::StreamClient implementation.

4449 virtual void detachEmbedder();

50 virtual void streamEnded();

    // EventTarget.

    virtual GeneratedStream* toGeneratedStream();

private:

50 GeneratedStream(MediaStreamFrameController*, const String& label);

56 GeneratedStream(MediaStreamFrameController*, const String& label, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks);

    class DispatchUpdateTask;

    friend class DispatchUpdateTask;

    void onStop();

    RefPtr<MultipleTrackList> m_audioTracks;

    RefPtr<ExclusiveTrackList> m_videoTracks;

};

} // namespace WebCore

Source/WebCore/dom/GeneratedStream.idl

@@module core {

    ] GeneratedStream : Stream {

        void stop();

33 // FIXME: implement audio and video tracks when available.

        // Track control.

        readonly attribute MultipleTrackList audioTracks;

        readonly attribute ExclusiveTrackList videoTracks;

    };

}

Source/WebCore/dom/MultipleTrackList.cpp

@@void MultipleTrackList::clear()

    TrackList::clear();

}

#if ENABLE(MEDIA_STREAM)

void MultipleTrackList::trackFailed(unsigned long index)

{

    TrackList::trackFailed(index);

    m_isEnabled.remove(index);

}

#endif

bool MultipleTrackList::isEnabled(unsigned long index, ExceptionCode& ec) const

{

    return checkIndex(index, ec) ? m_isEnabled[index] : false;

@@void MultipleTrackList::enable(unsigned long index, ExceptionCode& ec)

        return;

    m_isEnabled[index] = true;

#if ENABLE(MEDIA_STREAM)

    if (mediaStreamFrameController())

        mediaStreamFrameController()->enableAudioTrack(associatedStreamLabel(), index);

#endif

    postChangeEvent();

}

@@void MultipleTrackList::disable(unsigned long index, ExceptionCode& ec)

        return;

    m_isEnabled[index] = false;

#if ENABLE(MEDIA_STREAM)

    if (mediaStreamFrameController())

        mediaStreamFrameController()->disableAudioTrack(associatedStreamLabel(), index);

#endif

    postChangeEvent();

}

Source/WebCore/dom/MultipleTrackList.h

@@public:

    virtual void clear();

#if ENABLE(MEDIA_STREAM)

    virtual void trackFailed(unsigned long index);

#endif

    // EventTarget implementation.

    virtual MultipleTrackList* toMultipleTrackList();

Source/WebCore/dom/Stream.h

@@public:

    // FIXME: implement the record method when StreamRecorder is available.

55 DEFINE_ATTRIBUTE_EVENT_LISTENER(readystatechange);

    DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);

    unsigned short readyState() const { return m_readyState; }

Source/WebCore/dom/TrackList.cpp

@@const String& TrackList::getLanguage(unsigned long index, ExceptionCode& ec) con

void TrackList::clear()

{

#if ENABLE(MEDIA_STREAM)

    m_associatedStreamLabel = String();

#endif

    if (m_tracks.isEmpty())

        return;

106113 m_tracks.clear();

114

    postChangeEvent();

}

@@void TrackList::dispatchChangeEvent(int)

    dispatchEvent(Event::create(eventNames().changeEvent, false, false));

}

#if ENABLE(MEDIA_STREAM)

void TrackList::associateStream(const String& label)

{

    ASSERT(m_associatedStreamLabel.isNull());

    m_associatedStreamLabel = label;

}

const String& TrackList::associatedStreamLabel() const

{

    return m_associatedStreamLabel;

}

void TrackList::trackFailed(unsigned long index)

{

    ASSERT(index < length());

    m_tracks.remove(index);

    postChangeEvent();

}

#endif

TrackList* TrackList::toTrackList()

{

    return this;

@@TrackList* TrackList::toTrackList()

ScriptExecutionContext* TrackList::scriptExecutionContext() const

{

133 // FIXME: provide an script execution context for HTML Media Element and MediaStream API use cases.

134 // For the MediaStream API: https://bugs.webkit.org/show_bug.cgi?id=60205

#if ENABLE(MEDIA_STREAM)

    if (mediaStreamFrameController())

        return mediaStreamFrameController()->scriptExecutionContext();

#endif

    // FIXME: provide an script execution context for HTML Media Element use case.

    // For the HTML Media Element: https://bugs.webkit.org/show_bug.cgi?id=61127

    return 0;

}

Source/WebCore/dom/TrackList.h

@@private:

typedef Vector<RefPtr<Track> > TrackVector;

class TrackList : public RefCounted<TrackList>,

#if ENABLE(MEDIA_STREAM)

                  public MediaStreamFrameController::GenericClient,

#endif

                  public EventTarget {

public:

    static PassRefPtr<TrackList> create(const TrackVector&);

@@public:

    virtual void clear();

#if ENABLE(MEDIA_STREAM)

    void associateStream(const String& streamLabel);

    const String& associatedStreamLabel() const;

    virtual void trackFailed(unsigned long index);

#endif

    // EventTarget implementation.

    virtual TrackList* toTrackList();

    virtual ScriptExecutionContext* scriptExecutionContext() const;

@@private:

    EventTargetData m_eventTargetData;

    TrackVector m_tracks;

#if ENABLE(MEDIA_STREAM)

    String m_associatedStreamLabel;

#endif

};

} // namespace WebCore

Source/WebCore/page/MediaStreamClient.h

@@public:

    // Stop a generated stream.

    virtual void stopGeneratedStream(const String& streamLabel) = 0;

    // Enable/disable an audio track in a generated stream.

    virtual void enableAudioTrack(const String& streamLabel, unsigned long index) = 0;

    virtual void disableAudioTrack(const String& streamLabel, unsigned long index) = 0;

    // Select a video track in a generated stream.

    virtual void selectVideoTrack(const String& streamLabel, long index) = 0;

protected:

    virtual ~MediaStreamClient() { }

};

Source/WebCore/page/MediaStreamController.cpp

#if ENABLE(MEDIA_STREAM)

30#include "ExclusiveTrackList.h"

3031#include "MediaStreamFrameController.h"

32#include "MultipleTrackList.h"

#include "SecurityOrigin.h"

#include <wtf/Vector.h>

@@void MediaStreamController::stopGeneratedStream(const String& streamLabel)

    m_client->stopGeneratedStream(streamLabel);

}

120 void MediaStreamController::streamGenerated(int controllerRequestId, const String& streamLabel)

void MediaStreamController::enableAudioTrack(const String& streamLabel, unsigned long index)

{

    m_client->enableAudioTrack(streamLabel, index);

}

void MediaStreamController::disableAudioTrack(const String& streamLabel, unsigned long index)

{

    m_client->disableAudioTrack(streamLabel, index);

}

void MediaStreamController::selectVideoTrack(const String& streamLabel, long index)

{

    m_client->selectVideoTrack(streamLabel, index);

}

void MediaStreamController::streamGenerated(int controllerRequestId, const String& streamLabel, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks)

{

    // Don't assert since the frame controller can have been destroyed while the request reply was coming back.

    if (m_requests.contains(controllerRequestId)) {

@@void MediaStreamController::streamGenerated(int controllerRequestId, const Strin

        registerStream(streamLabel, request.frameController());

        m_requests.remove(controllerRequestId);

        ASSERT(request.frameController());

128 request.frameController()->streamGenerated(request.localId(), streamLabel);

145 request.frameController()->streamGenerated(request.localId(), streamLabel, audioTracks, videoTracks);

    }

}

@@void MediaStreamController::streamFailed(const String& streamLabel)

        m_streams.get(streamLabel)->streamFailed(streamLabel);

}

void MediaStreamController::audioTrackFailed(const String& streamLabel, unsigned long index)

{

    // Don't assert since the frame controller can have been destroyed by the time this is called.

    if (m_streams.contains(streamLabel))

        m_streams.get(streamLabel)->audioTrackFailed(streamLabel, index);

}

void MediaStreamController::videoTrackFailed(const String& streamLabel, unsigned long index)

{

    // Don't assert since the frame controller can have been destroyed by the time this is called.

    if (m_streams.contains(streamLabel))

        m_streams.get(streamLabel)->videoTrackFailed(streamLabel, index);

}

} // namespace WebCore

#endif // ENABLE(MEDIA_STREAM)

Source/WebCore/page/MediaStreamController.h

namespace WebCore {

39class ExclusiveTrackList;

3940class MediaStreamClient;

4041class MediaStreamFrameController;

42class MultipleTrackList;

class SecurityOrigin;

class MediaStreamController {

@@public:

    void generateStream(MediaStreamFrameController*, int requestId, GenerateStreamOptionFlags, PassRefPtr<SecurityOrigin>);

    void stopGeneratedStream(const String& streamLabel);

    void enableAudioTrack(const String& streamLabel, unsigned long index);

    void disableAudioTrack(const String& streamLabel, unsigned long index);

    void selectVideoTrack(const String& streamLabel, long index);

5459

55 void streamGenerated(int requestId, const String& streamLabel);

60 void streamGenerated(int requestId, const String& streamLabel, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks);

5661 void streamGenerationFailed(int requestId, NavigatorUserMediaError::ErrorCode);

5762 void streamFailed(const String& streamLabel);

63 void audioTrackFailed(const String& streamLabel, unsigned long index);

64 void videoTrackFailed(const String& streamLabel, unsigned long index);

private:

    int registerRequest(int localRequestId, MediaStreamFrameController*);

Source/WebCore/page/MediaStreamFrameController.cpp

#include "DOMWindow.h"

#include "Document.h"

32#include "ExclusiveTrackList.h"

#include "Frame.h"

#include "GeneratedStream.h"

#include "MediaStreamController.h"

36#include "MultipleTrackList.h"

#include "NavigatorUserMediaErrorCallback.h"

#include "NavigatorUserMediaSuccessCallback.h"

#include "Page.h"

@@void MediaStreamFrameController::unregister(StreamClient* client)

    m_streams.remove(client->clientId());

}

void MediaStreamFrameController::unregister(GenericClient* client)

{

    ASSERT(m_clients.contains(client->clientId()));

    m_clients.remove(client->clientId());

}

Stream* MediaStreamFrameController::getStreamFromLabel(const String& label) const

{

    ASSERT(m_streams.contains(label));

@@void MediaStreamFrameController::enterDetachedState()

    m_requests.abortAll();

    m_streams.detachEmbedder();

199 m_clients.detachEmbedder();

    m_isInDetachedState = true;

}

@@void MediaStreamFrameController::disconnectFrame()

    ASSERT(m_requests.isEmpty());

    m_streams.unregisterAll();

228 m_clients.unregisterAll();

    m_frame = 0;

}

@@void MediaStreamFrameController::stopGeneratedStream(const String& streamLabel)

        pageController()->stopGeneratedStream(streamLabel);

}

300 void MediaStreamFrameController::streamGenerated(int requestId, const String& label)

void MediaStreamFrameController::enableAudioTrack(const String& streamLabel, unsigned long index)

{

    // Don't assert since the audio tracks don't necessarily keep alive their associated generated stream object.

    if (!m_streams.contains(streamLabel))

        return;

    if (isClientAvailable())

        pageController()->enableAudioTrack(streamLabel, index);

}

void MediaStreamFrameController::disableAudioTrack(const String& streamLabel, unsigned long index)

{

    // Don't assert since the audio tracks don't necessarily keep alive their associated generated stream object.

    if (!m_streams.contains(streamLabel))

        return;

    if (isClientAvailable())

        pageController()->disableAudioTrack(streamLabel, index);

}

void MediaStreamFrameController::selectVideoTrack(const String& streamLabel, long index)

{

    // Don't assert since the audio tracks don't necessarily keep alive their associated generated stream object.

    if (!m_streams.contains(streamLabel))

        return;

    if (isClientAvailable())

        pageController()->selectVideoTrack(streamLabel, index);

}

void MediaStreamFrameController::streamGenerated(int requestId, const String& label, PassRefPtr<MultipleTrackList> audioTracksParam, PassRefPtr<ExclusiveTrackList> videoTracksParam)

{

    // Don't assert since the request can have been aborted as a result of embedder detachment.

    if (!m_requests.contains(requestId))

@@void MediaStreamFrameController::streamGenerated(int requestId, const String& la

    ASSERT(m_requests.get(requestId)->isGenerateStreamRequest());

    ASSERT(!label.isNull());

    ASSERT(audioTracksParam);

    ASSERT(videoTracksParam);

    RefPtr<MultipleTrackList> audioTracks = audioTracksParam;

    RefPtr<ExclusiveTrackList> videoTracks = videoTracksParam;

    int audioTracksClientId = m_clients.getNextId();

    audioTracks->associateFrameController(this, audioTracksClientId);

    m_clients.add(audioTracksClientId, audioTracks.get());

    int videoTracksClientId = m_clients.getNextId();

    videoTracks->associateFrameController(this, videoTracksClientId);

    m_clients.add(videoTracksClientId, videoTracks.get());

308361

309362 RefPtr<GenerateStreamRequest> streamRequest = static_cast<GenerateStreamRequest*>(m_requests.get(requestId).get());

310 RefPtr<GeneratedStream> generatedStream = GeneratedStream::create(this, label);

363 RefPtr<GeneratedStream> generatedStream = GeneratedStream::create(this, label, audioTracks.release(), videoTracks.release());

    m_streams.add(label, generatedStream.get());

    m_requests.remove(requestId);

    streamRequest->successCallback()->handleEvent(generatedStream.get());

@@void MediaStreamFrameController::streamFailed(const String& label)

    getStreamFromLabel(label)->streamEnded();

}

void MediaStreamFrameController::audioTrackFailed(const String& label, unsigned long index)

{

    Stream* stream = getStreamFromLabel(label);

    ASSERT(stream->isGeneratedStream());

    static_cast<GeneratedStream*>(stream)->audioTracks()->trackFailed(index);

}

void MediaStreamFrameController::videoTrackFailed(const String& label, unsigned long index)

{

    Stream* stream = getStreamFromLabel(label);

    ASSERT(stream->isGeneratedStream());

    static_cast<GeneratedStream*>(stream)->videoTracks()->trackFailed(index);

}

} // namespace WebCore

Source/WebCore/page/MediaStreamFrameController.h

namespace WebCore {

40class ExclusiveTrackList;

class Frame;

class GeneratedStream;

class MediaStreamController;

44class MultipleTrackList;

class NavigatorUserMediaErrorCallback;

class NavigatorUserMediaSuccessCallback;

class Page;

@@public:

        virtual bool isStream() const { return false; }

        virtual bool isGeneratedStream() const { return false; }

72 virtual bool isGenericClient() const { return false; }

        // Called when the frame controller is being disconnected to the MediaStreamClient embedder.

        // Clients should override this to send any required shutdown messages.

@@public:

        bool m_isGeneratedStream;

    };

    // Generic clients are objects that require access to the frame controller but don't have a global id (like streams do)

    // or need to receive any messages from the embedder client.

    class GenericClient : public ClientBase<int> {

    public:

        GenericClient() { }

        GenericClient(MediaStreamFrameController* frameController, int id) : ClientBase<int>(frameController, id) { }

        virtual ~GenericClient() { unregister(); }

        virtual bool isGenericClient() { return true; }

    private:

        virtual void unregister() { unregisterClient(this); }

    };

    MediaStreamFrameController(Frame*);

    virtual ~MediaStreamFrameController();

@@public:

    // Stop a generated stream.

    void stopGeneratedStream(const String& streamLabel);

    // Enable/disable an audio track in a generated stream.

    void enableAudioTrack(const String& streamLabel, unsigned long index);

    void disableAudioTrack(const String& streamLabel, unsigned long index);

    // Select a video track in a generated stream.

    void selectVideoTrack(const String& streamLabel, long index);

    // --- Calls coming back from the controller. --- //

    // Report the generation of a new local stream.

148 void streamGenerated(int requestId, const String& streamLabel);

171 void streamGenerated(int requestId, const String& streamLabel, PassRefPtr<MultipleTrackList> audioTracks, PassRefPtr<ExclusiveTrackList> videoTracks);

    // Report a failure in the generation of a new stream.

    void streamGenerationFailed(int requestId, NavigatorUserMediaError::ErrorCode);

@@public:

    // Report the end of a stream for external reasons.

    void streamFailed(const String& streamLabel);

    // Report the unexpected unavailability of a live media track.

    void audioTrackFailed(const String& streamLabel, unsigned long index);

    void videoTrackFailed(const String& streamLabel, unsigned long index);

private:

    class Request;

    class GenerateStreamRequest;

@@private:

    // Streams are a special class of clients since they are identified by a global label string instead of an id.

    typedef ClientMapBase<String> StreamMap;

    // All other types of clients use autogenerated integer ids.

    class ClientMap : public IdGenerator, public ClientMapBase<int> { };

    // Detached from a page, and hence from a embedder client.

    void enterDetachedState();

    void unregister(StreamClient*);

224 void unregister(GenericClient*);

    MediaStreamController* pageController() const;

    Stream* getStreamFromLabel(const String&) const;

    RequestMap m_requests;

229 ClientMap m_clients;

    StreamMap m_streams;

    Frame* m_frame;