Changeset 97904 in webkit


Ignore:
Timestamp:
Oct 19, 2011 5:53:21 PM (13 years ago)
Author:
commit-queue@webkit.org
Message:

Update MediaStream to use WebCore platform interfaces
​https://bugs.webkit.org/show_bug.cgi?id=68464

Patch by Adam Bergkvist <​adam.bergkvist@ericsson.com> on 2011-10-19
Reviewed by Adam Barth.

Source/WebCore:

This is one in a series of patches that update the MediaStream feature
to use WebCore platform interfaces.

Tests will be provided by ​http://webkit.org/b/56587

  • dom/LocalMediaStream.cpp:

(WebCore::LocalMediaStream::create):
(WebCore::LocalMediaStream::LocalMediaStream):
(WebCore::LocalMediaStream::stop):
(WebCore::LocalMediaStream::stopTimerFired):
(WebCore::LocalMediaStream::~LocalMediaStream):
(WebCore::LocalMediaStream::toLocalMediaStream):

  • dom/LocalMediaStream.h:
  • dom/LocalMediaStream.idl:
  • dom/MediaStream.cpp:

(WebCore::MediaStream::create):
(WebCore::MediaStream::MediaStream):
(WebCore::MediaStream::~MediaStream):
(WebCore::MediaStream::readyState):
(WebCore::MediaStream::streamEnded):
(WebCore::MediaStream::scriptExecutionContext):

  • dom/MediaStream.h:

(WebCore::MediaStream::label):
(WebCore::MediaStream::tracks):
(WebCore::MediaStream::descriptor):

  • dom/MediaStreamTrack.cpp:

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

  • dom/MediaStreamTrack.h:
  • dom/MediaStreamTrack.idl:
  • dom/MediaStreamTrackList.cpp:

(WebCore::MediaStreamTrackList::create):
(WebCore::MediaStreamTrackList::MediaStreamTrackList):
(WebCore::MediaStreamTrackList::length):
(WebCore::MediaStreamTrackList::item):

  • dom/MediaStreamTrackList.h:
  • p2p/PeerConnection.cpp:

(WebCore::PeerConnection::addStream):
(WebCore::PeerConnection::removeStream):
(WebCore::PeerConnection::remoteStreamAdded):

  • page/MediaStreamClient.h:
  • page/MediaStreamController.cpp:

(WebCore::MediaStreamController::unregisterFrameController):
(WebCore::MediaStreamController::streamGenerated):

  • page/MediaStreamController.h:
  • page/MediaStreamFrameController.cpp:

(WebCore::MediaStreamFrameController::enterDetachedState):
(WebCore::MediaStreamFrameController::disconnectFrame):
(WebCore::MediaStreamFrameController::streamGenerated):

  • page/MediaStreamFrameController.h:

Source/WebKit/chromium:

Removed WebMediaStreamTrack* since they will no longer be needed.

  • WebKit.gyp:
  • public/WebMediaStreamTrack.h: Removed.
  • public/WebMediaStreamTrackList.h: Removed.
  • src/WebMediaStreamTrack.cpp: Removed.
  • src/WebMediaStreamTrackList.cpp: Removed.
