Changeset 158220 in webkit


Ignore:
Timestamp:
Oct 29, 2013 1:48:21 PM (10 years ago)
Author:
eric.carlson@apple.com
Message:

[Mac MediaStream] implement AVFoundation backed MediaStreamSource
​https://bugs.webkit.org/show_bug.cgi?id=123316

Source/WebCore:

Reviewed by Jer Noble

No new tests, existing tests updated.

  • CMakeLists.txt: Add MediaStreamSourceStates.cpp.
  • Modules/mediastream/MediaSourceStates.cpp:

(WebCore::MediaSourceStates::MediaSourceStates): m_SourceStates -> m_sourceStates.
(WebCore::MediaSourceStates::sourceType): Ditto.
(WebCore::MediaSourceStates::facingMode): Ditto.

  • Modules/mediastream/MediaSourceStates.h: Ditto.
  • Modules/mediastream/MediaSourceStates.idl: Mark some attributes as optional.
  • Modules/mediastream/MediaStream.cpp:

(WebCore::MediaStream::addTrack):
(WebCore::MediaStream::removeTrack):
(WebCore::MediaStream::addRemoteSource):
(WebCore::MediaStream::removeRemoteSource):

  • Modules/mediastream/MediaStreamCapabilities.cpp:

(WebCore::MediaStreamCapabilities::sourceType): MediaSourceStates -> MediaStreamSourceStates
(WebCore::MediaStreamCapabilities::facingMode): Ditto.

  • Modules/mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::MediaStreamTrack): Don't observe source changes directly, let the

private track do that. Change private track parameter to ref because it can't be NULL.

(WebCore::MediaStreamTrack::~MediaStreamTrack): Ditto.
(WebCore::MediaStreamTrack::setSource): Pass through to private track.
(WebCore::MediaStreamTrack::stopped): Ditto.
(WebCore::MediaStreamTrack::states): Ditto.
(WebCore::MediaStreamTrack::capabilities): Ditto.
(WebCore::MediaStreamTrack::applyConstraints): Ditto.
(WebCore::MediaStreamTrack::stopProducingData): Ditto.
(WebCore::MediaStreamTrack::trackReadyStateChanged): Renamed from sourceStateChanged. Don't

schedule an 'ended' event if called as a side effect of the stop() method having been
called as per spec.

(WebCore::MediaStreamTrack::trackMutedChanged): Renamed from sourceMutedChanged.
(WebCore::MediaStreamTrack::trackEnabledChanged): Renamed from sourceEnabledChanged.
(WebCore::MediaStreamTrack::stop): Pass through to private track.

  • Modules/mediastream/MediaStreamTrack.h:

(WebCore::MediaStreamTrack::Observer::~Observer): Add virtual destructor.

  • Modules/mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::callSuccessHandler): Set track, not source, constraints.

  • WebCore.xcodeproj/project.pbxproj: Add new files.
  • bindings/js/JSMediaSourceStatesCustom.cpp:

(WebCore::JSMediaSourceStates::facingMode): Return jsUndefined when the facing mode

is Unknown.

  • platform/mediastream/MediaStreamCenter.h: Remove unused class forward defines and

undefined method prototype.

  • platform/mediastream/MediaStreamDescriptor.cpp:

(WebCore::MediaStreamDescriptor::addSource): ASSERT if source is kind None.
(WebCore::MediaStreamDescriptor::removeSource): Ditto.
(WebCore::MediaStreamDescriptor::MediaStreamDescriptor):

  • platform/mediastream/MediaStreamSource.cpp:

(WebCore::MediaStreamSource::setReadyState): Call startProducingData when readyState changes

to Live, stopProducingData when it changes to Ended.

(WebCore::MediaStreamSource::removeObserver): Call stop() when there are no more observers.
(WebCore::MediaStreamSource::setEnabled): If passed false, do nothing unless all observers

are disabled. Call startProducingData/stopProducingData when becoming enabled/disabled.

(WebCore::MediaStreamSource::stop): Don't bother checking to see if other observers have

stopped, the spec says that track.stop() should permanently stop the track's source.

  • platform/mediastream/MediaStreamSource.h:

(WebCore::MediaStreamSource::name): Make virtual so derived classes can override.
(WebCore::MediaStreamSource::setName): Ditto.
(WebCore::MediaStreamSource::readyState): Ditto.
(WebCore::MediaStreamSource::enabled): Ditto.
(WebCore::MediaStreamSource::muted): Ditto.
(WebCore::MediaStreamSource::setReadonly): Ditto.
(WebCore::MediaStreamSource::remote): Ditto.
(WebCore::MediaStreamSource::setRemote): Ditto.
(WebCore::MediaStreamSource::startProducingData): Added.
(WebCore::MediaStreamSource::stopProducingData): Added.

  • platform/mediastream/MediaStreamSourceCapabilities.h: Move MediaStreamSourceStates to

its own file.

  • platform/mediastream/MediaStreamSourceStates.cpp: Added.

(WebCore::MediaStreamSourceStates::facingMode): Moved here from MediaSourceStates so the

strings are available to platform code.

(WebCore::MediaStreamSourceStates::sourceType): Ditto.

  • platform/mediastream/MediaStreamSourceStates.h: Added, moved from MediaStreamSourceCapabilities.h.
  • platform/mediastream/MediaStreamTrackPrivate.cpp:

(WebCore::MediaStreamTrackPrivate::create): Pass private track to constructor as PassRefPtr.
(WebCore::MediaStreamTrackPrivate::MediaStreamTrackPrivate): Initialize member variables.
(WebCore::MediaStreamTrackPrivate::~MediaStreamTrackPrivate): Unregister as source observer.
(WebCore::MediaStreamTrackPrivate::setSource): Unregister/register as source observer.
(WebCore::MediaStreamTrackPrivate::setEnabled): Enable/disable source, call client.
(WebCore::MediaStreamTrackPrivate::stop): New. Set readyState to Ended, optionally stop source.
(WebCore::MediaStreamTrackPrivate::setReadyState): Inline the logic from shouldFireTrackReadyStateChanged.
(WebCore::MediaStreamTrackPrivate::constraints): New, passthrough to the source.
(WebCore::MediaStreamTrackPrivate::states): Ditto.
(WebCore::MediaStreamTrackPrivate::type): Ditto.
(WebCore::MediaStreamTrackPrivate::capabilities): Ditto.
(WebCore::MediaStreamTrackPrivate::applyConstraints): Ditto.
(WebCore::MediaStreamTrackPrivate::sourceReadyStateChanged): React to source changes.
(WebCore::MediaStreamTrackPrivate::sourceMutedChanged): Ditto.
(WebCore::MediaStreamTrackPrivate::sourceEnabledChanged): Ditto.
(WebCore::MediaStreamTrackPrivate::observerIsEnabled): Respond to source query.
(WebCore::MediaStreamTrackPrivate::observerIsStopped): Ditto.

  • platform/mediastream/MediaStreamTrackPrivate.h:
  • platform/mediastream/mac/AVAudioCaptureSource.h: Added.
  • platform/mediastream/mac/AVAudioCaptureSource.mm: Added.
  • platform/mediastream/mac/AVCaptureDeviceManager.h: Added.
  • platform/mediastream/mac/AVCaptureDeviceManager.mm: Added.
  • platform/mediastream/mac/AVMediaCaptureSource.h: Added.
  • platform/mediastream/mac/AVMediaCaptureSource.mm: Added.
  • platform/mediastream/mac/AVVideoCaptureSource.h: Added.
  • platform/mediastream/mac/AVVideoCaptureSource.mm: Added.
  • platform/mediastream/mac/MediaStreamCenterMac.cpp:

(WebCore::MediaStreamCenterMac::validateRequestConstraints): Implement.
(WebCore::MediaStreamCenterMac::createMediaStream): Ditto.
(WebCore::MediaStreamCenterMac::getMediaStreamTrackSources): Ditto.

  • platform/mock/MockMediaStreamCenter.cpp:

(WebCore::initializeMockSources): Update for MediaStreamSourceStates changes.
(WebCore::MockMediaStreamCenter::createMediaStream):

LayoutTests:

Reviewed by Jer Noble.

  • fast/mediastream/MediaStream-add-remove-tracks-expected.txt: Updated.
  • fast/mediastream/MediaStream-add-remove-tracks.html: Ditto.
  • fast/mediastream/MediaStreamConstructor-expected.txt: Ditto.
  • fast/mediastream/MediaStreamConstructor.html: Ditto.
  • fast/mediastream/MediaStreamTrack-getSources.html: Remove typo.
  • fast/mediastream/MediaStreamTrack-expected.txt: Updated results.
  • fast/mediastream/MediaStreamTrack.html: Update to test track.stop() behavior.
