src/content/renderer/media/user_media_client_impl.h

   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_USER_MEDIA_CLIENT_IMPL_H_
   6 #define CONTENT_RENDERER_MEDIA_USER_MEDIA_CLIENT_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/WebSourceInfo.h"
  25 #include "third_party/WebKit/public/platform/WebVector.h"
  26 #include "third_party/WebKit/public/web/WebMediaDevicesRequest.h"
  27 #include "third_party/WebKit/public/web/WebUserMediaClient.h"
  28 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
  29 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
  30
  31 namespace content {
  32 class PeerConnectionDependencyFactory;
  33 class MediaStreamDispatcher;
  34 class MediaStreamVideoSource;
  35 class VideoCapturerDelegate;
  36
  37 // UserMediaClientImpl is a delegate for the Media Stream GetUserMedia API.
  38 // It ties together WebKit and MediaStreamManager
  39 // (via MediaStreamDispatcher and MediaStreamDispatcherHost)
  40 // in the browser process. It must be created, called and destroyed on the
  41 // render thread.
  42 class CONTENT_EXPORT UserMediaClientImpl
  43     : public RenderFrameObserver,
  44       NON_EXPORTED_BASE(public blink::WebUserMediaClient),
  45       public MediaStreamDispatcherEventHandler,
  46       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  47  public:
  48   // |render_frame| and |dependency_factory| must outlive this instance.
  49   UserMediaClientImpl(
  50       RenderFrame* render_frame,
  51       PeerConnectionDependencyFactory* dependency_factory,
  52       scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher);
  53   virtual ~UserMediaClientImpl();
  54
  55   MediaStreamDispatcher* media_stream_dispatcher() const {
  56     return media_stream_dispatcher_.get();
  57   }
  58
  59   // blink::WebUserMediaClient implementation
  60   virtual void requestUserMedia(
  61       const blink::WebUserMediaRequest& user_media_request);
  62   virtual void cancelUserMediaRequest(
  63       const blink::WebUserMediaRequest& user_media_request);
  64   virtual void requestMediaDevices(
  65       const blink::WebMediaDevicesRequest& media_devices_request) override;
  66   virtual void cancelMediaDevicesRequest(
  67       const blink::WebMediaDevicesRequest& media_devices_request) override;
  68   virtual void requestSources(
  69       const blink::WebMediaStreamTrackSourcesRequest& sources_request) override;
  70
  71   // MediaStreamDispatcherEventHandler implementation.
  72   void OnStreamGenerated(int request_id,
  73                          const std::string& label,
  74                          const StreamDeviceInfoArray& audio_array,
  75                          const StreamDeviceInfoArray& video_array) override;
  76   void OnStreamGenerationFailed(int request_id,
  77                                 MediaStreamRequestResult result) override;
  78   void OnDeviceStopped(const std::string& label,
  79                        const StreamDeviceInfo& device_info) override;
  80   void OnDevicesEnumerated(int request_id,
  81                            const StreamDeviceInfoArray& device_array) override;
  82   void OnDeviceOpened(int request_id,
  83                       const std::string& label,
  84                       const StreamDeviceInfo& device_info) override;
  85   void OnDeviceOpenFailed(int request_id) override;
  86
  87   // RenderFrameObserver override
  88   void FrameWillClose() override;
  89
  90  protected:
  91   // Called when |source| has been stopped from JavaScript.
  92   void OnLocalSourceStopped(const blink::WebMediaStreamSource& source);
  93
  94   // These methods are virtual for test purposes. A test can override them to
  95   // test requesting local media streams. The function notifies WebKit that the
  96   // |request| have completed.
  97   virtual void GetUserMediaRequestSucceeded(
  98        const blink::WebMediaStream& stream,
  99        blink::WebUserMediaRequest* request_info);
 100   virtual void GetUserMediaRequestFailed(
 101       blink::WebUserMediaRequest* request_info,
 102       MediaStreamRequestResult result);
 103   virtual void GetUserMediaRequestTrackStartedFailed(
 104       blink::WebUserMediaRequest* request_info,
 105       MediaStreamRequestResult result,
 106       const blink::WebString& result_name);
 107   virtual void EnumerateDevicesSucceded(
 108       blink::WebMediaDevicesRequest* request,
 109       blink::WebVector<blink::WebMediaDeviceInfo>& devices);
 110   virtual void EnumerateSourcesSucceded(
 111       blink::WebMediaStreamTrackSourcesRequest* request,
 112       blink::WebVector<blink::WebSourceInfo>& sources);
 113   // Creates a MediaStreamVideoSource object.
 114   // This is virtual for test purposes.
 115   virtual MediaStreamVideoSource* CreateVideoSource(
 116       const StreamDeviceInfo& device,
 117       const MediaStreamSource::SourceStoppedCallback& stop_callback);
 118
 119  private:
 120   // Class for storing information about a WebKit request to create a
 121   // MediaStream.
 122   class UserMediaRequestInfo
 123       : public base::SupportsWeakPtr<UserMediaRequestInfo> {
 124    public:
 125     typedef base::Callback<void(UserMediaRequestInfo* request_info,
 126                                 MediaStreamRequestResult result,
 127                                 const blink::WebString& result_name)>
 128       ResourcesReady;
 129
 130     UserMediaRequestInfo(int request_id,
 131                          const blink::WebUserMediaRequest& request,
 132                          bool enable_automatic_output_device_selection);
 133     ~UserMediaRequestInfo();
 134     int request_id;
 135     // True if MediaStreamDispatcher has generated the stream, see
 136     // OnStreamGenerated.
 137     bool generated;
 138     const bool enable_automatic_output_device_selection;
 139     blink::WebMediaStream web_stream;
 140     blink::WebUserMediaRequest request;
 141
 142     void StartAudioTrack(const blink::WebMediaStreamTrack& track,
 143                          const blink::WebMediaConstraints& constraints);
 144
 145     blink::WebMediaStreamTrack CreateAndStartVideoTrack(
 146         const blink::WebMediaStreamSource& source,
 147         const blink::WebMediaConstraints& constraints);
 148
 149     // Triggers |callback| when all sources used in this request have either
 150     // successfully started, or a source has failed to start.
 151     void CallbackOnTracksStarted(const ResourcesReady& callback);
 152
 153     bool IsSourceUsed(const blink::WebMediaStreamSource& source) const;
 154     void RemoveSource(const blink::WebMediaStreamSource& source);
 155
 156     bool HasPendingSources() const;
 157
 158    private:
 159     void OnTrackStarted(
 160         MediaStreamSource* source,
 161         MediaStreamRequestResult result,
 162         const blink::WebString& result_name);
 163     void CheckAllTracksStarted();
 164
 165     ResourcesReady ready_callback_;
 166     MediaStreamRequestResult request_result_;
 167     blink::WebString request_result_name_;
 168     // Sources used in this request.
 169     std::vector<blink::WebMediaStreamSource> sources_;
 170     std::vector<MediaStreamSource*> sources_waiting_for_callback_;
 171   };
 172   typedef ScopedVector<UserMediaRequestInfo> UserMediaRequests;
 173
 174   typedef std::vector<blink::WebMediaStreamSource> LocalStreamSources;
 175
 176   struct MediaDevicesRequestInfo;
 177   typedef ScopedVector<MediaDevicesRequestInfo> MediaDevicesRequests;
 178
 179   // Creates a WebKit representation of stream sources based on
 180   // |devices| from the MediaStreamDispatcher.
 181   void InitializeSourceObject(
 182       const StreamDeviceInfo& device,
 183       blink::WebMediaStreamSource::Type type,
 184       const blink::WebMediaConstraints& constraints,
 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       MediaStreamRequestResult result,
 204       const blink::WebString& result_name);
 205
 206   void OnStreamGeneratedForCancelledRequest(
 207       const StreamDeviceInfoArray& audio_array,
 208       const StreamDeviceInfoArray& video_array);
 209
 210   void FinalizeEnumerateDevices(MediaDevicesRequestInfo* request);
 211   void FinalizeEnumerateSources(MediaDevicesRequestInfo* request);
 212
 213   UserMediaRequestInfo* FindUserMediaRequestInfo(int request_id);
 214   UserMediaRequestInfo* FindUserMediaRequestInfo(
 215       const blink::WebUserMediaRequest& request);
 216   void DeleteUserMediaRequestInfo(UserMediaRequestInfo* request);
 217   void DeleteAllUserMediaRequests();
 218
 219   MediaDevicesRequestInfo* FindMediaDevicesRequestInfo(int request_id);
 220   MediaDevicesRequestInfo* FindMediaDevicesRequestInfo(
 221       const blink::WebMediaDevicesRequest& request);
 222   void CancelAndDeleteMediaDevicesRequest(MediaDevicesRequestInfo* request);
 223
 224   // Returns the source that use a device with |device.session_id|
 225   // and |device.device.id|. NULL if such source doesn't exist.
 226   const blink::WebMediaStreamSource* FindLocalSource(
 227       const StreamDeviceInfo& device) const;
 228
 229   void StopLocalSource(const blink::WebMediaStreamSource& source,
 230                        bool notify_dispatcher);
 231
 232   // Weak ref to a PeerConnectionDependencyFactory, owned by the RenderThread.
 233   // It's valid for the lifetime of RenderThread.
 234   // TODO(xians): Remove this dependency once audio do not need it for local
 235   // audio.
 236   PeerConnectionDependencyFactory* const dependency_factory_;
 237
 238   // UserMediaClientImpl owns MediaStreamDispatcher instead of RenderFrameImpl
 239   // (or RenderFrameObserver) to ensure tear-down occurs in the right order.
 240   const scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher_;
 241
 242   LocalStreamSources local_sources_;
 243
 244   UserMediaRequests user_media_requests_;
 245
 246   // Requests to enumerate media devices.
 247   MediaDevicesRequests media_devices_requests_;
 248
 249   // Note: This member must be the last to ensure all outstanding weak pointers
 250   // are invalidated first.
 251   base::WeakPtrFactory<UserMediaClientImpl> weak_factory_;
 252
 253   DISALLOW_COPY_AND_ASSIGN(UserMediaClientImpl);
 254 };
 255
 256 }  // namespace content
 257
 258 #endif  // CONTENT_RENDERER_MEDIA_USER_MEDIA_CLIENT_IMPL_H_