| OLD | NEW |
|---|
| (Empty) |
| 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_frame_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 class CONTENT_EXPORT MediaStreamImpl | |
| 42 : public RenderFrameObserver, | |
| 43 NON_EXPORTED_BASE(public blink::WebUserMediaClient), | |
| 44 public MediaStreamDispatcherEventHandler, | |
| 45 NON_EXPORTED_BASE(public base::NonThreadSafe) { | |
| 46 public: | |
| 47 // |render_frame| and |dependency_factory| must outlive this instance. | |
| 48 MediaStreamImpl( | |
| 49 RenderFrame* render_frame, | |
| 50 PeerConnectionDependencyFactory* dependency_factory, | |
| 51 scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher); | |
| 52 virtual ~MediaStreamImpl(); | |
| 53 | |
| 54 MediaStreamDispatcher* media_stream_dispatcher() const { | |
| 55 return media_stream_dispatcher_.get(); | |
| 56 } | |
| 57 | |
| 58 // blink::WebUserMediaClient implementation | |
| 59 virtual void requestUserMedia( | |
| 60 const blink::WebUserMediaRequest& user_media_request); | |
| 61 virtual void cancelUserMediaRequest( | |
| 62 const blink::WebUserMediaRequest& user_media_request); | |
| 63 virtual void requestMediaDevices( | |
| 64 const blink::WebMediaDevicesRequest& media_devices_request) OVERRIDE; | |
| 65 virtual void cancelMediaDevicesRequest( | |
| 66 const blink::WebMediaDevicesRequest& media_devices_request) OVERRIDE; | |
| 67 | |
| 68 // MediaStreamDispatcherEventHandler implementation. | |
| 69 virtual void OnStreamGenerated( | |
| 70 int request_id, | |
| 71 const std::string& label, | |
| 72 const StreamDeviceInfoArray& audio_array, | |
| 73 const StreamDeviceInfoArray& video_array) OVERRIDE; | |
| 74 virtual void OnStreamGenerationFailed( | |
| 75 int request_id, | |
| 76 MediaStreamRequestResult result) OVERRIDE; | |
| 77 virtual void OnDeviceStopped(const std::string& label, | |
| 78 const StreamDeviceInfo& device_info) OVERRIDE; | |
| 79 virtual void OnDevicesEnumerated( | |
| 80 int request_id, | |
| 81 const StreamDeviceInfoArray& device_array) OVERRIDE; | |
| 82 virtual void OnDeviceOpened( | |
| 83 int request_id, | |
| 84 const std::string& label, | |
| 85 const StreamDeviceInfo& device_info) OVERRIDE; | |
| 86 virtual void OnDeviceOpenFailed(int request_id) OVERRIDE; | |
| 87 | |
| 88 // RenderFrameObserver OVERRIDE | |
| 89 virtual void FrameWillClose() OVERRIDE; | |
| 90 | |
| 91 protected: | |
| 92 // Called when |source| has been stopped from JavaScript. | |
| 93 void OnLocalSourceStopped(const blink::WebMediaStreamSource& source); | |
| 94 | |
| 95 // These methods are virtual for test purposes. A test can override them to | |
| 96 // test requesting local media streams. The function notifies WebKit that the | |
| 97 // |request| have completed. | |
| 98 virtual void GetUserMediaRequestSucceeded( | |
| 99 const blink::WebMediaStream& stream, | |
| 100 blink::WebUserMediaRequest* request_info); | |
| 101 virtual void GetUserMediaRequestFailed( | |
| 102 blink::WebUserMediaRequest* request_info, | |
| 103 MediaStreamRequestResult result); | |
| 104 virtual void GetUserMediaRequestTrackStartedFailed( | |
| 105 blink::WebUserMediaRequest* request_info, | |
| 106 MediaStreamRequestResult result, | |
| 107 const blink::WebString& result_name); | |
| 108 virtual void EnumerateDevicesSucceded( | |
| 109 blink::WebMediaDevicesRequest* request, | |
| 110 blink::WebVector<blink::WebMediaDeviceInfo>& devices); | |
| 111 // Creates a MediaStreamVideoSource object. | |
| 112 // This is virtual for test purposes. | |
| 113 virtual MediaStreamVideoSource* CreateVideoSource( | |
| 114 const StreamDeviceInfo& device, | |
| 115 const MediaStreamSource::SourceStoppedCallback& stop_callback); | |
| 116 | |
| 117 private: | |
| 118 // Class for storing information about a WebKit request to create a | |
| 119 // MediaStream. | |
| 120 class UserMediaRequestInfo | |
| 121 : public base::SupportsWeakPtr<UserMediaRequestInfo> { | |
| 122 public: | |
| 123 typedef base::Callback<void(UserMediaRequestInfo* request_info, | |
| 124 MediaStreamRequestResult result, | |
| 125 const blink::WebString& result_name)> | |
| 126 ResourcesReady; | |
| 127 | |
| 128 UserMediaRequestInfo(int request_id, | |
| 129 const blink::WebUserMediaRequest& request, | |
| 130 bool enable_automatic_output_device_selection); | |
| 131 ~UserMediaRequestInfo(); | |
| 132 int request_id; | |
| 133 // True if MediaStreamDispatcher has generated the stream, see | |
| 134 // OnStreamGenerated. | |
| 135 bool generated; | |
| 136 const bool enable_automatic_output_device_selection; | |
| 137 blink::WebMediaStream web_stream; | |
| 138 blink::WebUserMediaRequest request; | |
| 139 | |
| 140 void StartAudioTrack(const blink::WebMediaStreamTrack& track, | |
| 141 const blink::WebMediaConstraints& constraints); | |
| 142 | |
| 143 blink::WebMediaStreamTrack CreateAndStartVideoTrack( | |
| 144 const blink::WebMediaStreamSource& source, | |
| 145 const blink::WebMediaConstraints& constraints); | |
| 146 | |
| 147 // Triggers |callback| when all sources used in this request have either | |
| 148 // successfully started, or a source has failed to start. | |
| 149 void CallbackOnTracksStarted(const ResourcesReady& callback); | |
| 150 | |
| 151 bool IsSourceUsed(const blink::WebMediaStreamSource& source) const; | |
| 152 void RemoveSource(const blink::WebMediaStreamSource& source); | |
| 153 | |
| 154 bool HasPendingSources() const; | |
| 155 | |
| 156 private: | |
| 157 void OnTrackStarted( | |
| 158 MediaStreamSource* source, | |
| 159 MediaStreamRequestResult result, | |
| 160 const blink::WebString& result_name); | |
| 161 void CheckAllTracksStarted(); | |
| 162 | |
| 163 ResourcesReady ready_callback_; | |
| 164 MediaStreamRequestResult request_result_; | |
| 165 blink::WebString request_result_name_; | |
| 166 // Sources used in this request. | |
| 167 std::vector<blink::WebMediaStreamSource> sources_; | |
| 168 std::vector<MediaStreamSource*> sources_waiting_for_callback_; | |
| 169 }; | |
| 170 typedef ScopedVector<UserMediaRequestInfo> UserMediaRequests; | |
| 171 | |
| 172 typedef std::vector<blink::WebMediaStreamSource> LocalStreamSources; | |
| 173 | |
| 174 struct MediaDevicesRequestInfo; | |
| 175 typedef ScopedVector<MediaDevicesRequestInfo> MediaDevicesRequests; | |
| 176 | |
| 177 // Creates a WebKit representation of stream sources based on | |
| 178 // |devices| from the MediaStreamDispatcher. | |
| 179 void InitializeSourceObject( | |
| 180 const StreamDeviceInfo& device, | |
| 181 blink::WebMediaStreamSource::Type type, | |
| 182 const blink::WebMediaConstraints& constraints, | |
| 183 blink::WebMediaStreamSource* webkit_source); | |
| 184 | |
| 185 void CreateVideoTracks( | |
| 186 const StreamDeviceInfoArray& devices, | |
| 187 const blink::WebMediaConstraints& constraints, | |
| 188 blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks, | |
| 189 UserMediaRequestInfo* request); | |
| 190 | |
| 191 void CreateAudioTracks( | |
| 192 const StreamDeviceInfoArray& devices, | |
| 193 const blink::WebMediaConstraints& constraints, | |
| 194 blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks, | |
| 195 UserMediaRequestInfo* request); | |
| 196 | |
| 197 // Callback function triggered when all native versions of the | |
| 198 // underlying media sources and tracks have been created and started. | |
| 199 void OnCreateNativeTracksCompleted( | |
| 200 UserMediaRequestInfo* request, | |
| 201 MediaStreamRequestResult result, | |
| 202 const blink::WebString& result_name); | |
| 203 | |
| 204 void OnStreamGeneratedForCancelledRequest( | |
| 205 const StreamDeviceInfoArray& audio_array, | |
| 206 const StreamDeviceInfoArray& video_array); | |
| 207 | |
| 208 UserMediaRequestInfo* FindUserMediaRequestInfo(int request_id); | |
| 209 UserMediaRequestInfo* FindUserMediaRequestInfo( | |
| 210 const blink::WebUserMediaRequest& request); | |
| 211 void DeleteUserMediaRequestInfo(UserMediaRequestInfo* request); | |
| 212 void DeleteAllUserMediaRequests(); | |
| 213 | |
| 214 MediaDevicesRequestInfo* FindMediaDevicesRequestInfo(int request_id); | |
| 215 MediaDevicesRequestInfo* FindMediaDevicesRequestInfo( | |
| 216 const blink::WebMediaDevicesRequest& request); | |
| 217 void CancelAndDeleteMediaDevicesRequest(MediaDevicesRequestInfo* request); | |
| 218 | |
| 219 // Returns the source that use a device with |device.session_id| | |
| 220 // and |device.device.id|. NULL if such source doesn't exist. | |
| 221 const blink::WebMediaStreamSource* FindLocalSource( | |
| 222 const StreamDeviceInfo& device) const; | |
| 223 | |
| 224 void StopLocalSource(const blink::WebMediaStreamSource& source, | |
| 225 bool notify_dispatcher); | |
| 226 | |
| 227 // Weak ref to a PeerConnectionDependencyFactory, owned by the RenderThread. | |
| 228 // It's valid for the lifetime of RenderThread. | |
| 229 // TODO(xians): Remove this dependency once audio do not need it for local | |
| 230 // audio. | |
| 231 PeerConnectionDependencyFactory* const dependency_factory_; | |
| 232 | |
| 233 // MediaStreamImpl owns MediaStreamDispatcher instead of RenderFrameImpl | |
| 234 // (or RenderFrameObserver) to ensure tear-down occurs in the right order. | |
| 235 const scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher_; | |
| 236 | |
| 237 LocalStreamSources local_sources_; | |
| 238 | |
| 239 UserMediaRequests user_media_requests_; | |
| 240 | |
| 241 // Requests to enumerate media devices. | |
| 242 MediaDevicesRequests media_devices_requests_; | |
| 243 | |
| 244 // Note: This member must be the last to ensure all outstanding weak pointers | |
| 245 // are invalidated first. | |
| 246 base::WeakPtrFactory<MediaStreamImpl> weak_factory_; | |
| 247 | |
| 248 DISALLOW_COPY_AND_ASSIGN(MediaStreamImpl); | |
| 249 }; | |
| 250 | |
| 251 } // namespace content | |
| 252 | |
| 253 #endif // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 524363003:
Changed name of MediaStreamImpl to UserMediaClientImpl. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master