Location:
trunk
Files:
10 added
33 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r158219 r158220  
     12013-10-29  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [Mac MediaStream] implement AVFoundation backed MediaStreamSource
     4        https://bugs.webkit.org/show_bug.cgi?id=123316
     5
     6        Reviewed by Jer Noble.
     7
     8        * fast/mediastream/MediaStream-add-remove-tracks-expected.txt: Updated.
     9        * fast/mediastream/MediaStream-add-remove-tracks.html: Ditto.
     10        * fast/mediastream/MediaStreamConstructor-expected.txt: Ditto.
     11        * fast/mediastream/MediaStreamConstructor.html: Ditto.
     12        * fast/mediastream/MediaStreamTrack-getSources.html: Remove typo.
     13        * fast/mediastream/MediaStreamTrack-expected.txt: Updated results.
     14        * fast/mediastream/MediaStreamTrack.html: Update to test track.stop() behavior.
     15
    1162013-10-29  Zoltan Horvath  <zoltan@webkit.org>
    217

  • trunk/LayoutTests/fast/mediastream/MediaStream-add-remove-tracks-expected.txt

    r157273 r158220  
    4343PASS stream1.getVideoTracks().length is 2
    4444
    45 *** after all tracks have been removed, stream.ended should return true
     45*** remove all tracks, stream.ended should return true
     46PASS stream2.getAudioTracks().length is 0
     47PASS stream2.getVideoTracks().length is 0
    4648PASS stream2.ended is true
    4749
    4850*** it should be impossible to add a track after the stream has ended
    49 PASS stream1.addTrack(audioTrack) threw exception Error: InvalidStateError: DOM Exception 11.
    50 PASS stream1.removeTrack(audioTrack) threw exception Error: InvalidStateError: DOM Exception 11.
     51PASS stream2.addTrack(audioTrack) threw exception Error: InvalidStateError: DOM Exception 11.
     52PASS stream2.removeTrack(audioTrack) threw exception Error: InvalidStateError: DOM Exception 11.
    5153PASS successfullyParsed is true
    5254

  • trunk/LayoutTests/fast/mediastream/MediaStream-add-remove-tracks.html

    r157273 r158220  
    110110    shouldBe('stream1.getVideoTracks().length', '2');
    111111
    112     debug("<br>*** after all tracks have been removed, stream.ended should return true");
     112    debug("<br>*** remove all tracks, stream.ended should return true");
    113113    tryRemoveTrack(stream2, stream2.getAudioTracks()[0]);
    114114    tryRemoveTrack(stream2, stream2.getVideoTracks()[0]);
     115    shouldBe('stream2.getAudioTracks().length', '0');
     116    shouldBe('stream2.getVideoTracks().length', '0');
    115117    shouldBeTrue('stream2.ended');
    116118
    117119    debug("<br>*** it should be impossible to add a track after the stream has ended");
    118     shouldThrow('stream1.addTrack(audioTrack)', '"Error: InvalidStateError: DOM Exception 11"');
    119     shouldThrow('stream1.removeTrack(audioTrack)', '"Error: InvalidStateError: DOM Exception 11"');
     120    shouldThrow('stream2.addTrack(audioTrack)', '"Error: InvalidStateError: DOM Exception 11"');
     121    shouldThrow('stream2.removeTrack(audioTrack)', '"Error: InvalidStateError: DOM Exception 11"');
    120122
    121123    setTimeout(finishJSTest, 0);

  • trunk/LayoutTests/fast/mediastream/MediaStreamConstructor-expected.txt

    r157273 r158220  
    7979PASS newStream.getVideoTracks().length is nVideo
    8080PASS checkIdAttribute(newStream.id) is true
     81PASS successfullyParsed is true
    8182
    8283TEST COMPLETE

  • trunk/LayoutTests/fast/mediastream/MediaStreamConstructor.html

    r157273 r158220  
    8585    verifyStream("new webkitMediaStream([stream.getAudioTracks()[0], stream.getVideoTracks()[0]])", 1, 1);
    8686    verifyStream("new webkitMediaStream([stream.getVideoTracks()[0], stream.getAudioTracks()[0], stream.getVideoTracks()[0]])", 1, 1);
     87
     88    finishJSTest();
    8789}
    8890

  • trunk/LayoutTests/fast/mediastream/MediaStreamTrack-expected.txt

    r157068 r158220  
    2727   supported : true
    2828  aspectRatio
    29    min : 1.3333333730697632
    30    max : 1.7777777910232544
     29   min : 1.33
     30   max : 1.78
    3131   supported : true
    3232  facingMode
    … …  
    3636PASS states.sourceId is capabilities.sourceId[0]
    3737PASS states.sourceType is "camera"
    38   width : 1920
    39   height : 1080
    40   frameRate : 30
    41   aspectRatio : 1.7777777910232544
    42   facingMode : user
     38  states.volume = undefined
     39  states.width = 1920
     40  states.sourceId = 239c24b0-2b15-11e3-8224-0800200c9a66
     41  states.height = 1080
     42  states.sourceType = camera
     43  states.facingMode = user
     44  states.frameRate = 30
     45  states.aspectRatio = 1.78
    4346
    4447audioTrack = mediaStream.getAudioTracks()[0]
    … …  
    5457PASS states.sourceId is capabilities.sourceId[0]
    5558PASS states.sourceType is "microphone"
    56   volume : 50
     59  states.volume = 50
     60  states.width = undefined
     61  states.sourceId = 239c24b1-2b15-11e3-8224-0800200c9a66
     62  states.height = undefined
     63  states.sourceType = microphone
     64  states.facingMode = undefined
     65  states.frameRate = undefined
     66  states.aspectRatio = undefined
    5767
    5868videoTrack2 = videoTrack.clone()
    … …  
    7787   supported : true
    7888  aspectRatio
    79    min : 1.3333333730697632
    80    max : 1.7777777910232544
     89   min : 1.33
     90   max : 1.78
    8191   supported : true
    8292  facingMode
    … …  
    8696PASS states.sourceId is capabilities.sourceId[0]
    8797PASS states.sourceType is "camera"
    88   width : 1920
    89   height : 1080
    90   frameRate : 30
    91   aspectRatio : 1.7777777910232544
    92   facingMode : user
     98  states.volume = undefined
     99  states.width = 1920
     100  states.sourceId = 239c24b0-2b15-11e3-8224-0800200c9a66
     101  states.height = 1080
     102  states.sourceType = camera
     103  states.facingMode = user
     104  states.frameRate = 30
     105  states.aspectRatio = 1.78
    93106PASS videoTrack.id is not videoTrack2.id
    94107PASS videoTrack.kind is videoTrack2.kind
    … …  
    98111PASS videoTrack.readyState is videoTrack2.readyState
    99112
    100 videoTrack.stop()
     113track.stop() should not fire 'ended' on the track it is called on, but it should end all tracks using the same source
     114videoTrack2.stop()
    101115PASS Track onended callback succeeded.
     116PASS videoTrack is event.target
    102117PASS videoTrack.readyState is "ended"
     118PASS videoTrack2.readyState is "ended"
    103119
    104120PASS successfullyParsed is true

  • trunk/LayoutTests/fast/mediastream/MediaStreamTrack-getSources.html

    r156554 r158220  
    3232                    constraints = _constraints;
    3333                    callback = _callback;
    34                 debug("<br>*** calling navigator.webkitGetUserMedia() ***");
     34                    debug("<br>*** calling navigator.webkitGetUserMedia() ***");
    3535                    shouldNotThrow("navigator.webkitGetUserMedia(constraints, callback, error)");
    3636                } catch (e) {

  • trunk/LayoutTests/fast/mediastream/MediaStreamTrack.html

    r157068 r158220  
    2424                }
    2525            }
    26            
     26
    2727            function onTrackEnded()
    2828            {
    2929                testPassed('Track onended callback succeeded.');
     30                shouldBe('videoTrack', 'event.target');
    3031                shouldBeEqualToString('videoTrack.readyState', 'ended');
     32                shouldBeEqualToString('videoTrack2.readyState', 'ended');
    3133                debug("");
    3234                finishJSTest();
    … …  
    5759                shouldBeEqual('videoTrack.muted', true);
    5860            }
     61           
     62            function limitPrecision(value, precision)
     63            {
     64                if (typeof value === "number" && value % 1 != 0)
     65                    return value.toFixed(precision);
     66                return value;
     67            }
    5968
    6069            function logCapabilityRange(name, range)
    6170            {
    6271                debug("  " + name);
    63                 debug("   min : " + range.min);
    64                 debug("   max : " + range.max);
     72                debug("   min : " + limitPrecision(range.min, 2));
     73                debug("   max : " + limitPrecision(range.max, 2));
    6574                debug("   supported : " + range.supported);
    6675            }
    … …  
    7079                debug("  " + name);
    7180                for (i = 0; i < list.length; i++)
    72                 debug("    " + i + " : " + list[i]);
     81                    debug("    " + i + " : " + list[i]);
    7382            }
    7483
    … …  
    95104                states = track.states();
    96105                shouldBe('states.sourceId', 'capabilities.sourceId[0]');
    97                 if (track.kind == "video") {
     106                if (track.kind == "video")
    98107                    shouldBeEqualToString('states.sourceType', 'camera');
    99                     debug("  width : " + states.width);
    100                     debug("  height : " + states.height);
    101                     debug("  frameRate : " + states.frameRate);
    102                     debug("  aspectRatio : " + states.aspectRatio);
    103                     debug("  facingMode : " + states.facingMode);
    104                 } else {
     108                else
    105109                    shouldBeEqualToString('states.sourceType', 'microphone');
    106                     debug("  volume : " + states.volume);
     110                for (var property in states) {
     111                    if (states.hasOwnProperty(property))
     112                        debug("  states." + property + " = " + limitPrecision(states[property], 2));
    107113                }
    108114            }
    … …  
    137143                debug("");
    138144                evalAndLog("videoTrack2 = videoTrack.clone()");
     145                videoTrack2.onended = onTrackEnded;
    139146                checkTrack(videoTrack2);
    140147                shouldNotBe('videoTrack.id', 'videoTrack2.id');
    … …  
    146153
    147154                debug("");
    148                 evalAndLog("videoTrack.stop()");
     155                debug("track.stop() should not fire 'ended' on the track it is called on, but it should end all tracks using the same source");
     156                evalAndLog("videoTrack2.stop()");
    149157            }
    150158

  • trunk/Source/WebCore/CMakeLists.txt

    r158203 r158220  
    19911991    platform/mediastream/MediaStreamTrackPrivate.cpp
    19921992    platform/mediastream/MediaStreamSource.cpp
     1993    platform/mediastream/MediaStreamSourceStates.cpp
    19931994    platform/mediastream/RTCIceCandidateDescriptor.cpp
    19941995    platform/mediastream/RTCPeerConnectionHandler.cpp

  • trunk/Source/WebCore/ChangeLog

    r158219 r158220  
     12013-10-29  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [Mac MediaStream] implement AVFoundation backed MediaStreamSource
     4        https://bugs.webkit.org/show_bug.cgi?id=123316
     5
     6        Reviewed by Jer Noble
     7
     8        No new tests, existing tests updated.
     9
     10        * CMakeLists.txt: Add MediaStreamSourceStates.cpp.
     11
     12        * Modules/mediastream/MediaSourceStates.cpp:
     13        (WebCore::MediaSourceStates::MediaSourceStates): m_SourceStates -> m_sourceStates.
     14        (WebCore::MediaSourceStates::sourceType): Ditto.
     15        (WebCore::MediaSourceStates::facingMode): Ditto.
     16        * Modules/mediastream/MediaSourceStates.h: Ditto.
     17        * Modules/mediastream/MediaSourceStates.idl: Mark some attributes as optional.
     18
     19        * Modules/mediastream/MediaStream.cpp:
     20        (WebCore::MediaStream::addTrack):
     21        (WebCore::MediaStream::removeTrack):
     22        (WebCore::MediaStream::addRemoteSource):
     23        (WebCore::MediaStream::removeRemoteSource):
     24
     25        * Modules/mediastream/MediaStreamCapabilities.cpp:
     26        (WebCore::MediaStreamCapabilities::sourceType): MediaSourceStates -> MediaStreamSourceStates
     27        (WebCore::MediaStreamCapabilities::facingMode): Ditto.
     28
     29        * Modules/mediastream/MediaStreamTrack.cpp:
     30        (WebCore::MediaStreamTrack::MediaStreamTrack): Don't observe source changes directly, let the
     31            private track do that. Change private track parameter to ref because it can't be NULL.
     32        (WebCore::MediaStreamTrack::~MediaStreamTrack): Ditto.
     33        (WebCore::MediaStreamTrack::setSource): Pass through to private track.
     34        (WebCore::MediaStreamTrack::stopped): Ditto.
     35        (WebCore::MediaStreamTrack::states): Ditto.
     36        (WebCore::MediaStreamTrack::capabilities): Ditto.
     37        (WebCore::MediaStreamTrack::applyConstraints): Ditto.
     38        (WebCore::MediaStreamTrack::stopProducingData): Ditto.
     39        (WebCore::MediaStreamTrack::trackReadyStateChanged): Renamed from sourceStateChanged. Don't
     40            schedule an 'ended' event if called as a side effect of the stop() method having been
     41            called as per spec.
     42        (WebCore::MediaStreamTrack::trackMutedChanged): Renamed from sourceMutedChanged.
     43        (WebCore::MediaStreamTrack::trackEnabledChanged): Renamed from sourceEnabledChanged.
     44        (WebCore::MediaStreamTrack::stop): Pass through to private track.
     45        * Modules/mediastream/MediaStreamTrack.h:
     46        (WebCore::MediaStreamTrack::Observer::~Observer): Add virtual destructor.
     47
     48        * Modules/mediastream/UserMediaRequest.cpp:
     49        (WebCore::UserMediaRequest::callSuccessHandler): Set track, not source, constraints.
     50
     51        * WebCore.xcodeproj/project.pbxproj: Add new files.
     52
     53        * bindings/js/JSMediaSourceStatesCustom.cpp:
     54        (WebCore::JSMediaSourceStates::facingMode): Return jsUndefined when the facing mode
     55            is Unknown.
     56
     57        * platform/mediastream/MediaStreamCenter.h: Remove unused class forward defines and
     58            undefined method prototype.
     59
     60        * platform/mediastream/MediaStreamDescriptor.cpp:
     61        (WebCore::MediaStreamDescriptor::addSource): ASSERT if source is kind None.
     62        (WebCore::MediaStreamDescriptor::removeSource): Ditto.
     63        (WebCore::MediaStreamDescriptor::MediaStreamDescriptor):
     64
     65        * platform/mediastream/MediaStreamSource.cpp:
     66        (WebCore::MediaStreamSource::setReadyState): Call startProducingData when readyState changes
     67            to Live, stopProducingData when it changes to Ended.
     68        (WebCore::MediaStreamSource::removeObserver): Call stop() when there are no more observers.
     69        (WebCore::MediaStreamSource::setEnabled): If passed false, do nothing unless all observers
     70            are disabled. Call startProducingData/stopProducingData when becoming enabled/disabled.
     71        (WebCore::MediaStreamSource::stop): Don't bother checking to see if other observers have
     72            stopped, the spec says that track.stop() should permanently stop the track's source.
     73        * platform/mediastream/MediaStreamSource.h:
     74        (WebCore::MediaStreamSource::name): Make virtual so derived classes can override.
     75        (WebCore::MediaStreamSource::setName): Ditto.
     76        (WebCore::MediaStreamSource::readyState): Ditto.
     77        (WebCore::MediaStreamSource::enabled): Ditto.
     78        (WebCore::MediaStreamSource::muted): Ditto.
     79        (WebCore::MediaStreamSource::setReadonly): Ditto.
     80        (WebCore::MediaStreamSource::remote): Ditto.
     81        (WebCore::MediaStreamSource::setRemote): Ditto.
     82        (WebCore::MediaStreamSource::startProducingData): Added.
     83        (WebCore::MediaStreamSource::stopProducingData): Added.
     84
     85        * platform/mediastream/MediaStreamSourceCapabilities.h: Move MediaStreamSourceStates to
     86            its own file.
     87
     88        * platform/mediastream/MediaStreamSourceStates.cpp: Added.
     89        (WebCore::MediaStreamSourceStates::facingMode): Moved here from MediaSourceStates so the
     90            strings are available to platform code.
     91        (WebCore::MediaStreamSourceStates::sourceType): Ditto.
     92        * platform/mediastream/MediaStreamSourceStates.h: Added, moved from MediaStreamSourceCapabilities.h.
     93
     94        * platform/mediastream/MediaStreamTrackPrivate.cpp:
     95        (WebCore::MediaStreamTrackPrivate::create): Pass private track to constructor as PassRefPtr.
     96        (WebCore::MediaStreamTrackPrivate::MediaStreamTrackPrivate): Initialize member variables.
     97        (WebCore::MediaStreamTrackPrivate::~MediaStreamTrackPrivate): Unregister as source observer.
     98        (WebCore::MediaStreamTrackPrivate::setSource): Unregister/register as source observer.
     99        (WebCore::MediaStreamTrackPrivate::setEnabled): Enable/disable source, call client.
     100        (WebCore::MediaStreamTrackPrivate::stop): New. Set readyState to Ended, optionally stop source.
     101        (WebCore::MediaStreamTrackPrivate::setReadyState): Inline the logic from shouldFireTrackReadyStateChanged.
     102        (WebCore::MediaStreamTrackPrivate::constraints): New, passthrough to the source.
     103        (WebCore::MediaStreamTrackPrivate::states): Ditto.
     104        (WebCore::MediaStreamTrackPrivate::type): Ditto.
     105        (WebCore::MediaStreamTrackPrivate::capabilities): Ditto.
     106        (WebCore::MediaStreamTrackPrivate::applyConstraints): Ditto.
     107        (WebCore::MediaStreamTrackPrivate::sourceReadyStateChanged): React to source changes.
     108        (WebCore::MediaStreamTrackPrivate::sourceMutedChanged): Ditto.
     109        (WebCore::MediaStreamTrackPrivate::sourceEnabledChanged): Ditto.
     110        (WebCore::MediaStreamTrackPrivate::observerIsEnabled): Respond to source query.
     111        (WebCore::MediaStreamTrackPrivate::observerIsStopped): Ditto.
     112        * platform/mediastream/MediaStreamTrackPrivate.h:
     113
     114        * platform/mediastream/mac/AVAudioCaptureSource.h: Added.
     115        * platform/mediastream/mac/AVAudioCaptureSource.mm: Added.
     116
     117        * platform/mediastream/mac/AVCaptureDeviceManager.h: Added.
     118        * platform/mediastream/mac/AVCaptureDeviceManager.mm: Added.
     119
     120        * platform/mediastream/mac/AVMediaCaptureSource.h: Added.
     121        * platform/mediastream/mac/AVMediaCaptureSource.mm: Added.
     122
     123        * platform/mediastream/mac/AVVideoCaptureSource.h: Added.
     124        * platform/mediastream/mac/AVVideoCaptureSource.mm: Added.
     125
     126        * platform/mediastream/mac/MediaStreamCenterMac.cpp:
     127        (WebCore::MediaStreamCenterMac::validateRequestConstraints): Implement.
     128        (WebCore::MediaStreamCenterMac::createMediaStream): Ditto.
     129        (WebCore::MediaStreamCenterMac::getMediaStreamTrackSources): Ditto.
     130
     131        * platform/mock/MockMediaStreamCenter.cpp:
     132        (WebCore::initializeMockSources): Update for MediaStreamSourceStates changes.
     133        (WebCore::MockMediaStreamCenter::createMediaStream):
     134
    11352013-10-29  Zoltan Horvath  <zoltan@webkit.org>
    2136

  • trunk/Source/WebCore/Modules/mediastream/AudioStreamTrack.cpp

    r158018 r158220  
    3838RefPtr<AudioStreamTrack> AudioStreamTrack::create(ScriptExecutionContext* context, const Dictionary& audioConstraints)
    3939{
    40     return adoptRef(new AudioStreamTrack(context, MediaStreamTrackPrivate::create(0), &audioConstraints));
     40    return adoptRef(new AudioStreamTrack(context, *MediaStreamTrackPrivate::create(0), &audioConstraints));
    4141}
    4242
    43 RefPtr<AudioStreamTrack> AudioStreamTrack::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack)
     43RefPtr<AudioStreamTrack> AudioStreamTrack::create(ScriptExecutionContext* context, MediaStreamTrackPrivate& privateTrack)
    4444{
    4545    return adoptRef(new AudioStreamTrack(context, privateTrack, 0));
    … …  
    5151}
    5252
    53 AudioStreamTrack::AudioStreamTrack(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack, const Dictionary* audioConstraints)
     53AudioStreamTrack::AudioStreamTrack(ScriptExecutionContext* context, MediaStreamTrackPrivate& privateTrack, const Dictionary* audioConstraints)
    5454    : MediaStreamTrack(context, privateTrack, audioConstraints)
    5555{

  • trunk/Source/WebCore/Modules/mediastream/AudioStreamTrack.h

    r158018 r158220  
    4141public:
    4242    static RefPtr<AudioStreamTrack> create(ScriptExecutionContext*, const Dictionary&);
    43     static RefPtr<AudioStreamTrack> create(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>);
     43    static RefPtr<AudioStreamTrack> create(ScriptExecutionContext*, MediaStreamTrackPrivate&);
    4444    static RefPtr<AudioStreamTrack> create(MediaStreamTrack*);
    4545
    … …  
    4949
    5050private:
    51     AudioStreamTrack(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>, const Dictionary*);
     51    AudioStreamTrack(ScriptExecutionContext*, MediaStreamTrackPrivate&, const Dictionary*);
    5252    explicit AudioStreamTrack(MediaStreamTrack*);
    5353};

  • trunk/Source/WebCore/Modules/mediastream/MediaSourceStates.cpp

    r157068 r158220  
    4040
    4141MediaSourceStates::MediaSourceStates(const MediaStreamSourceStates& states)
    42     : m_SourceStates(states)
     42    : m_sourceStates(states)
    4343{
    44 }
    45 
    46 const AtomicString& MediaSourceStates::facingMode(MediaStreamSourceStates::VideoFacingMode mode)
    47 {
    48     static NeverDestroyed<AtomicString> userFacing("user", AtomicString::ConstructFromLiteral);
    49     static NeverDestroyed<AtomicString> environmentFacing("environment", AtomicString::ConstructFromLiteral);
    50     static NeverDestroyed<AtomicString> leftFacing("left", AtomicString::ConstructFromLiteral);
    51     static NeverDestroyed<AtomicString> rightFacing("right", AtomicString::ConstructFromLiteral);
    52    
    53     switch (mode) {
    54     case MediaStreamSourceStates::User:
    55         return userFacing;
    56     case MediaStreamSourceStates::Environment:
    57         return environmentFacing;
    58     case MediaStreamSourceStates::Left:
    59         return leftFacing;
    60     case MediaStreamSourceStates::Right:
    61         return rightFacing;
    62     }
    63 
    64     ASSERT_NOT_REACHED();
    65     return emptyAtom;
    66 }
    67 
    68 const AtomicString& MediaSourceStates::sourceType(MediaStreamSourceStates::SourceType sourceType)
    69 {
    70     static NeverDestroyed<AtomicString> none("none", AtomicString::ConstructFromLiteral);
    71     static NeverDestroyed<AtomicString> camera("camera", AtomicString::ConstructFromLiteral);
    72     static NeverDestroyed<AtomicString> microphone("microphone", AtomicString::ConstructFromLiteral);
    73 
    74     switch (sourceType) {
    75     case MediaStreamSourceStates::None:
    76         return none;
    77     case MediaStreamSourceStates::Camera:
    78         return camera;
    79     case MediaStreamSourceStates::Microphone:
    80         return microphone;
    81     }
    82 
    83     ASSERT_NOT_REACHED();
    84     return emptyAtom;
    8544}
    8645
    8746const AtomicString& MediaSourceStates::sourceType() const
    8847{
    89     return MediaSourceStates::sourceType(m_SourceStates.sourceType);
     48    return MediaStreamSourceStates::sourceType(m_sourceStates.sourceType());
    9049}
    9150
    9251const AtomicString& MediaSourceStates::facingMode() const
    9352{
    94     return MediaSourceStates::facingMode(m_SourceStates.facingMode);
     53    return MediaStreamSourceStates::facingMode(m_sourceStates.facingMode());
    9554}
    9655

  • trunk/Source/WebCore/Modules/mediastream/MediaSourceStates.h

    r157068 r158220  
    4040    static RefPtr<MediaSourceStates> create(const MediaStreamSourceStates&);
    4141
    42     static const AtomicString& sourceType(MediaStreamSourceStates::SourceType);
    43     static const AtomicString& facingMode(MediaStreamSourceStates::VideoFacingMode);
     42    const AtomicString& sourceType() const;
     43    const AtomicString& sourceId() const { return m_sourceStates.sourceId(); }
     44    unsigned long width() const { return m_sourceStates.width(); }
     45    unsigned long height() const { return m_sourceStates.height(); }
     46    float frameRate() const { return m_sourceStates.frameRate(); }
     47    float aspectRatio() const { return m_sourceStates.aspectRatio(); }
     48    const AtomicString& facingMode() const;
     49    unsigned long volume() const { return m_sourceStates.volume(); }
    4450   
    45     const AtomicString& sourceType() const;
    46     const AtomicString& sourceId() const { return m_SourceStates.sourceId; }
    47     unsigned long width() const { return m_SourceStates.width; }
    48     unsigned long height() const { return m_SourceStates.height; }
    49     float frameRate() const { return m_SourceStates.frameRate; }
    50     float aspectRatio() const { return m_SourceStates.aspectRatio; }
    51     const AtomicString& facingMode() const;
    52     unsigned long volume() const { return m_SourceStates.volume; }
    53    
    54     bool hasVideoSource() const { return m_SourceStates.sourceType == MediaStreamSourceStates::Camera; }
     51    bool hasVideoSource() const { return m_sourceStates.sourceType() == MediaStreamSourceStates::Camera; }
    5552
    5653private:
    5754    explicit MediaSourceStates(const MediaStreamSourceStates&);
    5855
    59     MediaStreamSourceStates m_SourceStates;
     56    MediaStreamSourceStates m_sourceStates;
    6057};
    6158

  • trunk/Source/WebCore/Modules/mediastream/MediaSourceStates.idl

    r157068 r158220  
    3535    readonly attribute DOMString sourceId;
    3636
    37     [CustomGetter] readonly attribute unsigned long width;
    38     [CustomGetter] readonly attribute unsigned long height;
    39     [CustomGetter] readonly attribute float frameRate;
    40     [CustomGetter] readonly attribute float aspectRatio;
    41     [CustomGetter] readonly attribute VideoFacingModeEnum facingMode;
    42     [CustomGetter] readonly attribute unsigned long volume;
     37    [CustomGetter] readonly attribute unsigned long? width;
     38    [CustomGetter] readonly attribute unsigned long? height;
     39    [CustomGetter] readonly attribute float? frameRate;
     40    [CustomGetter] readonly attribute float? aspectRatio;
     41    [CustomGetter] readonly attribute VideoFacingModeEnum? facingMode;
     42    [CustomGetter] readonly attribute unsigned long? volume;
    4343};
    4444

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

    r158018 r158220  
    123123    m_audioTracks.reserveCapacity(numberOfAudioTracks);
    124124    for (size_t i = 0; i < numberOfAudioTracks; i++) {
    125         track = AudioStreamTrack::create(context, m_descriptor->audioTracks(i));
     125        track = AudioStreamTrack::create(context, *m_descriptor->audioTracks(i));
    126126        track->addObserver(this);
    127127        m_audioTracks.append(track.release());
    … …  
    131131    m_videoTracks.reserveCapacity(numberOfVideoTracks);
    132132    for (size_t i = 0; i < numberOfVideoTracks; i++) {
    133         track = VideoStreamTrack::create(context, m_descriptor->videoTracks(i));
     133        track = VideoStreamTrack::create(context, *m_descriptor->videoTracks(i));
    134134        track->addObserver(this);
    135135        m_videoTracks.append(track.release());
    … …  
    191191    case MediaStreamSource::Video:
    192192        m_videoTracks.append(track);
     193        break;
     194    case MediaStreamSource::None:
     195        ASSERT_NOT_REACHED();
    193196        break;
    194197    }
    … …  
    223226        if (pos != notFound)
    224227            m_videoTracks.remove(pos);
     228        break;
     229    case MediaStreamSource::None:
     230        ASSERT_NOT_REACHED();
    225231        break;
    226232    }
    … …  
    309315    switch (source->type()) {
    310316    case MediaStreamSource::Audio:
    311         track = AudioStreamTrack::create(scriptExecutionContext(), MediaStreamTrackPrivate::create(source));
     317        track = AudioStreamTrack::create(scriptExecutionContext(), *MediaStreamTrackPrivate::create(source));
    312318        m_audioTracks.append(track);
    313319        break;
    314320    case MediaStreamSource::Video:
    315         track = VideoStreamTrack::create(scriptExecutionContext(), MediaStreamTrackPrivate::create(source));
     321        track = VideoStreamTrack::create(scriptExecutionContext(), *MediaStreamTrackPrivate::create(source));
    316322        m_videoTracks.append(track);
     323        break;
     324    case MediaStreamSource::None:
     325        ASSERT_NOT_REACHED();
    317326        break;
    318327    }
    … …  
    335344    case MediaStreamSource::Video:
    336345        tracks = &m_videoTracks;
     346        break;
     347    case MediaStreamSource::None:
     348        ASSERT_NOT_REACHED();
    337349        break;
    338350    }

  • trunk/Source/WebCore/Modules/mediastream/MediaStreamCapabilities.cpp

    r157068 r158220  
    6464   
    6565    for (size_t i = 0; i < count; ++i)
    66         capabilities.append(MediaSourceStates::sourceType(sourceTypes[i]));
     66        capabilities.append(MediaStreamSourceStates::sourceType(sourceTypes[i]));
    6767   
    6868    return capabilities;
    … …  
    9898   
    9999    for (size_t i = 0; i < count; ++i)
    100         capabilities.append(MediaSourceStates::facingMode(facingModes[i]));
     100        capabilities.append(MediaStreamSourceStates::facingMode(facingModes[i]));
    101101   
    102102    return capabilities;

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

    r158018 r158220  
    3636#include "Event.h"
    3737#include "ExceptionCode.h"
     38#include "ExceptionCodePlaceholder.h"
    3839#include "MediaConstraintsImpl.h"
    3940#include "MediaSourceStates.h"
    … …  
    4546#include "MediaTrackConstraints.h"
    4647#include "NotImplemented.h"
    47 #include "UUID.h"
    4848#include "VideoStreamTrack.h"
    4949#include <wtf/Functional.h>
    … …  
    5252namespace WebCore {
    5353
    54 MediaStreamTrack::MediaStreamTrack(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack, const Dictionary*)
     54MediaStreamTrack::MediaStreamTrack(ScriptExecutionContext* context, MediaStreamTrackPrivate& privateTrack, const Dictionary* constraints)
    5555    : ActiveDOMObject(context)
    5656    , m_privateTrack(privateTrack)
    5757    , m_eventDispatchScheduled(false)
     58    , m_stoppingTrack(false)
    5859{
    5960    suspendIfNeeded();
    6061
    61     if (m_privateTrack->source())
    62         m_privateTrack->source()->addObserver(this);
     62    m_privateTrack->setClient(this);
     63
     64    if (constraints)
     65        applyConstraints(*constraints);
    6366}
    6467
    6568MediaStreamTrack::MediaStreamTrack(MediaStreamTrack* other)
    6669    : ActiveDOMObject(other->scriptExecutionContext())
     70    , m_privateTrack(*other->privateTrack().clone())
     71    , m_eventDispatchScheduled(false)
     72    , m_stoppingTrack(false)
    6773{
    6874    suspendIfNeeded();
    6975
    70     m_privateTrack = other->privateTrack()->clone();
    71 
    72     if (m_privateTrack->source())
    73         m_privateTrack->source()->addObserver(this);
    74 
    75     m_eventDispatchScheduled = false;
     76    m_privateTrack->setClient(this);
    7677}
    7778
    7879MediaStreamTrack::~MediaStreamTrack()
    7980{
    80 }
    81 
    82 const AtomicString& MediaStreamTrack::kind() const
    83 {
    84     return m_privateTrack->kind();
    85 }
    86 
    87 void MediaStreamTrack::setSource(MediaStreamSource* newSource)
    88 {
    89     MediaStreamSource* trackSource = source();
    90 
    91     if (trackSource)
    92         trackSource->removeObserver(this);
    93 
    94     if (newSource)
    95         newSource->addObserver(this);
    96 
     81    m_privateTrack->setClient(nullptr);
     82}
     83
     84void MediaStreamTrack::setSource(PassRefPtr<MediaStreamSource> newSource)
     85{
    9786    m_privateTrack->setSource(newSource);
    9887}
    … …  
    116105{
    117106    m_privateTrack->setEnabled(enabled);
     107}
     108
     109bool MediaStreamTrack::stopped() const
     110{
     111    return m_privateTrack->stopped();
    118112}
    119113
    … …  
    168162RefPtr<MediaSourceStates> MediaStreamTrack::states() const
    169163{
    170     if (!source())
    171         return 0;
    172 
    173     return MediaSourceStates::create(source()->states());
     164    return MediaSourceStates::create(m_privateTrack->states());
    174165}
    175166
    176167RefPtr<MediaStreamCapabilities> MediaStreamTrack::capabilities() const
    177168{
    178     if (!source())
    179         return 0;
    180 
    181     return MediaStreamCapabilities::create(source()->capabilities());
     169    // The source may be shared by multiple tracks, so its states is not necessarily
     170    // in sync with the track state. A track that is new or has ended always has a source
     171    // type of "none".
     172    RefPtr<MediaStreamSourceCapabilities> sourceCapabilities = m_privateTrack->capabilities();
     173    MediaStreamSource::ReadyState readyState = m_privateTrack->readyState();
     174    if (readyState == MediaStreamSource::New || readyState == MediaStreamSource::Ended)
     175        sourceCapabilities->setSourceType(MediaStreamSourceStates::None);
     176   
     177    return MediaStreamCapabilities::create(sourceCapabilities.release());
    182178}
    183179
    184180void MediaStreamTrack::applyConstraints(const Dictionary& constraints)
     181{
     182    m_constraints->initialize(constraints);
     183    m_privateTrack->applyConstraints(m_constraints);
     184}
     185
     186void MediaStreamTrack::applyConstraints(PassRefPtr<MediaConstraints>)
    185187{
    186188    // FIXME: apply the new constraints to the track
    187189    // https://bugs.webkit.org/show_bug.cgi?id=122428
    188     m_constraints->initialize(constraints);
    189190}
    190191
    191192RefPtr<MediaStreamTrack> MediaStreamTrack::clone()
    192193{
    193     if (source() && source()->type() == MediaStreamSource::Audio)
     194    if (m_privateTrack->type() == MediaStreamSource::Audio)
    194195        return AudioStreamTrack::create(this);
    195196
    … …  
    199200void MediaStreamTrack::stopProducingData()
    200201{
    201     if (stopped() || !source())
    202         return;
    203 
    204     m_privateTrack->setReadyState(MediaStreamSource::Ended);
    205     m_privateTrack->stop();
     202    // NOTE: this method is called when the "stop" method is called from JS, using
     203    // the "ImplementedAs" IDL attribute. This is done because ActiveDOMObject requires
     204    // a "stop" method.
     205   
     206    // The stop method should "Permanently stop the generation of data for track's source", but it
     207    // should not post an 'ended' event.
     208    m_stoppingTrack = true;
     209    m_privateTrack->stop(MediaStreamTrackPrivate::StopTrackAndStopSource);
     210    m_stoppingTrack = false;
    206211}
    207212
    … …  
    223228}
    224229
    225 void MediaStreamTrack::sourceStateChanged()
     230void MediaStreamTrack::trackReadyStateChanged()
    226231{
    227232    if (stopped())
    228233        return;
    229234
    230     m_privateTrack->setReadyState(source()->readyState());
     235    MediaStreamSource::ReadyState readyState = m_privateTrack->readyState();
     236    if (readyState == MediaStreamSource::Live)
     237        scheduleEventDispatch(Event::create(eventNames().startedEvent, false, false));
     238    else if (readyState == MediaStreamSource::Ended && !m_stoppingTrack)
     239        scheduleEventDispatch(Event::create(eventNames().endedEvent, false, false));
     240
     241    configureTrackRendering();
    231242}
    232243   
    233 void MediaStreamTrack::sourceMutedChanged()
     244void MediaStreamTrack::trackMutedChanged()
    234245{
    235246    if (stopped())
    236247        return;
    237248
    238     m_privateTrack->setMuted(source()->muted());
     249    if (muted())
     250        scheduleEventDispatch(Event::create(eventNames().muteEvent, false, false));
     251    else
     252        scheduleEventDispatch(Event::create(eventNames().unmuteEvent, false, false));
    239253
    240254    configureTrackRendering();
    241255}
    242256
    243 void MediaStreamTrack::sourceEnabledChanged()
     257void MediaStreamTrack::trackEnabledChanged()
    244258{
    245259    if (stopped())
    246260        return;
    247261
    248     setEnabled(source()->enabled());
    249     // media from the source only flows when a MediaStreamTrack object is both unmuted and enabled
     262    setEnabled(m_privateTrack->enabled());
    250263    configureTrackRendering();
    251264}
    … …  
    260273}
    261274
    262 bool MediaStreamTrack::stopped()
    263 {
    264     return m_privateTrack->stopped();
    265 }
    266 
    267275void MediaStreamTrack::trackDidEnd()
    268276{
    … …  
    275283void MediaStreamTrack::stop()
    276284{
    277     stopProducingData();
     285    m_privateTrack->stop(MediaStreamTrackPrivate::StopTrackOnly);
    278286}
    279287
    … …  
    308316}
    309317
    310 void MediaStreamTrack::trackReadyStateChanged()
    311 {
    312     if (m_privateTrack->readyState() == MediaStreamSource::Live)
    313         scheduleEventDispatch(Event::create(eventNames().startedEvent, false, false));
    314     else if (m_privateTrack->readyState() == MediaStreamSource::Ended)
    315         scheduleEventDispatch(Event::create(eventNames().endedEvent, false, false));
    316 }
    317 
    318 void MediaStreamTrack::trackMutedChanged()
    319 {
    320     if (muted())
    321         scheduleEventDispatch(Event::create(eventNames().muteEvent, false, false));
    322     else
    323         scheduleEventDispatch(Event::create(eventNames().unmuteEvent, false, false));
    324 }
    325 
    326318} // namespace WebCore
    327319

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

    r158018 r158220  
    4949class MediaTrackConstraints;
    5050
    51 class MediaStreamTrack : public RefCounted<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamSource::Observer, public MediaStreamTrackPrivateClient {
     51class MediaStreamTrack : public RefCounted<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamTrackPrivateClient {
    5252public:
    5353    class Observer {
    5454    public:
     55        virtual ~Observer() { }
    5556        virtual void trackDidEnd() = 0;
    5657    };
    … …  
    6869    bool readonly() const;
    6970    bool remote() const;
     71    bool stopped() const;
    7072
    7173    const AtomicString& readyState() const;
    … …  
    7779    RefPtr<MediaStreamCapabilities> capabilities() const;
    7880    void applyConstraints(const Dictionary&);
     81    void applyConstraints(PassRefPtr<MediaConstraints>);
    7982
    8083    RefPtr<MediaStreamTrack> clone();
    … …  
    8891
    8992    MediaStreamSource* source() const { return m_privateTrack->source(); }
    90     void setSource(MediaStreamSource*);
    9193
    9294    bool ended() const;
    … …  
    9496    void addObserver(Observer*);
    9597    void removeObserver(Observer*);
    96     MediaStreamTrackPrivate* privateTrack() const { return m_privateTrack.get(); }
    97 
    98     // MediaStreamTrackPrivateClient
    99     void trackReadyStateChanged();
    100     void trackMutedChanged();
    10198
    10299    // EventTarget
    … …  
    109106protected:
    110107    explicit MediaStreamTrack(MediaStreamTrack*);
    111     MediaStreamTrack(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>, const Dictionary*);
     108    MediaStreamTrack(ScriptExecutionContext*, MediaStreamTrackPrivate&, const Dictionary*);
     109
     110    MediaStreamTrackPrivate& privateTrack() { return m_privateTrack.get(); }
     111    void setSource(PassRefPtr<MediaStreamSource>);
    112112
    113113private:
    … …  
    125125    virtual void derefEventTarget() OVERRIDE FINAL { deref(); }
    126126
    127     // MediaStreamSourceObserver
    128     virtual void sourceStateChanged() OVERRIDE FINAL;
    129     virtual void sourceMutedChanged() OVERRIDE FINAL;
    130     virtual void sourceEnabledChanged() OVERRIDE FINAL;
    131     virtual bool stopped() OVERRIDE FINAL;
     127    // MediaStreamTrackPrivateClient
     128    void trackReadyStateChanged();
     129    void trackMutedChanged();
     130    void trackEnabledChanged();
    132131
    133132    Vector<RefPtr<Event>> m_scheduledEvents;
    … …  
    138137    Vector<Observer*> m_observers;
    139138
    140     RefPtr<MediaStreamTrackPrivate> m_privateTrack;
     139    Ref<MediaStreamTrackPrivate> m_privateTrack;
    141140    bool m_eventDispatchScheduled;
     141
     142    bool m_stoppingTrack;
    142143};
    143144

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

    r157068 r158220  
    168168    MediaStreamTrackVector tracks = stream->getAudioTracks();
    169169    for (MediaStreamTrackVector::iterator iter = tracks.begin(); iter != tracks.end(); ++iter)
    170         (*iter)->source()->setConstraints(m_audioConstraints);
     170        (*iter)->applyConstraints(m_audioConstraints);
    171171
    172172    tracks = stream->getVideoTracks();
    173173    for (MediaStreamTrackVector::iterator iter = tracks.begin(); iter != tracks.end(); ++iter)
    174         (*iter)->source()->setConstraints(m_videoConstraints);
     174        (*iter)->applyConstraints(m_videoConstraints);
    175175
    176176    m_successCallback->handleEvent(stream.get());

  • trunk/Source/WebCore/Modules/mediastream/VideoStreamTrack.cpp

    r158018 r158220  
    3838RefPtr<VideoStreamTrack> VideoStreamTrack::create(ScriptExecutionContext* context, const Dictionary& videoConstraints)
    3939{
    40     return adoptRef(new VideoStreamTrack(context, MediaStreamTrackPrivate::create(0), &videoConstraints));
     40    return adoptRef(new VideoStreamTrack(context, *MediaStreamTrackPrivate::create(0), &videoConstraints));
    4141}
    4242
    43 RefPtr<VideoStreamTrack> VideoStreamTrack::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack)
     43RefPtr<VideoStreamTrack> VideoStreamTrack::create(ScriptExecutionContext* context, MediaStreamTrackPrivate& privateTrack)
    4444{
    4545    return adoptRef(new VideoStreamTrack(context, privateTrack, 0));
    … …  
    5151}
    5252
    53 VideoStreamTrack::VideoStreamTrack(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack, const Dictionary* videoConstraints)
     53VideoStreamTrack::VideoStreamTrack(ScriptExecutionContext* context, MediaStreamTrackPrivate& privateTrack, const Dictionary* videoConstraints)
    5454    : MediaStreamTrack(context, privateTrack, videoConstraints)
    5555{

  • trunk/Source/WebCore/Modules/mediastream/VideoStreamTrack.h

    r158018 r158220  
    4242public:
    4343    static RefPtr<VideoStreamTrack> create(ScriptExecutionContext*, const Dictionary&);
    44     static RefPtr<VideoStreamTrack> create(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>);
     44    static RefPtr<VideoStreamTrack> create(ScriptExecutionContext*, MediaStreamTrackPrivate&);
    4545    static RefPtr<VideoStreamTrack> create(MediaStreamTrack*);
    4646
    … …  
    5050
    5151private:
    52     VideoStreamTrack(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>, const Dictionary*);
     52    VideoStreamTrack(ScriptExecutionContext*, MediaStreamTrackPrivate&, const Dictionary*);
    5353    explicit VideoStreamTrack(MediaStreamTrack*);
    5454};

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r158217 r158220  
    8585                070334D9145A006F008D8D45 /* TrackBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 070334D8145A006F008D8D45 /* TrackBase.cpp */; };
    8686                070334E9145A1F36008D8D45 /* JSTrackCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 070334E8145A1F35008D8D45 /* JSTrackCustom.cpp */; };
     87                070363D6181A146500C074A5 /* MediaStreamSourceStates.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 070363D4181A146500C074A5 /* MediaStreamSourceStates.cpp */; };
     88                070363D7181A146500C074A5 /* MediaStreamSourceStates.h in Headers */ = {isa = PBXBuildFile; fileRef = 070363D5181A146500C074A5 /* MediaStreamSourceStates.h */; };
     89                070363E0181A1CDC00C074A5 /* AVAudioCaptureSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 070363D8181A1CDC00C074A5 /* AVAudioCaptureSource.h */; };
     90                070363E1181A1CDC00C074A5 /* AVAudioCaptureSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 070363D9181A1CDC00C074A5 /* AVAudioCaptureSource.mm */; };
     91                070363E2181A1CDC00C074A5 /* AVCaptureDeviceManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 070363DA181A1CDC00C074A5 /* AVCaptureDeviceManager.h */; };
     92                070363E3181A1CDC00C074A5 /* AVCaptureDeviceManager.mm in Sources */ = {isa = PBXBuildFile; fileRef = 070363DB181A1CDC00C074A5 /* AVCaptureDeviceManager.mm */; };
     93                070363E4181A1CDC00C074A5 /* AVMediaCaptureSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 070363DC181A1CDC00C074A5 /* AVMediaCaptureSource.h */; };
     94                070363E5181A1CDC00C074A5 /* AVMediaCaptureSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 070363DD181A1CDC00C074A5 /* AVMediaCaptureSource.mm */; };
     95                070363E6181A1CDC00C074A5 /* AVVideoCaptureSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 070363DE181A1CDC00C074A5 /* AVVideoCaptureSource.h */; };
     96                070363E7181A1CDC00C074A5 /* AVVideoCaptureSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 070363DF181A1CDC00C074A5 /* AVVideoCaptureSource.mm */; };
    8797                070584FD17F9D6DF005F2BCB /* MediaStreamSourceCapabilities.h in Headers */ = {isa = PBXBuildFile; fileRef = 070584FB17F9D6DF005F2BCB /* MediaStreamSourceCapabilities.h */; settings = {ATTRIBUTES = (Private, ); }; };
    8898                070584FF17F9F05E005F2BCB /* CapabilityRange.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 070584FE17F9F05E005F2BCB /* CapabilityRange.cpp */; };
    … …  
    314324                07E116B11489C9A100EC5ACE /* JSTextTrackCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07E116B01489C9A100EC5ACE /* JSTextTrackCustom.cpp */; };
    315325                07E117071489EBEB00EC5ACE /* JSTextTrackCueCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07E117061489EBEB00EC5ACE /* JSTextTrackCueCustom.cpp */; };
     326                07FFDE68181AED420072D409 /* MediaStreamTrackPrivate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07FFDE66181AED420072D409 /* MediaStreamTrackPrivate.cpp */; };
     327                07FFDE69181AED420072D409 /* MediaStreamTrackPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 07FFDE67181AED420072D409 /* MediaStreamTrackPrivate.h */; };
    316328                0806E57A12893045007CED32 /* SVGMatrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 0806E57912893045007CED32 /* SVGMatrix.h */; settings = {ATTRIBUTES = (Private, ); }; };
    317329                080E49261255F3BD00EFCA27 /* SVGTextLayoutEngineBaseline.h in Headers */ = {isa = PBXBuildFile; fileRef = 080E49221255F3BD00EFCA27 /* SVGTextLayoutEngineBaseline.h */; };
    … …  
    64836495                070334D8145A006F008D8D45 /* TrackBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TrackBase.cpp; sourceTree = "<group>"; };
    64846496                070334E8145A1F35008D8D45 /* JSTrackCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTrackCustom.cpp; sourceTree = "<group>"; };
     6497                070363D4181A146500C074A5 /* MediaStreamSourceStates.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaStreamSourceStates.cpp; sourceTree = "<group>"; };
     6498                070363D5181A146500C074A5 /* MediaStreamSourceStates.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamSourceStates.h; sourceTree = "<group>"; };
     6499                070363D8181A1CDC00C074A5 /* AVAudioCaptureSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AVAudioCaptureSource.h; sourceTree = "<group>"; };
     6500                070363D9181A1CDC00C074A5 /* AVAudioCaptureSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AVAudioCaptureSource.mm; sourceTree = "<group>"; };
     6501                070363DA181A1CDC00C074A5 /* AVCaptureDeviceManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AVCaptureDeviceManager.h; sourceTree = "<group>"; };
     6502                070363DB181A1CDC00C074A5 /* AVCaptureDeviceManager.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AVCaptureDeviceManager.mm; sourceTree = "<group>"; };
     6503                070363DC181A1CDC00C074A5 /* AVMediaCaptureSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AVMediaCaptureSource.h; sourceTree = "<group>"; };
     6504                070363DD181A1CDC00C074A5 /* AVMediaCaptureSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AVMediaCaptureSource.mm; sourceTree = "<group>"; };
     6505                070363DE181A1CDC00C074A5 /* AVVideoCaptureSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AVVideoCaptureSource.h; sourceTree = "<group>"; };
     6506                070363DF181A1CDC00C074A5 /* AVVideoCaptureSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AVVideoCaptureSource.mm; sourceTree = "<group>"; };
    64856507                070584FB17F9D6DF005F2BCB /* MediaStreamSourceCapabilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamSourceCapabilities.h; sourceTree = "<group>"; };
    64866508                070584FE17F9F05E005F2BCB /* CapabilityRange.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CapabilityRange.cpp; sourceTree = "<group>"; };
    … …  
    67526774                07E116B01489C9A100EC5ACE /* JSTextTrackCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTextTrackCustom.cpp; sourceTree = "<group>"; };
    67536775                07E117061489EBEB00EC5ACE /* JSTextTrackCueCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTextTrackCueCustom.cpp; sourceTree = "<group>"; };
     6776                07FFDE66181AED420072D409 /* MediaStreamTrackPrivate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaStreamTrackPrivate.cpp; sourceTree = "<group>"; };
     6777                07FFDE67181AED420072D409 /* MediaStreamTrackPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamTrackPrivate.h; sourceTree = "<group>"; };
    67546778                0806E57912893045007CED32 /* SVGMatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGMatrix.h; sourceTree = "<group>"; };
    67556779                080E49211255F3BD00EFCA27 /* SVGTextLayoutEngineBaseline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SVGTextLayoutEngineBaseline.cpp; sourceTree = "<group>"; };
    … …  
    1346413488                        isa = PBXGroup;
    1346513489                        children = (
     13490                                07FFDE66181AED420072D409 /* MediaStreamTrackPrivate.cpp */,
     13491                                07FFDE67181AED420072D409 /* MediaStreamTrackPrivate.h */,
     13492                                070363D4181A146500C074A5 /* MediaStreamSourceStates.cpp */,
     13493                                070363D5181A146500C074A5 /* MediaStreamSourceStates.h */,
    1346613494                                0729B14D17CFCCA0004F1D60 /* mac */,
    1346713495                                07221B9917CF0AD400848E51 /* MediaConstraints.h */,
    … …  
    1349913527                        isa = PBXGroup;
    1350013528                        children = (
     13529                                070363D8181A1CDC00C074A5 /* AVAudioCaptureSource.h */,
     13530                                070363D9181A1CDC00C074A5 /* AVAudioCaptureSource.mm */,
     13531                                070363DA181A1CDC00C074A5 /* AVCaptureDeviceManager.h */,
     13532                                070363DB181A1CDC00C074A5 /* AVCaptureDeviceManager.mm */,
     13533                                070363DC181A1CDC00C074A5 /* AVMediaCaptureSource.h */,
     13534                                070363DD181A1CDC00C074A5 /* AVMediaCaptureSource.mm */,
     13535                                070363DE181A1CDC00C074A5 /* AVVideoCaptureSource.h */,
     13536                                070363DF181A1CDC00C074A5 /* AVVideoCaptureSource.mm */,
    1350113537                                0729B14E17CFCCA0004F1D60 /* MediaStreamCenterMac.cpp */,
    1350213538                                0729B14F17CFCCA0004F1D60 /* MediaStreamCenterMac.h */,
    … …  
    2233622372                                188604B40F2E654A000B6443 /* DOMTimer.h in Headers */,
    2233722373                                05FD69E012845D4300B2BEB3 /* DOMTimeStamp.h in Headers */,
     22374                                07FFDE69181AED420072D409 /* MediaStreamTrackPrivate.h in Headers */,
    2233822375                                76FC2B0C12370DA0006A991A /* DOMTokenList.h in Headers */,
    2233922376                                E145349716A9BB6A000F6FD2 /* DOMTransitionEvent.h in Headers */,
    … …  
    2242422461                                FD31609312B026F700C1A359 /* EqualPowerPanner.h in Headers */,
    2242522462                                2ECF7AE210162B5800427DE7 /* ErrorEvent.h in Headers */,
     22463                                070363E4181A1CDC00C074A5 /* AVMediaCaptureSource.h in Headers */,
    2242622464                                85031B420A44EFC700F992E0 /* Event.h in Headers */,
    2242722465                                4138D3351244054800323D33 /* EventContext.h in Headers */,
    … …  
    2332823366                                B2FA3E090AB75A6F000E5AC4 /* JSSVGTitleElement.h in Headers */,
    2332923367                                B2FA3E0B0AB75A6F000E5AC4 /* JSSVGTransform.h in Headers */,
     23368                                070363D7181A146500C074A5 /* MediaStreamSourceStates.h in Headers */,
    2333023369                                B2FA3E0D0AB75A6F000E5AC4 /* JSSVGTransformList.h in Headers */,
    2333123370                                07277E4F17D018CC0015534D /* JSMediaStreamAudioDestinationNode.h in Headers */,
    … …  
    2364523684                                B27535650B053814002CE64F /* PDFDocumentImage.h in Headers */,
    2364623685                                8A7CC96B12076D73001D4588 /* PendingScript.h in Headers */,
     23686                                070363E6181A1CDC00C074A5 /* AVVideoCaptureSource.h in Headers */,
    2364723687                                8A844D0511D3C18E0014065C /* Performance.h in Headers */,
    2364823688                                07969DB017D14151007FF842 /* JSRTCDTMFSender.h in Headers */,
    … …  
    2450224542                                854FE7370A2297BE0058D7AD /* Traversal.h in Headers */,
    2450324543                                37FD4298118368460093C029 /* TreeDepthLimit.h in Headers */,
     24544                                070363E0181A1CDC00C074A5 /* AVAudioCaptureSource.h in Headers */,
    2450424545                                14D64B5D134A5B6B00E58FDA /* TreeScope.h in Headers */,
    2450524546                                51D719D1181106E00016DC51 /* IDBEventDispatcher.h in Headers */,
    … …  
    2459024631                                A0EE0DF8144F825500F80B0D /* WebGLDebugShaders.h in Headers */,
    2459124632                                6E3FAE8F14733FDB00E42307 /* WebGLDepthTexture.h in Headers */,
     24633                                070363E2181A1CDC00C074A5 /* AVCaptureDeviceManager.h in Headers */,
    2459224634                                6EBF0E5512A8929800DB1709 /* WebGLExtension.h in Headers */,
    2459324635                                49C7B9CF1042D32F0009D447 /* WebGLFramebuffer.h in Headers */,
    … …  
    2612626168                                BC46C1EE0C0DDBDF0020CFC3 /* JSCSSRuleCustom.cpp in Sources */,
    2612726169                                A8D05FA70A23B301005E7203 /* JSCSSRuleList.cpp in Sources */,
     26170                                070363E5181A1CDC00C074A5 /* AVMediaCaptureSource.mm in Sources */,
    2612826171                                9392262F10321084006E7D5D /* JSCSSRuleListCustom.cpp in Sources */,
    2612926172                                142011B60A003133008303F9 /* JSCSSStyleDeclaration.cpp in Sources */,
    … …  
    2652626569                                B2FA3D9A0AB75A6F000E5AC4 /* JSSVGGElement.cpp in Sources */,
    2652726570                                B27B28270CEF0C0700D39D54 /* JSSVGGlyphElement.cpp in Sources */,
     26571                                070363E1181A1CDC00C074A5 /* AVAudioCaptureSource.mm in Sources */,
    2652826572                                24D9129813CA96DE00D21915 /* JSSVGGlyphRefElement.cpp in Sources */,
    2652926573                                B2FA3D9C0AB75A6F000E5AC4 /* JSSVGGradientElement.cpp in Sources */,
    … …  
    2659726641                                B2FA3E0C0AB75A6F000E5AC4 /* JSSVGTransformList.cpp in Sources */,
    2659826642                                B2FA3E0E0AB75A6F000E5AC4 /* JSSVGTRefElement.cpp in Sources */,
     26643                                070363D6181A146500C074A5 /* MediaStreamSourceStates.cpp in Sources */,
    2659926644                                B2FA3E100AB75A6F000E5AC4 /* JSSVGTSpanElement.cpp in Sources */,
    2660026645                                B2FA3E120AB75A6F000E5AC4 /* JSSVGUnitTypes.cpp in Sources */,
    … …  
    2692326968                                97205ABB1239292700B17380 /* PluginDocument.cpp in Sources */,
    2692426969                                1ADA14100E1AE5D900023EE5 /* PluginMainThreadScheduler.cpp in Sources */,
     26970                                070363E3181A1CDC00C074A5 /* AVCaptureDeviceManager.mm in Sources */,
    2692526971                                71E2183B17359FB8006E6E4D /* PlugInsResourcesData.cpp in Sources */,
    2692626972                                76FF17E311235673001D61B5 /* PluginViewNone.cpp in Sources */,
    … …  
    2722527271                                D01A27AD10C9BFD800026A42 /* SpaceSplitString.cpp in Sources */,
    2722627272                                626CDE0E1140424C001E5A68 /* SpatialNavigation.cpp in Sources */,
     27273                                07FFDE68181AED420072D409 /* MediaStreamTrackPrivate.cpp in Sources */,
    2722727274                                75415C29129A9920003AD669 /* SpeechInputResultList.cpp in Sources */,
    2722827275                                AA2A5AD516A4861400975A25 /* SpeechSynthesis.cpp in Sources */,
    … …  
    2763427681                                E180810E16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm in Sources */,
    2763527682                                E152551616FD2350003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.mm in Sources */,
     27683                                070363E7181A1CDC00C074A5 /* AVVideoCaptureSource.mm in Sources */,
    2763627684                                93EB169509F880B00091F8FF /* WebCoreSystemInterface.mm in Sources */,
    2763727685                                37F818FE0D657606005E1F05 /* WebCoreURLResponse.mm in Sources */,

  • trunk/Source/WebCore/bindings/js/JSMediaSourceStatesCustom.cpp

    r157215 r158220  
    7373        return jsUndefined();
    7474
     75    const AtomicString& mode = impl().facingMode();
     76    if (mode.isEmpty())
     77        return jsUndefined();
     78   
    7579    return jsStringWithCache(exec, impl().facingMode());
    7680}

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

    r157068 r158220  
    4343class MediaConstraints;
    4444class MediaStreamCreationClient;
    45 class MediaStreamCreationClient;
    46 class MediaStreamDescriptor;
    47 class MediaStreamSourceCapabilities;
     45class MediaStreamSourceStates;
    4846class MediaStreamTrackSourcesRequestClient;
    49 
    50 struct MediaStreamSourceStates;
    5147
    5248class MediaStreamCenter {
    … …  
    6662    MediaStreamCenter();
    6763
    68     void endLocalMediaStream(MediaStreamDescriptor*);
    6964    static MediaStreamCenter& platformCenter();
    7065};

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

    r158018 r158220  
    6161            m_videoStreamSources.append(source);
    6262        break;
     63    case MediaStreamSource::None:
     64        ASSERT_NOT_REACHED();
     65        break;
    6366    }
    6467}
    … …  
    7982            return;
    8083        m_videoStreamSources.remove(pos);
     84        break;
     85    case MediaStreamSource::None:
     86        ASSERT_NOT_REACHED();
    8187        break;
    8288    }
    … …  
    106112    ASSERT(m_id.length());
    107113    for (size_t i = 0; i < audioSources.size(); i++) {
    108         m_audioStreamSources.append(audioSources[i]);
    109         m_audioTrackDescriptors.append(MediaStreamTrackPrivate::create(audioSources[i]));
     114        RefPtr<MediaStreamSource> source = audioSources[i];
     115        m_audioStreamSources.append(source);
     116        m_audioTrackDescriptors.append(MediaStreamTrackPrivate::create(source));
    110117    }
    111118
    112119    for (size_t i = 0; i < videoSources.size(); i++) {
    113         m_videoStreamSources.append(videoSources[i]);
    114         m_videoTrackDescriptors.append(MediaStreamTrackPrivate::create(videoSources[i]));
     120        RefPtr<MediaStreamSource> source = videoSources[i];
     121        m_videoStreamSources.append(source);
     122        m_videoTrackDescriptors.append(MediaStreamTrackPrivate::create(source));
    115123    }
    116124}

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

    r157958 r158220  
    7575
    7676    m_readyState = readyState;
    77     for (Vector<Observer*>::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
    78         (*i)->sourceStateChanged();
     77    for (auto observer = m_observers.begin(); observer != m_observers.end(); ++observer)
     78        (*observer)->sourceReadyStateChanged();
     79
     80    if (m_readyState == Live) {
     81        startProducingData();
     82        return;
     83    }
     84   
     85    // There are no more consumers of this source's data, shut it down as appropriate.
     86    if (m_readyState == Ended)
     87        stopProducingData();
    7988}
    8089
    … …  
    8998    if (pos != notFound)
    9099        m_observers.remove(pos);
    91 }
    92100
    93 MediaConstraints* MediaStreamSource::constraints() const
    94 {
    95     // FIXME: While this returns
    96     // https://bugs.webkit.org/show_bug.cgi?id=122428
    97     return m_constraints.get();
    98 }
    99    
    100 void MediaStreamSource::setConstraints(PassRefPtr<MediaConstraints> constraints)
    101 {
    102     m_constraints = constraints;
     101    if (!m_observers.size())
     102        stop();
    103103}
    104104
    … …  
    113113        return;
    114114
    115     for (Vector<Observer*>::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
    116         (*i)->sourceMutedChanged();
     115    for (auto observer = m_observers.begin(); observer != m_observers.end(); ++observer)
     116        (*observer)->sourceMutedChanged();
    117117}
    118118
    119119void MediaStreamSource::setEnabled(bool enabled)
    120120{
     121    if (!enabled) {
     122        // Don't disable the source unless all observers are disabled.
     123        for (auto observer = m_observers.begin(); observer != m_observers.end(); ++observer) {
     124            if ((*observer)->observerIsEnabled())
     125                return;
     126        }
     127    }
     128
    121129    if (m_enabled == enabled)
    122130        return;
    123    
     131
    124132    m_enabled = enabled;
    125133
    126134    if (m_readyState == Ended)
    127135        return;
    128    
    129     for (Vector<Observer*>::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
    130         (*i)->sourceEnabledChanged();
     136
     137    if (!enabled)
     138        stopProducingData();
     139    else
     140        startProducingData();
     141
     142    for (auto observer = m_observers.begin(); observer != m_observers.end(); ++observer)
     143        (*observer)->sourceEnabledChanged();
    131144}
    132145
    133146bool MediaStreamSource::readonly() const
    134147{
    135     // http://www.w3.org/TR/mediacapture-streams/#widl-MediaStreamTrack-_readonly
    136     // If the track (audio or video) is backed by a read-only source such as a file, or the track source
    137     // is a local microphone or camera, but is shared so that this track cannot modify any of the source's
    138     // settings, the readonly attribute must return the value true. Otherwise, it must return the value false.
    139148    return m_readonly;
    140149}
    … …  
    142151void MediaStreamSource::stop()
    143152{
    144     for (Vector<Observer*>::iterator i = m_observers.begin(); i != m_observers.end(); ++i) {
    145         if (!(*i)->stopped())
    146             return;
    147     }
    148 
    149     // There are no more consumers of this source's data, shut it down as appropriate.
     153    // This is called from the track.stop() method, which should "Permanently stop the generation of data
     154    // for track's source", so go straight to ended. This will notify any other tracks using this source
     155    // that it is no longer available.
    150156    setReadyState(Ended);
    151 
    152     // http://www.w3.org/TR/mediacapture-streams/#widl-MediaStreamTrack-stop-void
    153     // If the data is being generated from a live source (e.g., a microphone or camera), then the user
    154     // agent should remove any active "on-air" indicator for that source. If the data is being
    155     // generated from a prerecorded source (e.g. a video file), any remaining content in the file is ignored.
    156157}
    157158

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

    r157958 r158220  
    4848class MediaConstraints;
    4949class MediaStreamDescriptor;
    50 struct MediaStreamSourceStates;
     50class MediaStreamSourceStates;
    5151
    5252class MediaStreamSource : public RefCounted<MediaStreamSource> {
    … …  
    5555    public:
    5656        virtual ~Observer() { }
    57         virtual void sourceStateChanged() = 0;
     57       
     58        // Source state changes.
     59        virtual void sourceReadyStateChanged() = 0;
    5860        virtual void sourceMutedChanged() = 0;
    5961        virtual void sourceEnabledChanged() = 0;
    60         virtual bool stopped() = 0;
     62
     63        // Observer state queries.
     64        virtual bool observerIsEnabled() = 0;
    6165    };
    62 
    63     enum Type { Audio, Video };
    64     enum ReadyState { New = 0, Live = 1, Ended = 2 };
    6566
    6667    virtual ~MediaStreamSource() { }
    … …  
    6970    virtual bool useIDForTrackID() const { return false; }
    7071
    71     void reset();
     72    const String& id() const { return m_id; }
    7273
    73     const String& id() const { return m_id; }
     74    enum Type { None, Audio, Video };
    7475    Type type() const { return m_type; }
    75     const String& name() const { return m_name; }
     76
     77    virtual const String& name() const { return m_name; }
     78    virtual void setName(const String& name) { m_name = name; }
    7679
    7780    virtual RefPtr<MediaStreamSourceCapabilities> capabilities() const = 0;
    7881    virtual const MediaStreamSourceStates& states() = 0;
    7982   
    80     void setReadyState(ReadyState);
    81     ReadyState readyState() const { return m_readyState; }
     83    enum ReadyState { New = 0, Live = 1, Ended = 2 };
     84    virtual ReadyState readyState() const { return m_readyState; }
     85    virtual void setReadyState(ReadyState);
     86
     87    virtual bool enabled() const { return m_enabled; }
     88    virtual void setEnabled(bool);
     89
     90    virtual bool muted() const { return m_muted; }
     91    virtual void setMuted(bool);
     92
     93    virtual bool readonly() const;
     94    virtual void setReadonly(bool readonly) { m_readonly = readonly; }
     95
     96    virtual bool remote() const { return m_remote; }
     97    virtual void setRemote(bool remote) { m_remote = remote; }
    8298
    8399    void addObserver(Observer*);
    84100    void removeObserver(Observer*);
    85 
    86     void setConstraints(PassRefPtr<MediaConstraints>);
    87     MediaConstraints* constraints() const;
    88 
    89     bool enabled() const { return m_enabled; }
    90     void setEnabled(bool);
    91 
    92     bool muted() const { return m_muted; }
    93     void setMuted(bool);
    94 
    95     bool readonly() const;
    96     void setReadonly(bool readonly) { m_readonly = readonly; }
    97 
    98     bool remote() const { return m_remote; }
    99     void setRemote(bool remote) { m_remote = remote; }
     101   
     102    virtual void startProducingData() { }
     103    virtual void stopProducingData() { }
    100104
    101105    void stop();
     106
     107    void reset();
    102108
    103109protected:
    … …  
    110116    ReadyState m_readyState;
    111117    Vector<Observer*> m_observers;
    112     RefPtr<MediaConstraints> m_constraints;
    113     MediaStreamSourceStates m_states;
    114118
    115119    bool m_enabled;

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

    r157068 r158220  
    2929#if ENABLE(MEDIA_STREAM)
    3030
     31#include "MediaStreamSourceStates.h"
    3132#include <wtf/RefCounted.h>
    3233#include <wtf/Vector.h>
    … …  
    3435
    3536namespace WebCore {
    36 
    37 struct MediaStreamSourceStates {
    38 public:
    39     enum SourceType { None, Camera, Microphone };
    40     enum VideoFacingMode { User, Environment, Left, Right };
    41 
    42     MediaStreamSourceStates()
    43         : sourceType(None)
    44         , facingMode(User)
    45         , width(0)
    46         , height(0)
    47         , frameRate(0)
    48         , aspectRatio(0)
    49         , volume(0)
    50     {
    51     }
    52 
    53     SourceType sourceType;
    54     AtomicString sourceId;
    55     VideoFacingMode facingMode;
    56     unsigned long width;
    57     unsigned long height;
    58     float frameRate;
    59     float aspectRatio;
    60     unsigned long volume;
    61    
    62     bool hasVideoSource;
    63 };
    6437
    6538class MediaStreamSourceCapabilityRange {
    … …  
    11992
    12093    const Vector<MediaStreamSourceStates::SourceType>& sourceTypes() { return m_sourceType; }
     94    void setSourceType(MediaStreamSourceStates::SourceType sourceType) { m_sourceType.resizeToFit(1); addSourceType(sourceType); }
    12195    void addSourceType(MediaStreamSourceStates::SourceType sourceType)
    12296    {

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

    r158109 r158220  
    3030#include "MediaStreamTrackPrivate.h"
    3131
     32#include "MediaSourceStates.h"
     33#include "MediaStreamCapabilities.h"
     34#include "NotImplemented.h"
    3235#include "UUID.h"
    3336#include <wtf/NeverDestroyed.h>
    … …  
    3740PassRefPtr<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(PassRefPtr<MediaStreamSource> source)
    3841{
    39     return adoptRef(new MediaStreamTrackPrivate(source.get()));
    40 }
    41 
    42 MediaStreamTrackPrivate::MediaStreamTrackPrivate(MediaStreamTrackPrivate* other)
    43 {
    44     // When the clone() method is invoked, the user agent must run the following steps:
    45     // 1. Let trackClone be a newly constructed MediaStreamTrack object.
    46     // 2. Initialize trackClone's id attribute to a newly generated value.
     42    return adoptRef(new MediaStreamTrackPrivate(source));
     43}
     44
     45MediaStreamTrackPrivate::MediaStreamTrackPrivate(const MediaStreamTrackPrivate& other)
     46    : m_client(nullptr)
     47{
     48    m_ignoreMutations = true;
    4749    m_id = createCanonicalUUIDString();
    48 
    49     // 3. Let trackClone inherit this track's underlying source, kind, label and enabled attributes.
    50     m_source = other->source();
    51     m_readyState = m_source ? m_source->readyState() : MediaStreamSource::New;
    52     m_enabled = other->enabled();
    53 
    54     // Note: the "clone" steps don't say anything about 'muted', but 4.3.1 says:
    55     // For a newly created MediaStreamTrack object, the following applies. The track is always enabled
    56     // unless stated otherwise (for examlpe when cloned) and the muted state reflects the state of the
    57     // source at the time the track is created.
    58     m_muted = other->muted();
    59     m_stopped = other->stopped();
    60 }
    61 
    62 MediaStreamTrackPrivate::MediaStreamTrackPrivate(MediaStreamSource* source)
    63     : m_source(0)
     50    setSource(other.source());
     51    m_readyState = other.readyState();
     52    m_muted = other.muted();
     53    m_enabled = other.enabled();
     54    m_stopped = other.stopped();
     55    m_ignoreMutations = false;
     56}
     57
     58MediaStreamTrackPrivate::MediaStreamTrackPrivate(PassRefPtr<MediaStreamSource> source)
     59    : m_source(nullptr)
     60    , m_client(nullptr)
    6461    , m_readyState(MediaStreamSource::New)
    6562    , m_muted(false)
    6663    , m_enabled(true)
    6764    , m_stopped(false)
    68     , m_client(0)
    69 {
     65{
     66    m_ignoreMutations = true;
    7067    setSource(source);
    71 }
    72 
    73 void MediaStreamTrackPrivate::setSource(MediaStreamSource* source)
    74 {
     68    m_ignoreMutations = false;
     69}
     70
     71MediaStreamTrackPrivate::~MediaStreamTrackPrivate()
     72{
     73    if (m_source)
     74        m_source->removeObserver(this);
     75}
     76
     77void MediaStreamTrackPrivate::setSource(PassRefPtr<MediaStreamSource> source)
     78{
     79    if (m_source)
     80        m_source->removeObserver(this);
     81
    7582    m_source = source;
    7683
    … …  
    8087    setMuted(m_source->muted());
    8188    setReadyState(m_source->readyState());
    82 }
    83 
    84 bool MediaStreamTrackPrivate::shouldFireTrackReadyStateChanged(MediaStreamSource::ReadyState oldState)
    85 {
    86     return (m_readyState == MediaStreamSource::Live && oldState == MediaStreamSource::New) || (m_readyState == MediaStreamSource::Ended && oldState != MediaStreamSource::Ended);
    87 }
    88 
    89 const AtomicString& MediaStreamTrackPrivate::kind() const
    90 {
    91     static NeverDestroyed<AtomicString> audio("audio", AtomicString::ConstructFromLiteral);
    92     static NeverDestroyed<AtomicString> video("video", AtomicString::ConstructFromLiteral);
    93 
    94     if (m_type == MediaStreamSource::Audio)
    95         return audio;
    96 
    97     return video;
     89    if (m_source)
     90        m_source->addObserver(this);
    9891}
    9992
    … …  
    142135    m_muted = muted;
    143136
    144     if (m_client)
    145         m_client->trackMutedChanged();
     137    if (!m_client || m_ignoreMutations)
     138        return;
     139
     140    m_client->trackMutedChanged();
    146141}
    147142
    … …  
    171166    // changes value when set; it just doesn't do anything with that new value.
    172167    m_enabled = enabled;
     168
     169    if (m_source)
     170        m_source->setEnabled(enabled);
     171
     172    if (!m_client || m_ignoreMutations)
     173        return;
     174
     175    m_client->trackEnabledChanged();
     176}
     177
     178void MediaStreamTrackPrivate::stop(StopBehavior stopSource)
     179{
     180    if (m_stopped)
     181        return;
     182
     183    if (stopSource == StopTrackAndStopSource && m_source)
     184        m_source->stop();
     185
     186    setReadyState(MediaStreamSource::Ended);
     187    m_stopped = true;
    173188}
    174189
    … …  
    189204    m_readyState = state;
    190205
    191     if (m_client && shouldFireTrackReadyStateChanged(oldState))
     206    if (!m_client || m_ignoreMutations)
     207        return;
     208
     209    if ((m_readyState == MediaStreamSource::Live && oldState == MediaStreamSource::New) || m_readyState == MediaStreamSource::Ended)
    192210        m_client->trackReadyStateChanged();
    193211}
    … …  
    195213RefPtr<MediaStreamTrackPrivate> MediaStreamTrackPrivate::clone()
    196214{
    197     return adoptRef(new MediaStreamTrackPrivate(this));
     215    return adoptRef(new MediaStreamTrackPrivate(*this));
     216}
     217
     218   
     219RefPtr<MediaConstraints> MediaStreamTrackPrivate::constraints() const
     220{
     221    return m_constraints;
     222}
     223
     224const MediaStreamSourceStates& MediaStreamTrackPrivate::states() const
     225{
     226    if (!m_source) {
     227        DEFINE_STATIC_LOCAL(const MediaStreamSourceStates, noState, ());
     228        return noState;
     229    }
     230   
     231    return m_source->states();
     232}
     233
     234MediaStreamSource::Type MediaStreamTrackPrivate::type() const
     235{
     236    if (!m_source)
     237        return MediaStreamSource::None;
     238
     239    return m_source->type();
     240}
     241
     242RefPtr<MediaStreamSourceCapabilities> MediaStreamTrackPrivate::capabilities() const
     243{
     244    if (!m_source)
     245        return 0;
     246
     247    return m_source->capabilities();
     248}
     249
     250void MediaStreamTrackPrivate::applyConstraints(PassRefPtr<MediaConstraints>)
     251{
     252    // FIXME: apply the new constraints to the track
     253    // https://bugs.webkit.org/show_bug.cgi?id=122428
     254}
     255
     256void MediaStreamTrackPrivate::sourceReadyStateChanged()
     257{
     258    if (stopped())
     259        return;
     260   
     261    setReadyState(m_source->readyState());
     262}
     263
     264void MediaStreamTrackPrivate::sourceMutedChanged()
     265{
     266    if (stopped())
     267        return;
     268   
     269    setMuted(m_source->muted());
     270}
     271
     272void MediaStreamTrackPrivate::sourceEnabledChanged()
     273{
     274    if (stopped())
     275        return;
     276   
     277    setEnabled(m_source->enabled());
     278}
     279
     280bool MediaStreamTrackPrivate::observerIsEnabled()
     281{
     282    return enabled();
    198283}
    199284

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

    r158018 r158220  
    3636namespace WebCore {
    3737
     38class MediaSourceStates;
     39class MediaStreamSourceCapabilities;
     40
    3841class MediaStreamTrackPrivateClient {
    3942public:
     43    virtual ~MediaStreamTrackPrivateClient() { }
     44
    4045    virtual void trackReadyStateChanged() = 0;
    4146    virtual void trackMutedChanged() = 0;
     47    virtual void trackEnabledChanged() = 0;
    4248};
    4349
    44 class MediaStreamTrackPrivate : public RefCounted<MediaStreamTrackPrivate> {
     50class MediaStreamTrackPrivate : public RefCounted<MediaStreamTrackPrivate>, public MediaStreamSource::Observer {
    4551public:
    4652    static PassRefPtr<MediaStreamTrackPrivate> create(PassRefPtr<MediaStreamSource>);
    47     virtual ~MediaStreamTrackPrivate() { }
    4853
    49     const AtomicString& kind() const;
     54    virtual ~MediaStreamTrackPrivate();
     55
    5056    const String& id() const;
    5157    const String& label() const;
    … …  
    6874
    6975    MediaStreamSource* source() const { return m_source.get(); }
    70     void setSource(MediaStreamSource*);
     76    void setSource(PassRefPtr<MediaStreamSource>);
    7177
    72     void stop() { m_stopped = true; }
     78    enum StopBehavior { StopTrackAndStopSource, StopTrackOnly };
     79    void stop(StopBehavior);
    7380    bool stopped() const { return m_stopped; }
     81   
     82    void setClient(MediaStreamTrackPrivateClient* client) { m_client = client; }
    7483
    75     MediaStreamSource::Type type() const { return m_type; }
     84    MediaStreamSource::Type type() const;
    7685
    77     void setClient(MediaStreamTrackPrivateClient* client) { m_client = client; }
     86    const MediaStreamSourceStates& states() const;
     87    RefPtr<MediaStreamSourceCapabilities> capabilities() const;
     88
     89    RefPtr<MediaConstraints> constraints() const;
     90    void applyConstraints(PassRefPtr<MediaConstraints>);
     91
     92    void configureTrackRendering();
     93
    7894protected:
    79     explicit MediaStreamTrackPrivate(MediaStreamTrackPrivate*);
    80     MediaStreamTrackPrivate(MediaStreamSource*);
     95    explicit MediaStreamTrackPrivate(const MediaStreamTrackPrivate&);
     96    MediaStreamTrackPrivate(PassRefPtr<MediaStreamSource>);
    8197
    8298private:
    83     bool shouldFireTrackReadyStateChanged(MediaStreamSource::ReadyState);
     99    MediaStreamTrackPrivateClient* client() const { return m_client; }
     100
     101    // MediaStreamSourceObserver
     102    virtual void sourceReadyStateChanged() OVERRIDE FINAL;
     103    virtual void sourceMutedChanged() OVERRIDE FINAL;
     104    virtual void sourceEnabledChanged() OVERRIDE FINAL;
     105    virtual bool observerIsEnabled() OVERRIDE FINAL;
     106   
    84107    RefPtr<MediaStreamSource> m_source;
     108    MediaStreamTrackPrivateClient* m_client;
     109    RefPtr<MediaConstraints> m_constraints;
    85110    MediaStreamSource::ReadyState m_readyState;
    86111    mutable String m_id;
    … …  
    89114    bool m_enabled;
    90115    bool m_stopped;
    91     MediaStreamSource::Type m_type;
    92     MediaStreamTrackPrivateClient* m_client;
     116    bool m_ignoreMutations;
    93117};
    94118

  • trunk/Source/WebCore/platform/mediastream/mac/MediaStreamCenterMac.cpp

    r157068 r158220  
    3535#include "MediaStreamCenterMac.h"
    3636
     37#include "AVCaptureDeviceManager.h"
    3738#include "MediaStreamCreationClient.h"
    3839#include "MediaStreamDescriptor.h"
    3940#include "MediaStreamTrackSourcesRequestClient.h"
    40 #include "NotImplemented.h"
    4141#include <wtf/MainThread.h>
    4242
    … …  
    5858}
    5959
    60 void MediaStreamCenterMac::validateRequestConstraints(PassRefPtr<MediaStreamCreationClient>, PassRefPtr<MediaConstraints>, PassRefPtr<MediaConstraints>)
     60void MediaStreamCenterMac::validateRequestConstraints(PassRefPtr<MediaStreamCreationClient> prpQueryClient, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints)
    6161{
    62     notImplemented();
     62    RefPtr<MediaStreamCreationClient> client = prpQueryClient;
     63   
     64    ASSERT(client);
     65
     66    if (audioConstraints) {
     67        String invalidConstraint;
     68        AVCaptureDeviceManager::shared().verifyConstraintsForMediaType(MediaStreamSource::Audio, audioConstraints.get(), invalidConstraint);
     69        if (!invalidConstraint.isEmpty()) {
     70            client->constraintsInvalid(invalidConstraint);
     71            return;
     72        }
     73    }
     74
     75    if (videoConstraints) {
     76        String invalidConstraint;
     77        AVCaptureDeviceManager::shared().verifyConstraintsForMediaType(MediaStreamSource::Video, videoConstraints.get(), invalidConstraint);
     78        if (!invalidConstraint.isEmpty()) {
     79            client->constraintsInvalid(invalidConstraint);
     80            return;
     81        }
     82    }
     83
     84    client->constraintsValidated();
    6385}
    6486   
    65 void MediaStreamCenterMac::createMediaStream(PassRefPtr<MediaStreamCreationClient>, PassRefPtr<MediaConstraints>, PassRefPtr<MediaConstraints>)
     87void MediaStreamCenterMac::createMediaStream(PassRefPtr<MediaStreamCreationClient> prpQueryClient, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints)
    6688{
    67     notImplemented();
     89    RefPtr<MediaStreamCreationClient> client = prpQueryClient;
     90   
     91    ASSERT(client);
     92   
     93    Vector<RefPtr<MediaStreamSource>> audioSources;
     94    Vector<RefPtr<MediaStreamSource>> videoSources;
     95   
     96    if (audioConstraints) {
     97        String invalidConstraint;
     98        AVCaptureDeviceManager::shared().verifyConstraintsForMediaType(MediaStreamSource::Audio, audioConstraints.get(), invalidConstraint);
     99        if (!invalidConstraint.isEmpty()) {
     100            client->failedToCreateStreamWithConstraintsError(invalidConstraint);
     101            return;
     102        }
     103       
     104        RefPtr<MediaStreamSource> audioSource = AVCaptureDeviceManager::shared().bestSourceForTypeAndConstraints(MediaStreamSource::Audio, audioConstraints.get());
     105        ASSERT(audioSource);
     106       
     107        audioSources.append(audioSource.release());
     108    }
     109   
     110    if (videoConstraints) {
     111        String invalidConstraint;
     112        AVCaptureDeviceManager::shared().verifyConstraintsForMediaType(MediaStreamSource::Video, videoConstraints.get(), invalidConstraint);
     113        if (!invalidConstraint.isEmpty()) {
     114            client->failedToCreateStreamWithConstraintsError(invalidConstraint);
     115            return;
     116        }
     117       
     118        RefPtr<MediaStreamSource> videoSource = AVCaptureDeviceManager::shared().bestSourceForTypeAndConstraints(MediaStreamSource::Video, videoConstraints.get());
     119        ASSERT(videoSource);
     120       
     121        videoSources.append(videoSource.release());
     122    }
     123   
     124    client->didCreateStream(MediaStreamDescriptor::create(audioSources, videoSources, MediaStreamDescriptor::IsNotEnded));
    68125}
    69126
    70 bool MediaStreamCenterMac::getMediaStreamTrackSources(PassRefPtr<MediaStreamTrackSourcesRequestClient>)
     127bool MediaStreamCenterMac::getMediaStreamTrackSources(PassRefPtr<MediaStreamTrackSourcesRequestClient> prpClient)
    71128{
    72     notImplemented();
    73     return false;
     129    RefPtr<MediaStreamTrackSourcesRequestClient> requestClient = prpClient;
     130
     131    Vector<RefPtr<TrackSourceInfo>> sources = AVCaptureDeviceManager::shared().getSourcesInfo(requestClient->requestOrigin());
     132
     133    requestClient->didCompleteRequest(sources);
     134    return true;
    74135}
    75136

  • trunk/Source/WebCore/platform/mock/MockMediaStreamCenter.cpp

    r157268 r158220  
    9292    mockSource1->m_capabilities->setVolumeRange(MediaStreamSourceCapabilityRange(10UL, 90UL, true));
    9393
    94     mockSource1->m_currentStates.sourceType = MediaStreamSourceStates::Camera;
    95     mockSource1->m_currentStates.sourceId = mockSource1->id();
    96     mockSource1->m_currentStates.facingMode = MediaStreamSourceStates::User;
    97     mockSource1->m_currentStates.width = 1920;
    98     mockSource1->m_currentStates.height = 1080;
    99     mockSource1->m_currentStates.frameRate = 30;
    100     mockSource1->m_currentStates.aspectRatio = 16 / 9.0f;
    101     mockSource1->m_currentStates.volume = 70;
     94    mockSource1->m_currentStates.setSourceType(MediaStreamSourceStates::Camera);
     95    mockSource1->m_currentStates.setSourceId(mockSource1->id());
     96    mockSource1->m_currentStates.setFacingMode(MediaStreamSourceStates::User);
     97    mockSource1->m_currentStates.setWidth(1920);
     98    mockSource1->m_currentStates.setHeight(1080);
     99    mockSource1->m_currentStates.setFrameRate(30);
     100    mockSource1->m_currentStates.setAspectRatio(16 / 9.0f);
     101    mockSource1->m_currentStates.setVolume(70);
    102102    String mockSource1id = mockSource1->id();
    103103    mockSourceMap().add(mockSource1id, mockSource1.release());
    … …  
    108108    mockSource2->m_capabilities->setVolumeRange(MediaStreamSourceCapabilityRange(0UL, 100UL, true));
    109109
    110     mockSource2->m_currentStates.sourceType = MediaStreamSourceStates::Microphone;
    111     mockSource2->m_currentStates.sourceId = mockSource2->id();
    112     mockSource2->m_currentStates.volume = 50;
     110    mockSource2->m_currentStates.setSourceType(MediaStreamSourceStates::Microphone);
     111    mockSource2->m_currentStates.setSourceId(mockSource2->id());
     112    mockSource2->m_currentStates.setVolume(50);
    113113    String mockSource2id = mockSource2->id();
    114114    mockSourceMap().add(mockSource2id, mockSource2.release());
    … …  
    205205        }
    206206
    207         if (audioConstraints) {
    208             MockSourceMap::iterator it = map.find(mockAudioSourceID());
    209             ASSERT(it != map.end());
    210 
    211             RefPtr<MediaStreamSource> audioSource = it->value;
    212             audioSource->reset();
    213             audioSource->setReadyState(MediaStreamSource::Live);
    214             audioSources.append(audioSource.release());
    215         }
     207        MockSourceMap::iterator it = map.find(mockAudioSourceID());
     208        ASSERT(it != map.end());
     209
     210        RefPtr<MediaStreamSource> audioSource = it->value;
     211        audioSource->reset();
     212        audioSource->setReadyState(MediaStreamSource::Live);
     213        audioSources.append(audioSource.release());
    216214    }
    217215
    … …  
    223221        }
    224222
    225         if (videoConstraints) {
    226             MockSourceMap::iterator it = map.find(mockVideoSourceID());
    227             ASSERT(it != map.end());
    228 
    229             RefPtr<MediaStreamSource> videoSource = it->value;
    230             videoSource->reset();
    231             videoSource->setReadyState(MediaStreamSource::Live);
    232             videoSources.append(videoSource.release());
    233         }
     223        MockSourceMap::iterator it = map.find(mockVideoSourceID());
     224        ASSERT(it != map.end());
     225
     226        RefPtr<MediaStreamSource> videoSource = it->value;
     227        videoSource->reset();
     228        videoSource->setReadyState(MediaStreamSource::Live);
     229        videoSources.append(videoSource.release());
    234230    }
    235231   
Note: See TracChangeset for help on using the changeset viewer.