1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_ 6 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/basictypes.h" 12 #include "base/compiler_specific.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/memory/scoped_vector.h" 16 #include "base/memory/weak_ptr.h" 17 #include "base/threading/non_thread_safe.h" 18 #include "content/common/content_export.h" 19 #include "content/public/renderer/render_view_observer.h" 20 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h" 21 #include "content/renderer/media/media_stream_source.h" 22 #include "third_party/WebKit/public/platform/WebMediaStream.h" 23 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h" 24 #include "third_party/WebKit/public/platform/WebVector.h" 25 #include "third_party/WebKit/public/web/WebMediaDevicesRequest.h" 26 #include "third_party/WebKit/public/web/WebUserMediaClient.h" 27 #include "third_party/WebKit/public/web/WebUserMediaRequest.h" 28 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h" 29 30 namespace content { 31 class PeerConnectionDependencyFactory; 32 class MediaStreamDispatcher; 33 class MediaStreamVideoSource; 34 class VideoCapturerDelegate; 35 36 // MediaStreamImpl is a delegate for the Media Stream GetUserMedia API. 37 // It ties together WebKit and MediaStreamManager 38 // (via MediaStreamDispatcher and MediaStreamDispatcherHost) 39 // in the browser process. It must be created, called and destroyed on the 40 // render thread. 41 // MediaStreamImpl have weak pointers to a MediaStreamDispatcher. 42 class CONTENT_EXPORT MediaStreamImpl 43 : public RenderViewObserver, 44 NON_EXPORTED_BASE(public blink::WebUserMediaClient), 45 public MediaStreamDispatcherEventHandler, 46 public base::SupportsWeakPtr<MediaStreamImpl>, 47 NON_EXPORTED_BASE(public base::NonThreadSafe) { 48 public: 49 MediaStreamImpl( 50 RenderView* render_view, 51 MediaStreamDispatcher* media_stream_dispatcher, 52 PeerConnectionDependencyFactory* dependency_factory); 53 virtual ~MediaStreamImpl(); 54 55 // blink::WebUserMediaClient implementation 56 virtual void requestUserMedia( 57 const blink::WebUserMediaRequest& user_media_request); 58 virtual void cancelUserMediaRequest( 59 const blink::WebUserMediaRequest& user_media_request); 60 virtual void requestMediaDevices( 61 const blink::WebMediaDevicesRequest& media_devices_request) OVERRIDE; 62 virtual void cancelMediaDevicesRequest( 63 const blink::WebMediaDevicesRequest& media_devices_request) OVERRIDE; 64 65 // MediaStreamDispatcherEventHandler implementation. 66 virtual void OnStreamGenerated( 67 int request_id, 68 const std::string& label, 69 const StreamDeviceInfoArray& audio_array, 70 const StreamDeviceInfoArray& video_array) OVERRIDE; 71 virtual void OnStreamGenerationFailed( 72 int request_id, 73 content::MediaStreamRequestResult result) OVERRIDE; 74 virtual void OnDeviceStopped(const std::string& label, 75 const StreamDeviceInfo& device_info) OVERRIDE; 76 virtual void OnDevicesEnumerated( 77 int request_id, 78 const StreamDeviceInfoArray& device_array) OVERRIDE; 79 virtual void OnDeviceOpened( 80 int request_id, 81 const std::string& label, 82 const StreamDeviceInfo& device_info) OVERRIDE; 83 virtual void OnDeviceOpenFailed(int request_id) OVERRIDE; 84 85 // RenderViewObserver OVERRIDE 86 virtual void FrameDetached(blink::WebFrame* frame) OVERRIDE; 87 virtual void FrameWillClose(blink::WebFrame* frame) OVERRIDE; 88 89 protected: 90 // Called when |source| has been stopped from JavaScript. 91 void OnLocalSourceStopped(const blink::WebMediaStreamSource& source); 92 93 // These methods are virtual for test purposes. A test can override them to 94 // test requesting local media streams. The function notifies WebKit that the 95 // |request| have completed. 96 virtual void GetUserMediaRequestSucceeded( 97 const blink::WebMediaStream& stream, 98 blink::WebUserMediaRequest* request_info); 99 virtual void GetUserMediaRequestFailed( 100 blink::WebUserMediaRequest* request_info, 101 content::MediaStreamRequestResult result); 102 virtual void EnumerateDevicesSucceded( 103 blink::WebMediaDevicesRequest* request, 104 blink::WebVector<blink::WebMediaDeviceInfo>& devices); 105 // Creates a MediaStreamVideoSource object. 106 // This is virtual for test purposes. 107 virtual MediaStreamVideoSource* CreateVideoSource( 108 const StreamDeviceInfo& device, 109 const MediaStreamSource::SourceStoppedCallback& stop_callback); 110 111 private: 112 // Class for storing information about a WebKit request to create a 113 // MediaStream. 114 class UserMediaRequestInfo 115 : public base::SupportsWeakPtr<UserMediaRequestInfo> { 116 public: 117 typedef base::Callback<void(UserMediaRequestInfo* request_info, 118 content::MediaStreamRequestResult result)> 119 ResourcesReady; 120 121 UserMediaRequestInfo(int request_id, 122 blink::WebFrame* frame, 123 const blink::WebUserMediaRequest& request, 124 bool enable_automatic_output_device_selection); 125 ~UserMediaRequestInfo(); 126 int request_id; 127 // True if MediaStreamDispatcher has generated the stream, see 128 // OnStreamGenerated. 129 bool generated; 130 const bool enable_automatic_output_device_selection; 131 blink::WebFrame* frame; // WebFrame that requested the MediaStream. 132 blink::WebMediaStream web_stream; 133 blink::WebUserMediaRequest request; 134 135 void StartAudioTrack(const blink::WebMediaStreamTrack& track, 136 const blink::WebMediaConstraints& constraints); 137 138 blink::WebMediaStreamTrack CreateAndStartVideoTrack( 139 const blink::WebMediaStreamSource& source, 140 const blink::WebMediaConstraints& constraints); 141 142 // Triggers |callback| when all sources used in this request have either 143 // successfully started, or a source has failed to start. 144 void CallbackOnTracksStarted(const ResourcesReady& callback); 145 146 bool IsSourceUsed(const blink::WebMediaStreamSource& source) const; 147 void RemoveSource(const blink::WebMediaStreamSource& source); 148 AreAllSourcesRemoved()149 bool AreAllSourcesRemoved() const { return sources_.empty(); } 150 151 private: 152 void OnTrackStarted(MediaStreamSource* source, bool success); 153 void CheckAllTracksStarted(); 154 155 ResourcesReady ready_callback_; 156 bool request_failed_; 157 // Sources used in this request. 158 std::vector<blink::WebMediaStreamSource> sources_; 159 std::vector<MediaStreamSource*> sources_waiting_for_callback_; 160 }; 161 typedef ScopedVector<UserMediaRequestInfo> UserMediaRequests; 162 163 struct LocalStreamSource { LocalStreamSourceLocalStreamSource164 LocalStreamSource(blink::WebFrame* frame, 165 const blink::WebMediaStreamSource& source) 166 : frame(frame), source(source) { 167 } 168 // |frame| is the WebFrame that requested |source|. NULL in unit tests. 169 // TODO(perkj): Change so that |frame| is not NULL in unit tests. 170 blink::WebFrame* frame; 171 blink::WebMediaStreamSource source; 172 }; 173 typedef std::vector<LocalStreamSource> LocalStreamSources; 174 175 struct MediaDevicesRequestInfo; 176 typedef ScopedVector<MediaDevicesRequestInfo> MediaDevicesRequests; 177 178 // Creates a WebKit representation of stream sources based on 179 // |devices| from the MediaStreamDispatcher. 180 void InitializeSourceObject( 181 const StreamDeviceInfo& device, 182 blink::WebMediaStreamSource::Type type, 183 const blink::WebMediaConstraints& constraints, 184 blink::WebFrame* frame, 185 blink::WebMediaStreamSource* webkit_source); 186 187 void CreateVideoTracks( 188 const StreamDeviceInfoArray& devices, 189 const blink::WebMediaConstraints& constraints, 190 blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks, 191 UserMediaRequestInfo* request); 192 193 void CreateAudioTracks( 194 const StreamDeviceInfoArray& devices, 195 const blink::WebMediaConstraints& constraints, 196 blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks, 197 UserMediaRequestInfo* request); 198 199 // Callback function triggered when all native versions of the 200 // underlying media sources and tracks have been created and started. 201 void OnCreateNativeTracksCompleted( 202 UserMediaRequestInfo* request, 203 content::MediaStreamRequestResult result); 204 205 UserMediaRequestInfo* FindUserMediaRequestInfo(int request_id); 206 UserMediaRequestInfo* FindUserMediaRequestInfo( 207 const blink::WebUserMediaRequest& request); 208 void DeleteUserMediaRequestInfo(UserMediaRequestInfo* request); 209 210 MediaDevicesRequestInfo* FindMediaDevicesRequestInfo(int request_id); 211 MediaDevicesRequestInfo* FindMediaDevicesRequestInfo( 212 const blink::WebMediaDevicesRequest& request); 213 void DeleteMediaDevicesRequestInfo(MediaDevicesRequestInfo* request); 214 215 // Returns the source that use a device with |device.session_id| 216 // and |device.device.id|. NULL if such source doesn't exist. 217 const blink::WebMediaStreamSource* FindLocalSource( 218 const StreamDeviceInfo& device) const; 219 220 void StopLocalSource(const blink::WebMediaStreamSource& source, 221 bool notify_dispatcher); 222 223 // Weak ref to a PeerConnectionDependencyFactory, owned by the RenderThread. 224 // It's valid for the lifetime of RenderThread. 225 // TODO(xians): Remove this dependency once audio do not need it for local 226 // audio. 227 PeerConnectionDependencyFactory* dependency_factory_; 228 229 // media_stream_dispatcher_ is a weak reference, owned by RenderView. It's 230 // valid for the lifetime of RenderView. 231 MediaStreamDispatcher* media_stream_dispatcher_; 232 233 LocalStreamSources local_sources_; 234 235 UserMediaRequests user_media_requests_; 236 237 // Requests to enumerate media devices. 238 MediaDevicesRequests media_devices_requests_; 239 240 DISALLOW_COPY_AND_ASSIGN(MediaStreamImpl); 241 }; 242 243 } // namespace content 244 245 #endif // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_ 246