Changeset 105774 in webkit


Ignore:
Timestamp:
Jan 24, 2012 12:29:44 PM (12 years ago)
Author:
tommyw@google.com
Message:

MediaStream API: Split the MediaStream track list into audio/video specific ones.
​https://bugs.webkit.org/show_bug.cgi?id=76614

Source/WebCore:

The latest draft of the WebRTC standard have split the MediaStream combined track list
into audio/video specific ones.

Reviewed by Darin Fisher.

Tests for the Media Stream API will be provided by the bug 56587, pending enough landed code.

  • mediastream/LocalMediaStream.cpp:

(WebCore::LocalMediaStream::create):
(WebCore::LocalMediaStream::LocalMediaStream):

  • mediastream/LocalMediaStream.h:
  • mediastream/MediaStream.cpp:

(WebCore::processTrackList):
(WebCore::MediaStream::create):
(WebCore::MediaStream::MediaStream):

  • mediastream/MediaStream.h:

(WebCore::MediaStream::audioTracks):
(WebCore::MediaStream::videoTracks):

  • mediastream/MediaStream.idl:
  • mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::create):
(WebCore::MediaStreamTrack::MediaStreamTrack):
(WebCore::MediaStreamTrack::kind):
(WebCore::MediaStreamTrack::label):
(WebCore::MediaStreamTrack::enabled):
(WebCore::MediaStreamTrack::setEnabled):
(WebCore::MediaStreamTrack::component):

  • mediastream/MediaStreamTrack.h:
  • mediastream/UserMediaClient.h:
  • mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::mediaStreamSourcesQueryCompleted):
(WebCore::UserMediaRequest::succeed):

  • mediastream/UserMediaRequest.h:
  • platform/mediastream/MediaStreamCenter.cpp:

(WebCore::MediaStreamCenter::queryMediaStreamSources):
(WebCore::MediaStreamCenter::didSetMediaStreamTrackEnabled):

  • platform/mediastream/MediaStreamCenter.h:
  • platform/mediastream/MediaStreamDescriptor.h:

(WebCore::MediaStreamDescriptor::create):
(WebCore::MediaStreamDescriptor::numberOfAudioComponents):
(WebCore::MediaStreamDescriptor::audioComponent):
(WebCore::MediaStreamDescriptor::numberOfVideoComponents):
(WebCore::MediaStreamDescriptor::videoComponent):
(WebCore::MediaStreamDescriptor::MediaStreamDescriptor):

Source/WebKit/chromium:

Reviewed by Darin Fisher.

  • public/WebUserMediaClient.h:

(WebKit::WebUserMediaClient::requestUserMedia):

  • public/WebUserMediaRequest.h:
  • public/platform/WebMediaStreamDescriptor.h:
  • src/UserMediaClientImpl.cpp:

(WebKit::UserMediaClientImpl::requestUserMedia):

  • src/UserMediaClientImpl.h:
  • src/WebMediaStreamDescriptor.cpp:

(WebKit::WebMediaStreamDescriptor::sources):
(WebKit::WebMediaStreamDescriptor::audioSources):
(WebKit::WebMediaStreamDescriptor::videoSources):
(WebKit::WebMediaStreamDescriptor::initialize):

  • src/WebUserMediaRequest.cpp:

(WebKit::WebUserMediaRequest::requestSucceeded):

