[EFL][WK2] --no-tiled-backing-store build fails because of not used #if USE(COORDINAT...
[WebKit-https.git] / Source / WebCore / platform / chromium / support / WebMediaStream.cpp
1 /*
2  * Copyright (C) 2013 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include "config.h"
26
27 #if ENABLE(MEDIA_STREAM)
28
29 #include <public/WebMediaStream.h>
30
31 #include "MediaStreamComponent.h"
32 #include "MediaStreamDescriptor.h"
33 #include "MediaStreamSource.h"
34 #include "UUID.h"
35 #include <public/WebMediaStreamSource.h>
36 #include <public/WebMediaStreamTrack.h>
37 #include <public/WebString.h>
38 #include <wtf/OwnPtr.h>
39 #include <wtf/PassOwnPtr.h>
40 #include <wtf/Vector.h>
41
42 using namespace WebCore;
43
44 namespace WebKit {
45
46 namespace {
47
48 class ExtraDataContainer : public MediaStreamDescriptor::ExtraData {
49 public:
50     ExtraDataContainer(WebMediaStream::ExtraData* extraData) : m_extraData(adoptPtr(extraData)) { }
51
52     WebMediaStream::ExtraData* extraData() { return m_extraData.get(); }
53
54 private:
55     OwnPtr<WebMediaStream::ExtraData> m_extraData;
56 };
57
58 } // namespace
59
60 WebMediaStream::WebMediaStream(const PassRefPtr<WebCore::MediaStreamDescriptor>& mediaStreamDescriptor)
61     : m_private(mediaStreamDescriptor)
62 {
63 }
64
65 WebMediaStream::WebMediaStream(WebCore::MediaStreamDescriptor* mediaStreamDescriptor)
66     : m_private(mediaStreamDescriptor)
67 {
68 }
69
70 void WebMediaStream::reset()
71 {
72     m_private.reset();
73 }
74
75 WebString WebMediaStream::label() const
76 {
77     return m_private->id();
78 }
79
80 WebString WebMediaStream::id() const
81 {
82     return m_private->id();
83 }
84
85 WebMediaStream::ExtraData* WebMediaStream::extraData() const
86 {
87     RefPtr<MediaStreamDescriptor::ExtraData> data = m_private->extraData();
88     if (!data)
89         return 0;
90     return static_cast<ExtraDataContainer*>(data.get())->extraData();
91 }
92
93 void WebMediaStream::setExtraData(ExtraData* extraData)
94 {
95     m_private->setExtraData(adoptRef(new ExtraDataContainer(extraData)));
96 }
97
98 void WebMediaStream::audioTracks(WebVector<WebMediaStreamTrack>& webTracks) const
99 {
100     size_t numberOfTracks = m_private->numberOfAudioComponents();
101     WebVector<WebMediaStreamTrack> result(numberOfTracks);
102     for (size_t i = 0; i < numberOfTracks; ++i)
103         result[i] = m_private->audioComponent(i);
104     webTracks.swap(result);
105 }
106
107 void WebMediaStream::videoTracks(WebVector<WebMediaStreamTrack>& webTracks) const
108 {
109     size_t numberOfTracks = m_private->numberOfVideoComponents();
110     WebVector<WebMediaStreamTrack> result(numberOfTracks);
111     for (size_t i = 0; i < numberOfTracks; ++i)
112         result[i] = m_private->videoComponent(i);
113     webTracks.swap(result);
114 }
115
116 WebMediaStream& WebMediaStream::operator=(const PassRefPtr<WebCore::MediaStreamDescriptor>& mediaStreamDescriptor)
117 {
118     m_private = mediaStreamDescriptor;
119     return *this;
120 }
121
122 WebMediaStream::operator PassRefPtr<WebCore::MediaStreamDescriptor>() const
123 {
124     return m_private.get();
125 }
126
127 WebMediaStream::operator WebCore::MediaStreamDescriptor*() const
128 {
129     return m_private.get();
130 }
131
132 void WebMediaStream::initialize(const WebString& label, const WebVector<WebMediaStreamSource>& audioSources, const WebVector<WebMediaStreamSource>& videoSources)
133 {
134     MediaStreamComponentVector audio, video;
135     for (size_t i = 0; i < audioSources.size(); ++i) {
136         MediaStreamSource* source = audioSources[i];
137         audio.append(MediaStreamComponent::create(source->id(), source));
138     }
139     for (size_t i = 0; i < videoSources.size(); ++i) {
140         MediaStreamSource* source = videoSources[i];
141         video.append(MediaStreamComponent::create(source->id(), source));
142     }
143     m_private = MediaStreamDescriptor::create(label, audio, video);
144 }
145
146 void WebMediaStream::initialize(const WebVector<WebMediaStreamTrack>& audioTracks, const WebVector<WebMediaStreamTrack>& videoTracks)
147 {
148     initialize(createCanonicalUUIDString(), audioTracks, videoTracks);
149 }
150
151 void WebMediaStream::initialize(const WebString& label, const WebVector<WebMediaStreamTrack>& audioTracks, const WebVector<WebMediaStreamTrack>& videoTracks)
152 {
153     MediaStreamComponentVector audio, video;
154     for (size_t i = 0; i < audioTracks.size(); ++i) {
155         MediaStreamComponent* component = audioTracks[i];
156         audio.append(component);
157     }
158     for (size_t i = 0; i < videoTracks.size(); ++i) {
159         MediaStreamComponent* component = videoTracks[i];
160         video.append(component);
161     }
162     m_private = MediaStreamDescriptor::create(label, audio, video);
163 }
164
165 void WebMediaStream::assign(const WebMediaStream& other)
166 {
167     m_private = other.m_private;
168 }
169
170 } // namespace WebKit
171
172 #endif // ENABLE(MEDIA_STREAM)