Location:
trunk/Source
Files:
4 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r97902 r97904  
     12011-10-19  Adam Bergkvist  <adam.bergkvist@ericsson.com>
     2
     3        Update MediaStream to use WebCore platform interfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=68464
     5
     6        Reviewed by Adam Barth.
     7
     8        This is one in a series of patches that update the MediaStream feature
     9        to use WebCore platform interfaces.
     10
     11        Tests will be provided by http://webkit.org/b/56587
     12
     13        * dom/LocalMediaStream.cpp:
     14        (WebCore::LocalMediaStream::create):
     15        (WebCore::LocalMediaStream::LocalMediaStream):
     16        (WebCore::LocalMediaStream::stop):
     17        (WebCore::LocalMediaStream::stopTimerFired):
     18        (WebCore::LocalMediaStream::~LocalMediaStream):
     19        (WebCore::LocalMediaStream::toLocalMediaStream):
     20        * dom/LocalMediaStream.h:
     21        * dom/LocalMediaStream.idl:
     22        * dom/MediaStream.cpp:
     23        (WebCore::MediaStream::create):
     24        (WebCore::MediaStream::MediaStream):
     25        (WebCore::MediaStream::~MediaStream):
     26        (WebCore::MediaStream::readyState):
     27        (WebCore::MediaStream::streamEnded):
     28        (WebCore::MediaStream::scriptExecutionContext):
     29        * dom/MediaStream.h:
     30        (WebCore::MediaStream::label):
     31        (WebCore::MediaStream::tracks):
     32        (WebCore::MediaStream::descriptor):
     33        * dom/MediaStreamTrack.cpp:
     34        (WebCore::MediaStreamTrack::create):
     35        (WebCore::MediaStreamTrack::MediaStreamTrack):
     36        (WebCore::MediaStreamTrack::kind):
     37        (WebCore::MediaStreamTrack::label):
     38        (WebCore::MediaStreamTrack::enabled):
     39        (WebCore::MediaStreamTrack::setEnabled):
     40        * dom/MediaStreamTrack.h:
     41        * dom/MediaStreamTrack.idl:
     42        * dom/MediaStreamTrackList.cpp:
     43        (WebCore::MediaStreamTrackList::create):
     44        (WebCore::MediaStreamTrackList::MediaStreamTrackList):
     45        (WebCore::MediaStreamTrackList::length):
     46        (WebCore::MediaStreamTrackList::item):
     47        * dom/MediaStreamTrackList.h:
     48        * p2p/PeerConnection.cpp:
     49        (WebCore::PeerConnection::addStream):
     50        (WebCore::PeerConnection::removeStream):
     51        (WebCore::PeerConnection::remoteStreamAdded):
     52        * page/MediaStreamClient.h:
     53        * page/MediaStreamController.cpp:
     54        (WebCore::MediaStreamController::unregisterFrameController):
     55        (WebCore::MediaStreamController::streamGenerated):
     56        * page/MediaStreamController.h:
     57        * page/MediaStreamFrameController.cpp:
     58        (WebCore::MediaStreamFrameController::enterDetachedState):
     59        (WebCore::MediaStreamFrameController::disconnectFrame):
     60        (WebCore::MediaStreamFrameController::streamGenerated):
     61        * page/MediaStreamFrameController.h:
     62
    1632011-10-19  W. James MacLean  <wjmaclean@chromium.org>
    264

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

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2829#if ENABLE(MEDIA_STREAM)
    2930
    30 #include "Event.h"
    31 #include "EventNames.h"
    32 #include "MediaStreamFrameController.h"
    33 #include "ScriptExecutionContext.h"
     31#include "UUID.h"
    3432
    3533namespace WebCore {
    3634
    37 class LocalMediaStream::DispatchUpdateTask : public ScriptExecutionContext::Task {
    38 public:
    39     typedef void (LocalMediaStream::*Callback)();
    40 
    41     static PassOwnPtr<DispatchUpdateTask> create(PassRefPtr<LocalMediaStream> object, Callback callback)
    42     {
    43         return adoptPtr(new DispatchUpdateTask(object, callback));
    44     }
    45 
    46     virtual void performTask(ScriptExecutionContext*)
    47     {
    48         (m_object.get()->*m_callback)();
    49     }
    50 
    51 public:
    52     DispatchUpdateTask(PassRefPtr<LocalMediaStream> object, Callback callback)
    53         : m_object(object)
    54         , m_callback(callback) { }
    55 
    56     RefPtr<LocalMediaStream> m_object;
    57     Callback m_callback;
    58 };
    59 
    60 PassRefPtr<LocalMediaStream> LocalMediaStream::create(MediaStreamFrameController* frameController, const String& label, PassRefPtr<MediaStreamTrackList> tracks)
     35PassRefPtr<LocalMediaStream> LocalMediaStream::create(ScriptExecutionContext* context, const MediaStreamSourceVector& sources)
    6136{
    62     return adoptRef(new LocalMediaStream(frameController, label, tracks));
     37    return adoptRef(new LocalMediaStream(context, sources));
    6338}
    6439
    65 LocalMediaStream::LocalMediaStream(MediaStreamFrameController* frameController, const String& label, PassRefPtr<MediaStreamTrackList> tracks)
    66     : MediaStream(frameController, label, tracks, true)
     40LocalMediaStream::LocalMediaStream(ScriptExecutionContext* context, const MediaStreamSourceVector& sources)
     41    : MediaStream(context, MediaStreamDescriptor::create(createCanonicalUUIDString(), sources))
     42    , m_stopTimer(this, &LocalMediaStream::stopTimerFired)
    6743{
     44}
     45
     46void LocalMediaStream::stop()
     47{
     48    if (!m_stopTimer.isActive())
     49        m_stopTimer.startOneShot(0);
     50}
     51
     52void LocalMediaStream::stopTimerFired(Timer<LocalMediaStream>* timer)
     53{
     54    ASSERT_UNUSED(timer, timer == &m_stopTimer);
     55
     56    if (readyState() == ENDED)
     57        return;
     58
     59    // FIXME: tell the platform that the stream was stopped
     60
     61    streamEnded();
    6862}
    6963
    … …  
    7771}
    7872
    79 void LocalMediaStream::detachEmbedder()
    80 {
    81     // Assuming we should stop any live streams when losing access to the embedder.
    82     stop();
    83 
    84     MediaStream::detachEmbedder();
    85 }
    86 
    87 void LocalMediaStream::streamEnded()
    88 {
    89     MediaStream::streamEnded();
    90 }
    91 
    92 void LocalMediaStream::stop()
    93 {
    94     if (!mediaStreamFrameController() || m_readyState == ENDED)
    95         return;
    96 
    97     mediaStreamFrameController()->stopGeneratedStream(label());
    98 
    99     m_readyState = ENDED;
    100 
    101     // Don't assert since it can be null in degenerate cases like frames detached from their pages.
    102     if (!scriptExecutionContext())
    103         return;
    104 
    105     ASSERT(scriptExecutionContext()->isContextThread());
    106     scriptExecutionContext()->postTask(DispatchUpdateTask::create(this, &LocalMediaStream::onStop));
    107 }
    108 
    109 void LocalMediaStream::onStop()
    110 {
    111     dispatchEvent(Event::create(eventNames().endedEvent, false, false));
    112 }
    113 
    11473} // namespace WebCore
    11574

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

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2930
    3031#include "MediaStream.h"
    31 #include <wtf/Forward.h>
     32#include "Timer.h"
    3233
    3334namespace WebCore {
    … …  
    3536class LocalMediaStream : public MediaStream {
    3637public:
    37     static PassRefPtr<LocalMediaStream> create(MediaStreamFrameController*, const String& label, PassRefPtr<MediaStreamTrackList> tracks);
     38    static PassRefPtr<LocalMediaStream> create(ScriptExecutionContext*, const MediaStreamSourceVector&);
    3839    virtual ~LocalMediaStream();
    3940
    4041    void stop();
    4142
    42     // MediaStreamFrameController::StreamClient implementation.
    43     virtual void detachEmbedder();
    44     virtual void streamEnded();
    45 
    4643    // EventTarget.
    4744    virtual LocalMediaStream* toLocalMediaStream();
    4845
    49 protected:
    50     virtual bool isLocalMediaStream() const { return true; }
     46private:
     47    LocalMediaStream(ScriptExecutionContext*, const MediaStreamSourceVector&);
    5148
    52 private:
    53     LocalMediaStream(MediaStreamFrameController*, const String& label, PassRefPtr<MediaStreamTrackList> tracks);
    54     class DispatchUpdateTask;
    55     friend class DispatchUpdateTask;
     49    void stopTimerFired(Timer<LocalMediaStream>*);
    5650
    57     void onStop();
     51    Timer<LocalMediaStream> m_stopTimer;
    5852};
    5953

  • trunk/Source/WebCore/dom/LocalMediaStream.idl

    r91364 r97904  
    2828        Conditional=MEDIA_STREAM,
    2929        GenerateNativeConverter,
    30         EventTarget
     30        EventTarget,
     31        GenerateToJS
    3132    ] LocalMediaStream : MediaStream {
    3233        void stop();

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

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3334namespace WebCore {
    3435
    35 PassRefPtr<MediaStream> MediaStream::create(MediaStreamFrameController* frameController, const String& label, PassRefPtr<MediaStreamTrackList> tracks, bool isLocalMediaStream)
     36PassRefPtr<MediaStream> MediaStream::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamDescriptor> streamDescriptor)
    3637{
    37     return adoptRef(new MediaStream(frameController, label, tracks, isLocalMediaStream));
     38    return adoptRef(new MediaStream(context, streamDescriptor));
    3839}
    3940
    40 MediaStream::MediaStream(MediaStreamFrameController* frameController, const String& label, PassRefPtr<MediaStreamTrackList> tracks, bool isLocalMediaStream)
    41     : MediaStreamClient(frameController, label, isLocalMediaStream)
    42     , m_readyState(LIVE)
    43     , m_tracks(tracks)
     41MediaStream::MediaStream(ScriptExecutionContext* context, PassRefPtr<MediaStreamDescriptor> streamDescriptor)
     42    : m_scriptExecutionContext(context)
     43    , m_descriptor(streamDescriptor)
    4444{
     45    m_descriptor->setOwner(this);
     46
     47    MediaStreamTrackVector trackVector;
     48    size_t numberOfTracks = m_descriptor->numberOfComponents();
     49
     50    trackVector.reserveCapacity(numberOfTracks);
     51    for (size_t i = 0; i < numberOfTracks; i++)
     52        trackVector.append(MediaStreamTrack::create(m_descriptor, i));
     53
     54    m_tracks = MediaStreamTrackList::create(trackVector);
    4555}
    4656
    4757MediaStream::~MediaStream()
    4858{
     59    m_descriptor->setOwner(0);
     60}
     61
     62MediaStream::ReadyState MediaStream::readyState() const
     63{
     64    return m_descriptor->ended() ? ENDED : LIVE;
    4965}
    5066
    … …  
    5672void MediaStream::streamEnded()
    5773{
    58     ASSERT(m_readyState != ENDED);
    59     m_readyState = ENDED;
     74    if (readyState() == ENDED)
     75        return;
     76
     77    m_descriptor->setEnded();
     78
    6079    dispatchEvent(Event::create(eventNames().endedEvent, false, false));
    6180}
    … …  
    6382ScriptExecutionContext* MediaStream::scriptExecutionContext() const
    6483{
    65     return mediaStreamFrameController() ? mediaStreamFrameController()->scriptExecutionContext() : 0;
     84    return m_scriptExecutionContext.get();
    6685}
    6786

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

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2829#if ENABLE(MEDIA_STREAM)
    2930
    30 #include "EventNames.h"
    3131#include "EventTarget.h"
    32 #include "MediaStreamFrameController.h"
     32#include "MediaStreamDescriptor.h"
    3333#include "MediaStreamTrackList.h"
    34 #include "ScriptExecutionContext.h"
    35 #include <wtf/Forward.h>
    36 #include <wtf/PassRefPtr.h>
    3734#include <wtf/RefCounted.h>
     35#include <wtf/RefPtr.h>
    3836
    3937namespace WebCore {
    4038
    41 class MediaStream : public RefCounted<MediaStream>,
    42                     public EventTarget,
    43                     public MediaStreamFrameController::MediaStreamClient {
     39class ScriptExecutionContext;
     40
     41class MediaStream : public RefCounted<MediaStream>, public EventTarget {
    4442public:
    4543    // Must match the constants in the .idl file.
    46     enum {
     44    enum ReadyState {
    4745        LIVE = 1,
    4846        ENDED = 2
    4947    };
    5048
    51     static PassRefPtr<MediaStream> create(MediaStreamFrameController*, const String& label, PassRefPtr<MediaStreamTrackList> tracks, bool isLocalMediaStream = false);
     49    static PassRefPtr<MediaStream> create(ScriptExecutionContext*, PassRefPtr<MediaStreamDescriptor>);
    5250    virtual ~MediaStream();
    5351
    5452    DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
    5553
    56     unsigned short readyState() const { return m_readyState; }
    57     const String& label() const { return clientId(); }
     54    ReadyState readyState() const;
     55    String label() const { return m_descriptor->label(); }
    5856
    59     PassRefPtr<MediaStreamTrackList> tracks() { return m_tracks; }
     57    MediaStreamTrackList* tracks() { return m_tracks.get(); }
    6058
    61     // MediaStreamFrameController::MediaStreamClient implementation.
    62     virtual void streamEnded();
     59    void streamEnded();
     60
     61    MediaStreamDescriptor* descriptor() const { return m_descriptor.get(); }
    6362
    6463    // EventTarget implementation.
    … …  
    7069
    7170protected:
    72     MediaStream(MediaStreamFrameController*, const String& label, PassRefPtr<MediaStreamTrackList> tracks, bool isLocalMediaStream);
     71    MediaStream(ScriptExecutionContext*, PassRefPtr<MediaStreamDescriptor>);
    7372
    7473    // EventTarget implementation.
    … …  
    7675    virtual EventTargetData* ensureEventTargetData();
    7776
    78     unsigned short m_readyState;
    79 
    8077private:
    81     void onEnded();
    82 
    8378    // EventTarget implementation.
    8479    virtual void refEventTarget() { ref(); }
    … …  
    8782    EventTargetData m_eventTargetData;
    8883
     84    RefPtr<ScriptExecutionContext> m_scriptExecutionContext;
     85
    8986    RefPtr<MediaStreamTrackList> m_tracks;
     87    RefPtr<MediaStreamDescriptor> m_descriptor;
    9088};
    9189

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

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3031namespace WebCore {
    3132
    32 PassRefPtr<MediaStreamTrack> MediaStreamTrack::create(const String& id, const String& kind, const String& label)
     33PassRefPtr<MediaStreamTrack> MediaStreamTrack::create(PassRefPtr<MediaStreamDescriptor> streamDescriptor, size_t trackIndex)
    3334{
    34     return adoptRef(new MediaStreamTrack(id, kind, label));
     35    return adoptRef(new MediaStreamTrack(streamDescriptor, trackIndex));
    3536}
    3637
    37 MediaStreamTrack::MediaStreamTrack(const String& id, const String& kind, const String& label)
    38     : m_id(id)
    39     , m_kind(kind)
    40     , m_label(label)
    41     , m_enabled(true)
     38MediaStreamTrack::MediaStreamTrack(PassRefPtr<MediaStreamDescriptor> streamDescriptor, size_t trackIndex)
     39    : m_streamDescriptor(streamDescriptor)
     40    , m_trackIndex(trackIndex)
    4241{
    4342}
    … …  
    4746}
    4847
    49 const String& MediaStreamTrack::kind() const
     48String MediaStreamTrack::kind() const
    5049{
    51     return m_kind;
     50    DEFINE_STATIC_LOCAL(String, audioKind, ("audio"));
     51    DEFINE_STATIC_LOCAL(String, videoKind, ("video"));
     52
     53    switch (m_streamDescriptor->component(m_trackIndex)->source()->type()) {
     54    case MediaStreamSource::TypeAudio:
     55        return audioKind;
     56    case MediaStreamSource::TypeVideo:
     57        return videoKind;
     58    }
     59
     60    ASSERT_NOT_REACHED();
    5261}
    5362
    54 const String& MediaStreamTrack::label() const
     63String MediaStreamTrack::label() const
    5564{
    56     return m_label;
     65    return m_streamDescriptor->component(m_trackIndex)->source()->name();
    5766}
    5867
    5968bool MediaStreamTrack::enabled() const
    6069{
    61     return m_enabled;
     70    return m_streamDescriptor->component(m_trackIndex)->enabled();
    6271}
    6372
    6473void MediaStreamTrack::setEnabled(bool enabled)
    6574{
    66     m_enabled = enabled;
     75    if (enabled == m_streamDescriptor->component(m_trackIndex)->enabled())
     76        return;
    6777
    68     if (mediaStreamFrameController())
    69         mediaStreamFrameController()->setMediaStreamTrackEnabled(m_id, enabled);
     78    m_streamDescriptor->component(m_trackIndex)->setEnabled(enabled);
     79
     80    // FIXME: tell the platform that the track was enabled/disabled
    7081}
    7182

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

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2829#if ENABLE(MEDIA_STREAM)
    2930
     31#include "MediaStreamDescriptor.h"
    3032#include "PlatformString.h"
    31 #include "MediaStreamFrameController.h"
    32 #include <wtf/PassRefPtr.h>
    3333#include <wtf/RefCounted.h>
     34#include <wtf/RefPtr.h>
    3435#include <wtf/Vector.h>
    3536
    3637namespace WebCore {
    3738
    38 class MediaStreamTrack : public RefCounted<MediaStreamTrack>,
    39                          public MediaStreamFrameController::GenericClient {
     39class MediaStreamTrack : public RefCounted<MediaStreamTrack> {
    4040public:
    41     static PassRefPtr<MediaStreamTrack> create(const String& id, const String& kind, const String& label);
     41    static PassRefPtr<MediaStreamTrack> create(PassRefPtr<MediaStreamDescriptor>, size_t trackIndex);
    4242    virtual ~MediaStreamTrack();
    4343
    44     const String& kind() const;
    45     const String& label() const;
     44    String kind() const;
     45    String label() const;
    4646
    4747    bool enabled() const;
    48     void setEnabled(bool enabled);
     48    void setEnabled(bool);
    4949
    5050private:
    51     MediaStreamTrack(const String& id, const String& kind, const String& label);
     51    MediaStreamTrack(PassRefPtr<MediaStreamDescriptor>, size_t trackIndex);
    5252
    53     String m_id;
    54     String m_kind;
    55     String m_label;
    56     bool m_enabled;
     53    RefPtr<MediaStreamDescriptor> m_streamDescriptor;
     54    const size_t m_trackIndex;
    5755};
    5856
    59 typedef Vector<RefPtr<MediaStreamTrack> > TrackVector;
     57typedef Vector<RefPtr<MediaStreamTrack> > MediaStreamTrackVector;
    6058
    6159} // namespace WebCore

  • trunk/Source/WebCore/dom/MediaStreamTrack.idl

    r91364 r97904  
    2828        Conditional=MEDIA_STREAM,
    2929    ] MediaStreamTrack {
    30       readonly attribute DOMString kind;
    31       readonly attribute DOMString label;
    32                attribute boolean enabled;
     30        readonly attribute DOMString kind;
     31        readonly attribute DOMString label;
     32                 attribute boolean enabled;
    3333    };
    3434

  • trunk/Source/WebCore/dom/MediaStreamTrackList.cpp

    r95901 r97904  
    11/*
    22 * Copyright (C) 2011 Google Inc. All rights reserved.
     3 * Copyright (C) 2011 Ericsson AB. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3031namespace WebCore {
    3132
    32 PassRefPtr<MediaStreamTrackList> MediaStreamTrackList::create(const TrackVector& tracks)
     33PassRefPtr<MediaStreamTrackList> MediaStreamTrackList::create(const MediaStreamTrackVector& trackVector)
    3334{
    34     return adoptRef(new MediaStreamTrackList(tracks));
     35    return adoptRef(new MediaStreamTrackList(trackVector));
    3536}
    3637
    37 MediaStreamTrackList::MediaStreamTrackList(const TrackVector& tracks)
    38     : m_tracks(tracks)
     38MediaStreamTrackList::MediaStreamTrackList(const MediaStreamTrackVector& trackVector)
     39    : m_trackVector(trackVector)
    3940{
    4041}
    … …  
    4647unsigned MediaStreamTrackList::length() const
    4748{
    48     return m_tracks.size();
     49    return m_trackVector.size();
    4950}
    5051
    51 PassRefPtr<MediaStreamTrack> MediaStreamTrackList::item(unsigned index) const
     52MediaStreamTrack* MediaStreamTrackList::item(unsigned index) const
    5253{
    53     if (index < m_tracks.size())
    54         return m_tracks.at(index);
    55     else
    56         return PassRefPtr<MediaStreamTrack>();
     54    ASSERT(index < length());
     55    return m_trackVector[index].get();
    5756}
    5857

  • trunk/Source/WebCore/dom/MediaStreamTrackList.h

    r95901 r97904  
    2929
    3030#include "MediaStreamTrack.h"
    31 #include <wtf/PassRefPtr.h>
    32 #include <wtf/RefCounted.h>
    33 #include <wtf/RefPtr.h>
    3431
    3532namespace WebCore {
    … …  
    3734class MediaStreamTrackList : public RefCounted<MediaStreamTrackList> {
    3835public:
    39     static PassRefPtr<MediaStreamTrackList> create(const TrackVector& m_tracks);
     36    static PassRefPtr<MediaStreamTrackList> create(const MediaStreamTrackVector&);
    4037    virtual ~MediaStreamTrackList();
    4138
    4239    // DOM methods & attributes for MediaStreamTrackList
    4340    unsigned length() const;
    44     PassRefPtr<MediaStreamTrack> item(unsigned index) const;
    45 
    46     void associateStream(const String& label) { m_associatedStreamLabel = label; }
     41    MediaStreamTrack* item(unsigned index) const;
    4742
    4843private:
    49     MediaStreamTrackList(const TrackVector& m_tracks);
     44    MediaStreamTrackList(const MediaStreamTrackVector&);
    5045
    51     TrackVector m_tracks;
    52     String m_associatedStreamLabel;
     46    MediaStreamTrackVector m_trackVector;
    5347};
    5448

  • trunk/Source/WebCore/p2p/PeerConnection.cpp

    r97305 r97904  
    130130    m_localStreams->append(stream);
    131131
    132     // FIXME: get from stream->descriptor() when it's available, see http://webkit.org/b/68464
    133     MediaStreamDescriptor* streamDescriptor = 0;
     132    MediaStreamDescriptor* streamDescriptor = stream->descriptor();
    134133    size_t i = m_pendingRemoveStreams.find(streamDescriptor);
    135134    if (i != notFound) {
    … …  
    157156    m_localStreams->remove(stream);
    158157
    159     // FIXME: get from stream->descriptor() when it's available, see http://webkit.org/b/68464
    160     MediaStreamDescriptor* streamDescriptor = 0;
     158    MediaStreamDescriptor* streamDescriptor = stream->descriptor();
    161159    size_t i = m_pendingAddStreams.find(streamDescriptor);
    162160    if (i != notFound) {
    … …  
    216214        return;
    217215
    218     // FIXME: create a new MediaStream from the streamDescriptor once it's possible, see http://webkit.org/b/68464
    219     RefPtr<MediaStream> stream = 0;
     216    RefPtr<MediaStream> stream = MediaStream::create(scriptExecutionContext(), streamDescriptor);
    220217    m_remoteStreams->append(stream);
    221218

  • trunk/Source/WebCore/page/MediaStreamClient.h

    r97305 r97904  
    4747    virtual void mediaStreamDestroyed() = 0;
    4848    virtual void generateStream(int requestId, GenerateStreamOptionFlags, PassRefPtr<SecurityOrigin>) = 0;
    49     virtual void stopGeneratedStream(const String& streamLabel) = 0;
    50     virtual void setMediaStreamTrackEnabled(const String& trackId, bool enabled) = 0;
    5149
    5250protected:

  • trunk/Source/WebCore/page/MediaStreamController.cpp

    r97305 r97904  
    2929
    3030#include "MediaStreamFrameController.h"
    31 #include "MediaStreamTrackList.h"
    3231#include "SecurityOrigin.h"
    3332#include <wtf/Vector.h>
    … …  
    8281    for (Vector<int>::iterator it = frameRequests.begin(); it != frameRequests.end(); ++it)
    8382        m_requests.remove(*it);
    84 
    85     Vector<String> frameStreams;
    86     for (StreamMap::iterator it = m_streams.begin(); it != m_streams.end(); ++it)
    87         if (it->second == frameController)
    88             frameStreams.append(it->first);
    89 
    90     for (Vector<String>::iterator it = frameStreams.begin(); it != frameStreams.end(); ++it)
    91         m_streams.remove(*it);
    92 
    93     // FIXME: Add unregister functionality for peer connection objects.
    9483}
    9584
    … …  
    10291}
    10392
    104 void MediaStreamController::registerStream(const String& streamLabel, MediaStreamFrameController* frameController)
    105 {
    106     ASSERT(frameController);
    107     ASSERT(!m_streams.contains(streamLabel));
    108     m_streams.add(streamLabel, frameController);
    109 }
    110 
    11193void MediaStreamController::generateStream(MediaStreamFrameController* frameController, int localId, GenerateStreamOptionFlags flags, PassRefPtr<SecurityOrigin> securityOrigin)
    11294{
    … …  
    11698}
    11799
    118 void MediaStreamController::stopGeneratedStream(const String& streamLabel)
    119 {
    120     m_client->stopGeneratedStream(streamLabel);
    121 }
    122 
    123 void MediaStreamController::setMediaStreamTrackEnabled(const String& trackId, bool enabled)
    124 {
    125     m_client->setMediaStreamTrackEnabled(trackId, enabled);
    126 }
    127 
    128 void MediaStreamController::streamGenerated(int controllerRequestId, const String& streamLabel, PassRefPtr<MediaStreamTrackList> tracks)
     100void MediaStreamController::streamGenerated(int controllerRequestId, const MediaStreamSourceVector& sources)
    129101{
    130102    // Don't assert since the frame controller can have been destroyed while the request reply was coming back.
    131103    if (m_requests.contains(controllerRequestId)) {
    132104        const Request& request = m_requests.get(controllerRequestId);
    133         registerStream(streamLabel, request.frameController());
    134105        m_requests.remove(controllerRequestId);
    135106        ASSERT(request.frameController());
    136         request.frameController()->streamGenerated(request.localId(), streamLabel, tracks);
     107        request.frameController()->streamGenerated(request.localId(), sources);
    137108    }
    138109}
    … …  
    148119}
    149120
    150 void MediaStreamController::streamFailed(const String& streamLabel)
    151 {
    152     // Don't assert since the frame controller can have been destroyed by the time this is called.
    153     if (m_streams.contains(streamLabel))
    154         m_streams.get(streamLabel)->streamFailed(streamLabel);
    155 }
    156 
    157121} // namespace WebCore
    158122

  • trunk/Source/WebCore/page/MediaStreamController.h

    r97305 r97904  
    2929
    3030#include "MediaStreamClient.h"
     31#include "MediaStreamSource.h"
    3132#include "NavigatorUserMediaError.h"
    3233#include <wtf/Forward.h>
    … …  
    3940class MediaStreamClient;
    4041class MediaStreamFrameController;
    41 class MediaStreamTrackList;
    4242class SecurityOrigin;
    4343
    … …  
    5252
    5353    void generateStream(MediaStreamFrameController*, int requestId, GenerateStreamOptionFlags, PassRefPtr<SecurityOrigin>);
    54     void stopGeneratedStream(const String& streamLabel);
    5554
    56     // Enable/disable an track.
    57     void setMediaStreamTrackEnabled(const String& trackId, bool enabled);
    58 
    59     void streamGenerated(int requestId, const String& streamLabel, PassRefPtr<MediaStreamTrackList> tracks);
     55    void streamGenerated(int requestId, const MediaStreamSourceVector& sources);
    6056    void streamGenerationFailed(int requestId, NavigatorUserMediaError::ErrorCode);
    61     void streamFailed(const String& streamLabel);
    6257
    6358private:
    6459    int registerRequest(int localRequestId, MediaStreamFrameController*);
    65     void registerStream(const String& streamLabel, MediaStreamFrameController*);
    6660
    6761    class Request;
    6862    typedef HashMap<int, Request> RequestMap;
    69     typedef HashMap<String, MediaStreamFrameController*> StreamMap;
    7063
    7164    RequestMap m_requests;
    72     StreamMap m_streams;
    7365
    7466    MediaStreamClient* m_client;

  • trunk/Source/WebCore/page/MediaStreamFrameController.cpp

    r97305 r97904  
    3333#include "LocalMediaStream.h"
    3434#include "MediaStreamController.h"
    35 #include "MediaStreamTrackList.h"
    3635#include "NavigatorUserMediaErrorCallback.h"
    3736#include "NavigatorUserMediaSuccessCallback.h"
    … …  
    4948    ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext; }
    5049    virtual bool isGenerateStreamRequest() const { return false; }
    51     virtual bool isRecordedDataRequest() const { return false; }
    52     virtual bool isSignalingRequest() const { return false; }
    5350
    5451    virtual void abort() = 0;
    … …  
    116113}
    117114
    118 template <typename T>
    119 void MediaStreamFrameController::ClientMapBase<T>::unregisterAll()
    120 {
    121     while (!this->isEmpty()) {
    122         T key = this->begin()->first;
    123         // unregister should remove the element from the map.
    124         this->begin()->second->unregister();
    125         ASSERT_UNUSED(key, !this->contains(key));
    126     }
    127 }
    128 
    129 template <typename T>
    130 void MediaStreamFrameController::ClientMapBase<T>::detachEmbedder()
    131 {
    132     for (typename MapType::iterator it = this->begin(); it != this->end(); ++it)
    133         it->second->detachEmbedder();
    134 }
    135 
    136115MediaStreamFrameController::MediaStreamFrameController(Frame* frame)
    137116    : m_frame(frame)
    … …  
    161140}
    162141
    163 void MediaStreamFrameController::unregister(MediaStreamClient* client)
    164 {
    165     ASSERT(m_streams.contains(client->clientId()));
    166 
    167     // Assuming we should stop any live streams when losing access to the embedder.
    168     if (client->isLocalMediaStream()) {
    169         LocalMediaStream* stream = static_cast<LocalMediaStream*>(client);
    170         if (stream->readyState() == MediaStream::LIVE)
    171             stopGeneratedStream(stream->label());
    172     }
    173 
    174     m_streams.remove(client->clientId());
    175 }
    176 
    177 void MediaStreamFrameController::unregister(GenericClient* client)
    178 {
    179     ASSERT(m_clients.contains(client->clientId()));
    180     m_clients.remove(client->clientId());
    181 }
    182 
    183 MediaStream* MediaStreamFrameController::getStreamFromLabel(const String& label) const
    184 {
    185     ASSERT(m_streams.contains(label));
    186     ASSERT(m_streams.get(label)->isMediaStream());
    187     return static_cast<MediaStream*>(m_streams.get(label));
    188 }
    189 
    190142void MediaStreamFrameController::enterDetachedState()
    191143{
    … …  
    196148
    197149    m_requests.abortAll();
    198     m_streams.detachEmbedder();
    199     m_clients.detachEmbedder();
    200150    m_isInDetachedState = true;
    201151}
    … …  
    225175
    226176    ASSERT(m_requests.isEmpty());
    227     m_streams.unregisterAll();
    228     m_clients.unregisterAll();
    229177
    230178    m_frame = 0;
    … …  
    299247}
    300248
    301 void MediaStreamFrameController::stopGeneratedStream(const String& streamLabel)
    302 {
    303     ASSERT(m_streams.contains(streamLabel));
    304     ASSERT(m_streams.get(streamLabel)->isLocalMediaStream());
    305 
    306     if (isClientAvailable())
    307         pageController()->stopGeneratedStream(streamLabel);
    308 }
    309 
    310 void MediaStreamFrameController::setMediaStreamTrackEnabled(const String& trackId, bool enabled)
    311 {
    312     if (isClientAvailable())
    313         pageController()->setMediaStreamTrackEnabled(trackId, enabled);
    314 }
    315 
    316 void MediaStreamFrameController::streamGenerated(int requestId, const String& label, PassRefPtr<MediaStreamTrackList> tracksParam)
     249void MediaStreamFrameController::streamGenerated(int requestId, const MediaStreamSourceVector& sources)
    317250{
    318251    // Don't assert since the request can have been aborted as a result of embedder detachment.
    … …  
    321254
    322255    ASSERT(m_requests.get(requestId)->isGenerateStreamRequest());
    323     ASSERT(!label.isNull());
    324     ASSERT(tracksParam);
    325 
    326     RefPtr<MediaStreamTrackList> tracks = tracksParam;
    327 
    328     for (unsigned i = 0; i < tracks->length(); ++i) {
    329         int trackClientId = m_clients.getNextId();
    330         RefPtr<MediaStreamTrack> track = tracks->item(i);
    331         track->associateFrameController(this, trackClientId);
    332         m_clients.add(trackClientId, track.get());
    333     }
    334256
    335257    RefPtr<GenerateStreamRequest> streamRequest = static_cast<GenerateStreamRequest*>(m_requests.get(requestId).get());
    336     RefPtr<LocalMediaStream> generatedStream = LocalMediaStream::create(this, label, tracks.release());
    337     m_streams.add(label, generatedStream.get());
     258    RefPtr<LocalMediaStream> generatedStream = LocalMediaStream::create(scriptExecutionContext(), sources);
    338259    m_requests.remove(requestId);
    339260    streamRequest->successCallback()->handleEvent(generatedStream.get());
    … …  
    357278}
    358279
    359 void MediaStreamFrameController::streamFailed(const String& label)
    360 {
    361     getStreamFromLabel(label)->streamEnded();
    362 }
    363 
    364280} // namespace WebCore
    365281

  • trunk/Source/WebCore/page/MediaStreamFrameController.h

    r97305 r97904  
    3030#include "ExceptionCode.h"
    3131#include "MediaStreamClient.h"
     32#include "MediaStreamSource.h"
    3233#include "NavigatorUserMediaError.h"
    3334#include <wtf/Forward.h>
    … …  
    3940
    4041class Frame;
    41 class LocalMediaStream;
    42 class MediaStream;
    4342class MediaStreamController;
    44 class MediaStreamTrackList;
    4543class NavigatorUserMediaErrorCallback;
    4644class NavigatorUserMediaSuccessCallback;
    … …  
    4846class ScriptExecutionContext;
    4947class SecurityOrigin;
    50 class SignalingCallback;
    5148
    5249class MediaStreamFrameController {
    5350    WTF_MAKE_NONCOPYABLE(MediaStreamFrameController);
    5451public:
    55     template <typename IdType>
    56     class ClientBase {
    57         WTF_MAKE_NONCOPYABLE(ClientBase);
    58     public:
    59         ClientBase() : m_frameController(0), m_clientId(0) { }
    60 
    61         ClientBase(MediaStreamFrameController* frameController, const IdType& id)
    62             : m_frameController(frameController)
    63             , m_clientId(id) { }
    64 
    65         virtual ~ClientBase() { }
    66 
    67         MediaStreamFrameController* mediaStreamFrameController() const { return m_frameController; }
    68         const IdType& clientId() const { return m_clientId; }
    69 
    70         virtual bool isMediaStream() const { return false; }
    71         virtual bool isLocalMediaStream() const { return false; }
    72         virtual bool isGenericClient() const { return false; }
    73 
    74         // Called when the frame controller is being disconnected to the MediaStreamClient embedder.
    75         // Clients should override this to send any required shutdown messages.
    76         virtual void detachEmbedder() { }
    77 
    78     protected:
    79         // Used for objects that are optionally associated to the frame controller after construction, like the MediaStreamTracks.
    80         void associateFrameController(MediaStreamFrameController* frameController, const IdType& id)
    81         {
    82             ASSERT(!m_frameController && !m_clientId);
    83             m_frameController = frameController;
    84             m_clientId = id;
    85         }
    86 
    87         // Avoids repeating the same code in the unregister method of each derived class.
    88         // This is required since the controller's unregister methods make use of the isObject virtuals,
    89         // and the unregistration can be triggered either by the destructor of the client or by the disconnection of the frame.
    90         template <typename ClientType>
    91         void unregisterClient(ClientType* client)
    92         {
    93             if (!m_frameController)
    94                 return;
    95 
    96             m_frameController->unregister(static_cast<ClientType*>(client));
    97             m_frameController = 0;
    98         }
    99 
    100         virtual void unregister() = 0;
    101         friend class MediaStreamFrameController;
    102 
    103         MediaStreamFrameController* m_frameController;
    104         IdType m_clientId;
    105     };
    106 
    107     class MediaStreamClient : public ClientBase<String> {
    108     public:
    109         MediaStreamClient(MediaStreamFrameController* frameController, const String& label, bool isLocalMediaStream)
    110             : ClientBase<String>(frameController, label)
    111             , m_isLocalMediaStream(isLocalMediaStream) { }
    112 
    113         virtual ~MediaStreamClient() { unregister(); }
    114 
    115         virtual bool isMediaStream() const { return true; }
    116 
    117         // Accessed by the destructor.
    118         virtual bool isLocalMediaStream() const { return m_isLocalMediaStream; }
    119 
    120         // Stream has ended for some external reason.
    121         virtual void streamEnded() = 0;
    122 
    123     private:
    124         virtual void unregister() { unregisterClient(this); }
    125         bool m_isLocalMediaStream;
    126     };
    127 
    128     // Generic clients are objects that require access to the frame controller but don't have a global id (like streams do)
    129     // or need to receive any messages from the embedder client.
    130     class GenericClient : public ClientBase<int> {
    131     public:
    132         GenericClient() { }
    133         GenericClient(MediaStreamFrameController* frameController, int id) : ClientBase<int>(frameController, id) { }
    134         virtual ~GenericClient() { unregister(); }
    135         virtual bool isGenericClient() const { return true; }
    136 
    137     private:
    138         virtual void unregister() { unregisterClient(this); }
    139     };
    140 
    14152    MediaStreamFrameController(Frame*);
    14253    virtual ~MediaStreamFrameController();
    … …  
    15263    static GenerateStreamOptionFlags parseGenerateStreamOptions(const String&);
    15364    void generateStream(const String& options, PassRefPtr<NavigatorUserMediaSuccessCallback>, PassRefPtr<NavigatorUserMediaErrorCallback>, ExceptionCode&);
    154     void stopGeneratedStream(const String& streamLabel);
    155     void setMediaStreamTrackEnabled(const String& trackId, bool enabled);
    15665
    15766    // --- Calls coming back from the controller. --- //
    15867
    159     void streamGenerated(int requestId, const String& streamLabel, PassRefPtr<MediaStreamTrackList> tracks);
     68    void streamGenerated(int requestId, const MediaStreamSourceVector& sources);
    16069    void streamGenerationFailed(int requestId, NavigatorUserMediaError::ErrorCode);
    161     void streamFailed(const String& streamLabel);
    16270
    16371private:
    … …  
    18189    };
    18290
    183     template <typename IdType>
    184     class ClientMapBase : public HashMap<IdType, ClientBase<IdType>* > {
    185         WTF_MAKE_NONCOPYABLE(ClientMapBase);
    186     public:
    187         typedef HashMap<IdType, ClientBase<IdType>* > MapType;
    188 
    189         ClientMapBase() { }
    190         void unregisterAll();
    191         void detachEmbedder();
    192     };
    193 
    194     // Streams are a special class of clients since they are identified by a global label string instead of an id.
    195     typedef ClientMapBase<String> StreamMap;
    196 
    197     // All other types of clients use autogenerated integer ids.
    198     class ClientMap : public IdGenerator, public ClientMapBase<int> { };
    199 
    20091    // Detached from a page, and hence from a embedder client.
    20192    void enterDetachedState();
    20293
    203     void unregister(MediaStreamClient*);
    204     void unregister(GenericClient*);
    20594    MediaStreamController* pageController() const;
    206     MediaStream* getStreamFromLabel(const String&) const;
    20795
    20896    RequestMap m_requests;
    209     ClientMap m_clients;
    210     StreamMap m_streams;
    21197
    21298    Frame* m_frame;

  • trunk/Source/WebKit/chromium/ChangeLog

    r97896 r97904  
     12011-10-19  Adam Bergkvist  <adam.bergkvist@ericsson.com>
     2
     3        Update MediaStream to use WebCore platform interfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=68464
     5
     6        Reviewed by Adam Barth.
     7
     8        Removed WebMediaStreamTrack* since they will no longer be needed.
     9
     10        * WebKit.gyp:
     11        * public/WebMediaStreamTrack.h: Removed.
     12        * public/WebMediaStreamTrackList.h: Removed.
     13        * src/WebMediaStreamTrack.cpp: Removed.
     14        * src/WebMediaStreamTrackList.cpp: Removed.
     15
    1162011-10-19  Zhenyao Mo  <zmo@google.com>
    217

  • trunk/Source/WebKit/chromium/WebKit.gyp

    r97550 r97904  
    229229                'public/WebMediaPlayerAction.h',
    230230                'public/WebMediaPlayerClient.h',
    231                 'public/WebMediaStreamTrack.h',
    232                 'public/WebMediaStreamTrackList.h',
    233231                'public/WebMenuItemInfo.h',
    234232                'public/WebMessagePortChannel.h',
    … …  
    554552                'src/WebMediaPlayerClientImpl.cpp',
    555553                'src/WebMediaPlayerClientImpl.h',
    556                 'src/WebMediaStreamTrack.cpp',
    557                 'src/WebMediaStreamTrackList.cpp',
    558554                'src/WebNamedNodeMap.cpp',
    559555                'src/WebNetworkStateNotifier.cpp',
Note: See TracChangeset for help on using the changeset viewer.