Location:
trunk/Source
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r105773 r105774  
     12012-01-24  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Split the MediaStream track list into audio/video specific ones.
     4        https://bugs.webkit.org/show_bug.cgi?id=76614
     5
     6        The latest draft of the WebRTC standard have split the MediaStream combined track list
     7        into audio/video specific ones.
     8
     9        Reviewed by Darin Fisher.
     10
     11        Tests for the Media Stream API will be provided by the bug 56587, pending enough landed code.
     12
     13        * mediastream/LocalMediaStream.cpp:
     14        (WebCore::LocalMediaStream::create):
     15        (WebCore::LocalMediaStream::LocalMediaStream):
     16        * mediastream/LocalMediaStream.h:
     17        * mediastream/MediaStream.cpp:
     18        (WebCore::processTrackList):
     19        (WebCore::MediaStream::create):
     20        (WebCore::MediaStream::MediaStream):
     21        * mediastream/MediaStream.h:
     22        (WebCore::MediaStream::audioTracks):
     23        (WebCore::MediaStream::videoTracks):
     24        * mediastream/MediaStream.idl:
     25        * mediastream/MediaStreamTrack.cpp:
     26        (WebCore::MediaStreamTrack::create):
     27        (WebCore::MediaStreamTrack::MediaStreamTrack):
     28        (WebCore::MediaStreamTrack::kind):
     29        (WebCore::MediaStreamTrack::label):
     30        (WebCore::MediaStreamTrack::enabled):
     31        (WebCore::MediaStreamTrack::setEnabled):
     32        (WebCore::MediaStreamTrack::component):
     33        * mediastream/MediaStreamTrack.h:
     34        * mediastream/UserMediaClient.h:
     35        * mediastream/UserMediaRequest.cpp:
     36        (WebCore::UserMediaRequest::mediaStreamSourcesQueryCompleted):
     37        (WebCore::UserMediaRequest::succeed):
     38        * mediastream/UserMediaRequest.h:
     39        * platform/mediastream/MediaStreamCenter.cpp:
     40        (WebCore::MediaStreamCenter::queryMediaStreamSources):
     41        (WebCore::MediaStreamCenter::didSetMediaStreamTrackEnabled):
     42        * platform/mediastream/MediaStreamCenter.h:
     43        * platform/mediastream/MediaStreamDescriptor.h:
     44        (WebCore::MediaStreamDescriptor::create):
     45        (WebCore::MediaStreamDescriptor::numberOfAudioComponents):
     46        (WebCore::MediaStreamDescriptor::audioComponent):
     47        (WebCore::MediaStreamDescriptor::numberOfVideoComponents):
     48        (WebCore::MediaStreamDescriptor::videoComponent):
     49        (WebCore::MediaStreamDescriptor::MediaStreamDescriptor):
     50
    1512012-01-24  Sheriff Bot  <webkit.review.bot@gmail.com>
    252

  • trunk/Source/WebCore/mediastream/LocalMediaStream.cpp

    r100997 r105774  
    3434namespace WebCore {
    3535
    36 PassRefPtr<LocalMediaStream> LocalMediaStream::create(ScriptExecutionContext* context, const MediaStreamSourceVector& sources)
     36PassRefPtr<LocalMediaStream> LocalMediaStream::create(ScriptExecutionContext* context, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
    3737{
    38     return adoptRef(new LocalMediaStream(context, sources));
     38    return adoptRef(new LocalMediaStream(context, audioSources, videoSources));
    3939}
    4040
    41 LocalMediaStream::LocalMediaStream(ScriptExecutionContext* context, const MediaStreamSourceVector& sources)
    42     : MediaStream(context, MediaStreamDescriptor::create(createCanonicalUUIDString(), sources))
     41LocalMediaStream::LocalMediaStream(ScriptExecutionContext* context, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
     42    : MediaStream(context, MediaStreamDescriptor::create(createCanonicalUUIDString(), audioSources, videoSources))
    4343    , m_stopTimer(this, &LocalMediaStream::stopTimerFired)
    4444{

  • trunk/Source/WebCore/mediastream/LocalMediaStream.h

    r98388 r105774  
    3636class LocalMediaStream : public MediaStream {
    3737public:
    38     static PassRefPtr<LocalMediaStream> create(ScriptExecutionContext*, const MediaStreamSourceVector&);
     38    static PassRefPtr<LocalMediaStream> create(ScriptExecutionContext*, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
    3939    virtual ~LocalMediaStream();
    4040
    … …  
    4545
    4646private:
    47     LocalMediaStream(ScriptExecutionContext*, const MediaStreamSourceVector&);
     47    LocalMediaStream(ScriptExecutionContext*, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
    4848
    4949    void stopTimerFired(Timer<LocalMediaStream>*);

  • trunk/Source/WebCore/mediastream/MediaStream.cpp

    r105138 r105774  
    3030
    3131#include "Event.h"
     32#include "ExceptionCode.h"
    3233#include "MediaStreamCenter.h"
     34#include "MediaStreamSource.h"
    3335#include "ScriptExecutionContext.h"
    3436#include "UUID.h"
    … …  
    3638namespace WebCore {
    3739
    38 PassRefPtr<MediaStream> MediaStream::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackList> prpTracks)
     40static void processTrackList(PassRefPtr<MediaStreamTrackList> prpTracks, const String& kind, MediaStreamSourceVector& sources, ExceptionCode& ec)
    3941{
    4042    RefPtr<MediaStreamTrackList> tracks = prpTracks;
    41     MediaStreamSourceVector sources;
    42     for (unsigned i = 0; i < tracks->length(); ++i)
    43         sources.append(tracks->item(i)->component()->source());
     43    if (!tracks)
     44        return;
    4445
    45     RefPtr<MediaStreamDescriptor> descriptor = MediaStreamDescriptor::create(createCanonicalUUIDString(), sources);
     46    for (unsigned i = 0; i < tracks->length(); ++i) {
     47        MediaStreamTrack* track = tracks->item(i);
     48        if (track->kind() != kind) {
     49            ec = SYNTAX_ERR;
     50            return;
     51        }
     52        MediaStreamSource* source = track->component()->source();
     53        bool isDuplicate = false;
     54        for (MediaStreamSourceVector::iterator j = sources.begin(); j < sources.end(); ++j) {
     55            if ((*j)->id() == source->id()) {
     56                isDuplicate = true;
     57                break;
     58            }
     59        }
     60        if (!isDuplicate)
     61            sources.append(source);
     62    }
     63}
     64
     65PassRefPtr<MediaStream> MediaStream::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackList> audioTracks, PassRefPtr<MediaStreamTrackList> videoTracks, ExceptionCode& ec)
     66{
     67    MediaStreamSourceVector audioSources;
     68    processTrackList(audioTracks, "audio", audioSources, ec);
     69    if (ec)
     70        return 0;
     71
     72    MediaStreamSourceVector videoSources;
     73    processTrackList(videoTracks, "video", videoSources, ec);
     74    if (ec)
     75        return 0;
     76
     77    RefPtr<MediaStreamDescriptor> descriptor = MediaStreamDescriptor::create(createCanonicalUUIDString(), audioSources, videoSources);
    4678    MediaStreamCenter::instance().didConstructMediaStream(descriptor.get());
    4779    return adoptRef(new MediaStream(context, descriptor.release()));
    … …  
    5991    m_descriptor->setOwner(this);
    6092
    61     MediaStreamTrackVector trackVector;
    62     size_t numberOfTracks = m_descriptor->numberOfComponents();
     93    MediaStreamTrackVector audioTrackVector;
     94    size_t numberOfAudioTracks = m_descriptor->numberOfAudioComponents();
     95    audioTrackVector.reserveCapacity(numberOfAudioTracks);
     96    for (size_t i = 0; i < numberOfAudioTracks; i++)
     97        audioTrackVector.append(MediaStreamTrack::create(m_descriptor, m_descriptor->audioComponent(i)));
     98    m_audioTracks = MediaStreamTrackList::create(audioTrackVector);
    6399
    64     trackVector.reserveCapacity(numberOfTracks);
    65     for (size_t i = 0; i < numberOfTracks; i++)
    66         trackVector.append(MediaStreamTrack::create(m_descriptor, i));
    67 
    68     m_tracks = MediaStreamTrackList::create(trackVector);
     100    MediaStreamTrackVector videoTrackVector;
     101    size_t numberOfVideoTracks = m_descriptor->numberOfVideoComponents();
     102    videoTrackVector.reserveCapacity(numberOfVideoTracks);
     103    for (size_t i = 0; i < numberOfVideoTracks; i++)
     104        videoTrackVector.append(MediaStreamTrack::create(m_descriptor, m_descriptor->videoComponent(i)));
     105    m_videoTracks = MediaStreamTrackList::create(videoTrackVector);
    69106}
    70107

  • trunk/Source/WebCore/mediastream/MediaStream.h

    r105138 r105774  
    4848
    4949    static PassRefPtr<MediaStream> create(ScriptExecutionContext*, PassRefPtr<MediaStreamDescriptor>);
    50     static PassRefPtr<MediaStream> create(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackList>);
     50    static PassRefPtr<MediaStream> create(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackList>, PassRefPtr<MediaStreamTrackList>, ExceptionCode&);
    5151    virtual ~MediaStream();
    5252
    … …  
    5656    String label() const { return m_descriptor->label(); }
    5757
    58     MediaStreamTrackList* tracks() { return m_tracks.get(); }
     58    MediaStreamTrackList* audioTracks() { return m_audioTracks.get(); }
     59    MediaStreamTrackList* videoTracks() { return m_videoTracks.get(); }
    5960
    6061    void streamEnded();
    … …  
    8586    RefPtr<ScriptExecutionContext> m_scriptExecutionContext;
    8687
    87     RefPtr<MediaStreamTrackList> m_tracks;
     88    RefPtr<MediaStreamTrackList> m_audioTracks;
     89    RefPtr<MediaStreamTrackList> m_videoTracks;
    8890    RefPtr<MediaStreamDescriptor> m_descriptor;
    8991};

  • trunk/Source/WebCore/mediastream/MediaStream.idl

    r105138 r105774  
    2828        Conditional=MEDIA_STREAM,
    2929        EventTarget,
    30         Constructor(in MediaStreamTrackList trackList),
    31         CallWith=ScriptExecutionContext
     30        Constructor(in MediaStreamTrackList audioTracks, in MediaStreamTrackList videoTracks),
     31        CallWith=ScriptExecutionContext,
     32        ConstructorRaisesException
    3233   ] MediaStream {
    3334        readonly attribute DOMString label;
    34         readonly attribute MediaStreamTrackList tracks;
     35        readonly attribute MediaStreamTrackList audioTracks;
     36        readonly attribute MediaStreamTrackList videoTracks;
    3537
    3638        // FIXME: implement the record method when MediaStreamRecorder is available.

  • trunk/Source/WebCore/mediastream/MediaStreamTrack.cpp

    r105138 r105774  
    3434namespace WebCore {
    3535
    36 PassRefPtr<MediaStreamTrack> MediaStreamTrack::create(PassRefPtr<MediaStreamDescriptor> streamDescriptor, size_t trackIndex)
     36PassRefPtr<MediaStreamTrack> MediaStreamTrack::create(PassRefPtr<MediaStreamDescriptor> streamDescriptor, MediaStreamComponent* component)
    3737{
    38     return adoptRef(new MediaStreamTrack(streamDescriptor, trackIndex));
     38    return adoptRef(new MediaStreamTrack(streamDescriptor, component));
    3939}
    4040
    41 MediaStreamTrack::MediaStreamTrack(PassRefPtr<MediaStreamDescriptor> streamDescriptor, size_t trackIndex)
     41MediaStreamTrack::MediaStreamTrack(PassRefPtr<MediaStreamDescriptor> streamDescriptor, MediaStreamComponent* component)
    4242    : m_streamDescriptor(streamDescriptor)
    43     , m_trackIndex(trackIndex)
     43    , m_component(component)
    4444{
    4545}
    … …  
    5454    DEFINE_STATIC_LOCAL(String, videoKind, ("video"));
    5555
    56     switch (m_streamDescriptor->component(m_trackIndex)->source()->type()) {
     56    switch (m_component->source()->type()) {
    5757    case MediaStreamSource::TypeAudio:
    5858        return audioKind;
    … …  
    6767String MediaStreamTrack::label() const
    6868{
    69     return m_streamDescriptor->component(m_trackIndex)->source()->name();
     69    return m_component->source()->name();
    7070}
    7171
    7272bool MediaStreamTrack::enabled() const
    7373{
    74     return m_streamDescriptor->component(m_trackIndex)->enabled();
     74    return m_component->enabled();
    7575}
    7676
    7777void MediaStreamTrack::setEnabled(bool enabled)
    7878{
    79     if (enabled == m_streamDescriptor->component(m_trackIndex)->enabled())
     79    if (enabled == m_component->enabled())
    8080        return;
    8181
    82     m_streamDescriptor->component(m_trackIndex)->setEnabled(enabled);
     82    m_component->setEnabled(enabled);
    8383
    84     MediaStreamCenter::instance().didSetMediaStreamTrackEnabled(m_streamDescriptor.get(), m_trackIndex);
     84    MediaStreamCenter::instance().didSetMediaStreamTrackEnabled(m_streamDescriptor.get(), m_component.get());
    8585}
    8686
    8787MediaStreamComponent* MediaStreamTrack::component()
    8888{
    89     return m_streamDescriptor->component(m_trackIndex);
     89    return m_component.get();
    9090}
    9191

  • trunk/Source/WebCore/mediastream/MediaStreamTrack.h

    r105138 r105774  
    4141class MediaStreamTrack : public RefCounted<MediaStreamTrack> {
    4242public:
    43     static PassRefPtr<MediaStreamTrack> create(PassRefPtr<MediaStreamDescriptor>, size_t trackIndex);
     43    static PassRefPtr<MediaStreamTrack> create(PassRefPtr<MediaStreamDescriptor>, MediaStreamComponent*);
    4444    virtual ~MediaStreamTrack();
    4545
    … …  
    5353
    5454private:
    55     MediaStreamTrack(PassRefPtr<MediaStreamDescriptor>, size_t trackIndex);
     55    MediaStreamTrack(PassRefPtr<MediaStreamDescriptor>, MediaStreamComponent*);
    5656
    5757    RefPtr<MediaStreamDescriptor> m_streamDescriptor;
    58     const size_t m_trackIndex;
     58    RefPtr<MediaStreamComponent> m_component;
    5959};
    6060

  • trunk/Source/WebCore/mediastream/UserMediaClient.h

    r100555 r105774  
    4343    virtual void pageDestroyed() = 0;
    4444
    45     virtual void requestUserMedia(PassRefPtr<UserMediaRequest>, const MediaStreamSourceVector&) = 0;
     45    virtual void requestUserMedia(PassRefPtr<UserMediaRequest>, const MediaStreamSourceVector&,  const MediaStreamSourceVector&) = 0;
    4646    virtual void cancelUserMediaRequest(UserMediaRequest*) = 0;
    4747

  • trunk/Source/WebCore/mediastream/UserMediaRequest.cpp

    r100997 r105774  
    7272}
    7373
    74 void UserMediaRequest::mediaStreamSourcesQueryCompleted(const MediaStreamSourceVector& sources)
     74void UserMediaRequest::mediaStreamSourcesQueryCompleted(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
    7575{
    7676    if (m_client)
    77         m_client->requestUserMedia(this, sources);
     77        m_client->requestUserMedia(this, audioSources, videoSources);
    7878}
    7979
    80 void UserMediaRequest::succeed(const MediaStreamSourceVector& sources)
     80void UserMediaRequest::succeed(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
    8181{
    8282    if (!m_scriptExecutionContext)
    8383        return;
    8484
    85     RefPtr<LocalMediaStream> stream = LocalMediaStream::create(m_scriptExecutionContext, sources);
     85    RefPtr<LocalMediaStream> stream = LocalMediaStream::create(m_scriptExecutionContext, audioSources, videoSources);
    8686    m_successCallback->handleEvent(stream.get());
    8787}

  • trunk/Source/WebCore/mediastream/UserMediaRequest.h

    r100997 r105774  
    6262
    6363    void start();
    64     void mediaStreamSourcesQueryCompleted(const MediaStreamSourceVector&);
     64    void mediaStreamSourcesQueryCompleted(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
    6565
    66     void succeed(const MediaStreamSourceVector&);
     66    void succeed(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources);
    6767    void fail();
    6868

  • trunk/Source/WebCore/platform/mediastream/MediaStreamCenter.cpp

    r105138 r105774  
    6969void MediaStreamCenter::queryMediaStreamSources(PassRefPtr<MediaStreamSourcesQueryClient> client)
    7070{
    71     MediaStreamSourceVector sources;
    72     client->mediaStreamSourcesQueryCompleted(sources);
     71    MediaStreamSourceVector audioSources, videoSources;
     72    client->mediaStreamSourcesQueryCompleted(audioSources, videoSources);
    7373}
    7474
    75 void MediaStreamCenter::didSetMediaStreamTrackEnabled(MediaStreamDescriptor*, unsigned)
     75void MediaStreamCenter::didSetMediaStreamTrackEnabled(MediaStreamDescriptor*, MediaStreamComponent*)
    7676{
    7777}

  • trunk/Source/WebCore/platform/mediastream/MediaStreamCenter.h

    r105138 r105774  
    3939namespace WebCore {
    4040
     41class MediaStreamComponent;
    4142class MediaStreamDescriptor;
    4243
    … …  
    4849    virtual bool video() const = 0;
    4950
    50     virtual void mediaStreamSourcesQueryCompleted(const MediaStreamSourceVector&) = 0;
     51    virtual void mediaStreamSourcesQueryCompleted(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources) = 0;
    5152};
    5253
    … …  
    6465
    6566    // Calls from the DOM objects to notify the platform
    66     void didSetMediaStreamTrackEnabled(MediaStreamDescriptor*, unsigned componentIndex);
     67    void didSetMediaStreamTrackEnabled(MediaStreamDescriptor*, MediaStreamComponent*);
    6768    void didStopLocalMediaStream(MediaStreamDescriptor*);
    6869    void didConstructMediaStream(MediaStreamDescriptor*);

  • trunk/Source/WebCore/platform/mediastream/MediaStreamDescriptor.h

    r100997 r105774  
    4949class MediaStreamDescriptor : public RefCounted<MediaStreamDescriptor> {
    5050public:
    51     static PassRefPtr<MediaStreamDescriptor> create(const String& label, const MediaStreamSourceVector& sources)
     51    static PassRefPtr<MediaStreamDescriptor> create(const String& label, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
    5252    {
    53         return adoptRef(new MediaStreamDescriptor(label, sources));
     53        return adoptRef(new MediaStreamDescriptor(label, audioSources, videoSources));
    5454    }
    5555
    … …  
    5959    String label() const { return m_label; }
    6060
    61     MediaStreamComponent* component(unsigned index) const { return m_components[index].get(); }
    62     unsigned numberOfComponents() const { return m_components.size(); }
     61    unsigned numberOfAudioComponents() const { return m_audioComponents.size(); }
     62    MediaStreamComponent* audioComponent(unsigned index) const { return m_audioComponents[index].get(); }
     63
     64    unsigned numberOfVideoComponents() const { return m_videoComponents.size(); }
     65    MediaStreamComponent* videoComponent(unsigned index) const { return m_videoComponents[index].get(); }
    6366
    6467    bool ended() const { return m_ended; }
    … …  
    6669
    6770private:
    68     MediaStreamDescriptor(const String& label, const MediaStreamSourceVector& sources)
     71    MediaStreamDescriptor(const String& label, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
    6972        : m_owner(0)
    7073        , m_label(label)
    7174        , m_ended(false)
    7275    {
    73         for (size_t i = 0; i < sources.size(); i++)
    74             m_components.append(MediaStreamComponent::create(sources[i]));
     76        for (size_t i = 0; i < audioSources.size(); i++)
     77            m_audioComponents.append(MediaStreamComponent::create(audioSources[i]));
     78
     79        for (size_t i = 0; i < videoSources.size(); i++)
     80            m_videoComponents.append(MediaStreamComponent::create(videoSources[i]));
    7581    }
    7682
    7783    MediaStreamDescriptorOwner* m_owner;
    7884    String m_label;
    79     Vector<RefPtr<MediaStreamComponent> > m_components;
     85    Vector<RefPtr<MediaStreamComponent> > m_audioComponents;
     86    Vector<RefPtr<MediaStreamComponent> > m_videoComponents;
    8087    bool m_ended;
    8188};

  • trunk/Source/WebKit/chromium/ChangeLog

    r105757 r105774  
     12012-01-24  Tommy Widenflycht  <tommyw@google.com>
     2
     3        MediaStream API: Split the MediaStream track list into audio/video specific ones.
     4        https://bugs.webkit.org/show_bug.cgi?id=76614
     5
     6        Reviewed by Darin Fisher.
     7
     8        * public/WebUserMediaClient.h:
     9        (WebKit::WebUserMediaClient::requestUserMedia):
     10        * public/WebUserMediaRequest.h:
     11        * public/platform/WebMediaStreamDescriptor.h:
     12        * src/UserMediaClientImpl.cpp:
     13        (WebKit::UserMediaClientImpl::requestUserMedia):
     14        * src/UserMediaClientImpl.h:
     15        * src/WebMediaStreamDescriptor.cpp:
     16        (WebKit::WebMediaStreamDescriptor::sources):
     17        (WebKit::WebMediaStreamDescriptor::audioSources):
     18        (WebKit::WebMediaStreamDescriptor::videoSources):
     19        (WebKit::WebMediaStreamDescriptor::initialize):
     20        * src/WebUserMediaRequest.cpp:
     21        (WebKit::WebUserMediaRequest::requestSucceeded):
     22
    1232012-01-23  Simon Fraser  <simon.fraser@apple.com>
    224

  • trunk/Source/WebKit/chromium/public/WebUserMediaClient.h

    r101058 r105774  
    4242    virtual ~WebUserMediaClient() { }
    4343
    44     virtual void requestUserMedia(const WebUserMediaRequest&, const WebVector<WebMediaStreamSource>&) = 0;
     44    // DEPRECATED
     45    virtual void requestUserMedia(const WebUserMediaRequest&, const WebVector<WebMediaStreamSource>&) { }
     46
     47    virtual void requestUserMedia(const WebUserMediaRequest&, const WebVector<WebMediaStreamSource>& audioSources, const WebVector<WebMediaStreamSource>& videoSources) { }
     48
    4549    virtual void cancelUserMediaRequest(const WebUserMediaRequest&) = 0;
    4650};

  • trunk/Source/WebKit/chromium/public/WebUserMediaRequest.h

    r101122 r105774  
    6969    WEBKIT_EXPORT WebSecurityOrigin securityOrigin() const;
    7070
     71    // DEPRECATED
    7172    WEBKIT_EXPORT void requestSucceeded(const WebVector<WebMediaStreamSource>&);
     73
     74    WEBKIT_EXPORT void requestSucceeded(const WebVector<WebMediaStreamSource>& audioSources, const WebVector<WebMediaStreamSource>& videoSources);
    7275    WEBKIT_EXPORT void requestFailed();
    7376

  • trunk/Source/WebKit/chromium/public/platform/WebMediaStreamDescriptor.h

    r105318 r105774  
    5353
    5454    WEBKIT_EXPORT void assign(const WebMediaStreamDescriptor&);
     55
     56    // DEPRECATED
    5557    WEBKIT_EXPORT void initialize(const WebString& label, const WebVector<WebMediaStreamSource>&);
     58
     59    WEBKIT_EXPORT void initialize(const WebString& label, const WebVector<WebMediaStreamSource>& audioSources, const WebVector<WebMediaStreamSource>& videoSources);
    5660    WEBKIT_EXPORT void reset();
    5761    bool isNull() const { return m_private.isNull(); }
    5862
    5963    WEBKIT_EXPORT WebString label() const;
     64
     65    // DEPRECATED
    6066    WEBKIT_EXPORT void sources(WebVector<WebMediaStreamSource>&) const;
     67
     68    WEBKIT_EXPORT void audioSources(WebVector<WebMediaStreamSource>&) const;
     69    WEBKIT_EXPORT void videoSources(WebVector<WebMediaStreamSource>&) const;
    6170
    6271#if WEBKIT_IMPLEMENTATION

  • trunk/Source/WebKit/chromium/src/UserMediaClientImpl.cpp

    r102603 r105774  
    3939#include "WebViewImpl.h"
    4040#include "platform/WebMediaStreamSource.h"
     41#include <wtf/RefPtr.h>
    4142
    4243using namespace WebCore;
    … …  
    5354}
    5455
    55 void UserMediaClientImpl::requestUserMedia(PassRefPtr<UserMediaRequest> request, const MediaStreamSourceVector& sources)
     56void UserMediaClientImpl::requestUserMedia(PassRefPtr<UserMediaRequest> prpRequest, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
    5657{
    57     if (m_client)
    58         m_client->requestUserMedia(request, sources);
     58    if (m_client) {
     59        RefPtr<UserMediaRequest> request = prpRequest;
     60
     61        // FIXME: Cleanup when the chromium code has switched to the split sources implementation.
     62        MediaStreamSourceVector combinedSources;
     63        combinedSources.append(audioSources);
     64        combinedSources.append(videoSources);
     65        m_client->requestUserMedia(PassRefPtr<UserMediaRequest>(request.get()), combinedSources);
     66
     67        m_client->requestUserMedia(request.release(), audioSources, videoSources);
     68    }
    5969}
    6070

  • trunk/Source/WebKit/chromium/src/UserMediaClientImpl.h

    r101058 r105774  
    5151    // WebCore::UserMediaClient ----------------------------------------------
    5252    virtual void pageDestroyed();
    53     virtual void requestUserMedia(PassRefPtr<WebCore::UserMediaRequest>, const WebCore::MediaStreamSourceVector&);
     53    virtual void requestUserMedia(PassRefPtr<WebCore::UserMediaRequest>, const WebCore::MediaStreamSourceVector&, const WebCore::MediaStreamSourceVector&);
    5454    virtual void cancelUserMediaRequest(WebCore::UserMediaRequest*);
    5555

  • trunk/Source/WebKit/chromium/src/WebMediaStreamDescriptor.cpp

    r105318 r105774  
    6161}
    6262
     63// FIXME: Cleanup when the chromium code has switched to the split sources implementation.
    6364void WebMediaStreamDescriptor::sources(WebVector<WebMediaStreamSource>& webSources) const
    6465{
    65     size_t numberOfSources = m_private->numberOfComponents();
     66    size_t numberOfAudioSources = m_private->numberOfAudioComponents();
     67    size_t numberOfVideoSources = m_private->numberOfVideoComponents();
     68    WebVector<WebMediaStreamSource> result(numberOfAudioSources + numberOfVideoSources);
     69    size_t i = 0;
     70    for (size_t j = 0; j < numberOfAudioSources; ++i, ++j)
     71        result[i] = m_private->audioComponent(j)->source();
     72    for (size_t j = 0; j < numberOfVideoSources; ++i, ++j)
     73        result[i] = m_private->videoComponent(j)->source();
     74    webSources.swap(result);
     75}
     76
     77void WebMediaStreamDescriptor::audioSources(WebVector<WebMediaStreamSource>& webSources) const
     78{
     79    size_t numberOfSources = m_private->numberOfAudioComponents();
    6680    WebVector<WebMediaStreamSource> result(numberOfSources);
    6781    for (size_t i = 0; i < numberOfSources; ++i)
    68         result[i] = m_private->component(i)->source();
     82        result[i] = m_private->audioComponent(i)->source();
     83    webSources.swap(result);
     84}
     85
     86void WebMediaStreamDescriptor::videoSources(WebVector<WebMediaStreamSource>& webSources) const
     87{
     88    size_t numberOfSources = m_private->numberOfVideoComponents();
     89    WebVector<WebMediaStreamSource> result(numberOfSources);
     90    for (size_t i = 0; i < numberOfSources; ++i)
     91        result[i] = m_private->videoComponent(i)->source();
    6992    webSources.swap(result);
    7093}
    … …  
    86109}
    87110
     111// FIXME: Cleanup when the chromium code has switched to the split sources implementation.
    88112void WebMediaStreamDescriptor::initialize(const WebString& label, const WebVector<WebMediaStreamSource>& sources)
    89113{
    90     MediaStreamSourceVector s;
     114    MediaStreamSourceVector audio, video;
    91115    for (size_t i = 0; i < sources.size(); ++i) {
    92116        MediaStreamSource* curr = sources[i];
    93         s.append(curr);
     117        if (curr->type() == MediaStreamSource::TypeAudio)
     118            audio.append(curr);
     119        else if (curr->type() == MediaStreamSource::TypeVideo)
     120            video.append(curr);
    94121    }
    95     m_private = MediaStreamDescriptor::create(label, s);
     122    m_private = MediaStreamDescriptor::create(label, audio, video);
     123}
     124
     125void WebMediaStreamDescriptor::initialize(const WebString& label, const WebVector<WebMediaStreamSource>& audioSources, const WebVector<WebMediaStreamSource>& videoSources)
     126{
     127    MediaStreamSourceVector audio, video;
     128    for (size_t i = 0; i < audioSources.size(); ++i) {
     129        MediaStreamSource* curr = audioSources[i];
     130        audio.append(curr);
     131    }
     132    for (size_t i = 0; i < videoSources.size(); ++i) {
     133        MediaStreamSource* curr = videoSources[i];
     134        video.append(curr);
     135    }
     136    m_private = MediaStreamDescriptor::create(label, audio, video);
    96137}
    97138

  • trunk/Source/WebKit/chromium/src/WebUserMediaRequest.cpp

    r102603 r105774  
    8787}
    8888
     89void WebUserMediaRequest::requestSucceeded(const WebVector<WebMediaStreamSource>& audioSources, const WebVector<WebMediaStreamSource>& videoSources)
     90{
     91    if (m_private.isNull())
     92        return;
     93
     94    MediaStreamSourceVector audio;
     95    for (size_t i = 0; i < audioSources.size(); ++i) {
     96        MediaStreamSource* curr = audioSources[i];
     97        audio.append(curr);
     98    }
     99    MediaStreamSourceVector video;
     100    for (size_t i = 0; i < videoSources.size(); ++i) {
     101        MediaStreamSource* curr = videoSources[i];
     102        video.append(curr);
     103    }
     104
     105    m_private->succeed(audio, video);
     106}
     107
     108// FIXME: Cleanup when the chromium code has switched to the split sources implementation.
    89109void WebUserMediaRequest::requestSucceeded(const WebVector<WebMediaStreamSource>& sources)
    90110{
    … …  
    92112        return;
    93113
    94     MediaStreamSourceVector s;
     114    MediaStreamSourceVector audio, video;
    95115    for (size_t i = 0; i < sources.size(); ++i) {
    96116        MediaStreamSource* curr = sources[i];
    97         s.append(curr);
     117        if (curr->type() == MediaStreamSource::TypeAudio)
     118            audio.append(curr);
     119        else if (curr->type() == MediaStreamSource::TypeVideo)
     120            video.append(curr);
    98121    }
    99122
    100     m_private->succeed(s);
     123    m_private->succeed(audio, video);
    101124}
    102125
Note: See TracChangeset for help on using the changeset viewer.