Home | History | Annotate | Download | only in webrtc 
      1 // Copyright 2014 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_WEBRTC_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
      6 #define CONTENT_RENDERER_MEDIA_WEBRTC_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/files/file.h"
     12 #include "base/threading/thread.h"
     13 #include "content/common/content_export.h"
     14 #include "content/public/renderer/render_process_observer.h"
     15 #include "content/renderer/media/aec_dump_message_filter.h"
     16 #include "content/renderer/p2p/socket_dispatcher.h"
     17 #include "ipc/ipc_platform_file.h"
     18 #include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h"
     19 #include "third_party/libjingle/source/talk/app/webrtc/videosourceinterface.h"
     20 
     21 namespace base {
     22 class WaitableEvent;
     23 }
     24 
     25 namespace talk_base {
     26 class NetworkManager;
     27 class PacketSocketFactory;
     28 class Thread;
     29 }
     30 
     31 namespace blink {
     32 class WebFrame;
     33 class WebMediaConstraints;
     34 class WebMediaStream;
     35 class WebMediaStreamSource;
     36 class WebMediaStreamTrack;
     37 class WebRTCPeerConnectionHandler;
     38 class WebRTCPeerConnectionHandlerClient;
     39 }
     40 
     41 namespace content {
     42 
     43 class IpcNetworkManager;
     44 class IpcPacketSocketFactory;
     45 class MediaStreamAudioSource;
     46 class RTCMediaConstraints;
     47 class WebAudioCapturerSource;
     48 class WebRtcAudioCapturer;
     49 class WebRtcAudioDeviceImpl;
     50 class WebRtcLocalAudioTrack;
     51 class WebRtcLoggingHandlerImpl;
     52 class WebRtcLoggingMessageFilter;
     53 class WebRtcVideoCapturerAdapter;
     54 struct StreamDeviceInfo;
     55 
     56 // Object factory for RTC PeerConnections.
     57 class CONTENT_EXPORT PeerConnectionDependencyFactory
     58     : NON_EXPORTED_BASE(public base::NonThreadSafe),
     59       NON_EXPORTED_BASE(public AecDumpMessageFilter::AecDumpDelegate) {
     60  public:
     61   PeerConnectionDependencyFactory(
     62       P2PSocketDispatcher* p2p_socket_dispatcher);
     63   virtual ~PeerConnectionDependencyFactory();
     64 
     65   // Create a RTCPeerConnectionHandler object that implements the
     66   // WebKit WebRTCPeerConnectionHandler interface.
     67   blink::WebRTCPeerConnectionHandler* CreateRTCPeerConnectionHandler(
     68       blink::WebRTCPeerConnectionHandlerClient* client);
     69 
     70   // Asks the PeerConnection factory to create a Local MediaStream object.
     71   virtual scoped_refptr<webrtc::MediaStreamInterface>
     72       CreateLocalMediaStream(const std::string& label);
     73 
     74   // InitializeMediaStreamAudioSource initialize a MediaStream source object
     75   // for audio input.
     76   bool InitializeMediaStreamAudioSource(
     77       int render_view_id,
     78       const blink::WebMediaConstraints& audio_constraints,
     79       MediaStreamAudioSource* source_data);
     80 
     81   // Creates an implementation of a cricket::VideoCapturer object that can be
     82   // used when creating a libjingle webrtc::VideoSourceInterface object.
     83   virtual WebRtcVideoCapturerAdapter* CreateVideoCapturer(
     84       bool is_screen_capture);
     85 
     86   // Create an instance of WebRtcLocalAudioTrack and store it
     87   // in the extraData field of |track|.
     88   void CreateLocalAudioTrack(const blink::WebMediaStreamTrack& track);
     89 
     90   // Asks the PeerConnection factory to create a Local VideoTrack object.
     91   virtual scoped_refptr<webrtc::VideoTrackInterface>
     92       CreateLocalVideoTrack(const std::string& id,
     93                             webrtc::VideoSourceInterface* source);
     94 
     95   // Asks the PeerConnection factory to create a Video Source.
     96   // The video source takes ownership of |capturer|.
     97   virtual scoped_refptr<webrtc::VideoSourceInterface>
     98       CreateVideoSource(cricket::VideoCapturer* capturer,
     99                         const blink::WebMediaConstraints& constraints);
    100 
    101   // Asks the libjingle PeerConnection factory to create a libjingle
    102   // PeerConnection object.
    103   // The PeerConnection object is owned by PeerConnectionHandler.
    104   virtual scoped_refptr<webrtc::PeerConnectionInterface>
    105       CreatePeerConnection(
    106           const webrtc::PeerConnectionInterface::IceServers& ice_servers,
    107           const webrtc::MediaConstraintsInterface* constraints,
    108           blink::WebFrame* web_frame,
    109           webrtc::PeerConnectionObserver* observer);
    110 
    111   // Creates a libjingle representation of a Session description. Used by a
    112   // RTCPeerConnectionHandler instance.
    113   virtual webrtc::SessionDescriptionInterface* CreateSessionDescription(
    114       const std::string& type,
    115       const std::string& sdp,
    116       webrtc::SdpParseError* error);
    117 
    118   // Creates a libjingle representation of an ice candidate.
    119   virtual webrtc::IceCandidateInterface* CreateIceCandidate(
    120       const std::string& sdp_mid,
    121       int sdp_mline_index,
    122       const std::string& sdp);
    123 
    124   WebRtcAudioDeviceImpl* GetWebRtcAudioDevice();
    125 
    126   static void AddNativeAudioTrackToBlinkTrack(
    127       webrtc::MediaStreamTrackInterface* native_track,
    128       const blink::WebMediaStreamTrack& webkit_track,
    129       bool is_local_track);
    130 
    131   scoped_refptr<base::MessageLoopProxy> GetWebRtcWorkerThread() const;
    132 
    133   // AecDumpMessageFilter::AecDumpDelegate implementation.
    134   // TODO(xians): Remove when option to disable audio track processing is
    135   // removed.
    136   virtual void OnAecDumpFile(
    137       const IPC::PlatformFileForTransit& file_handle) OVERRIDE;
    138   virtual void OnDisableAecDump() OVERRIDE;
    139   virtual void OnIpcClosing() OVERRIDE;
    140 
    141  protected:
    142   // Asks the PeerConnection factory to create a Local Audio Source.
    143   virtual scoped_refptr<webrtc::AudioSourceInterface>
    144       CreateLocalAudioSource(
    145           const webrtc::MediaConstraintsInterface* constraints);
    146 
    147   // Creates a media::AudioCapturerSource with an implementation that is
    148   // specific for a WebAudio source. The created WebAudioCapturerSource
    149   // instance will function as audio source instead of the default
    150   // WebRtcAudioCapturer.
    151   virtual scoped_refptr<WebAudioCapturerSource> CreateWebAudioSource(
    152       blink::WebMediaStreamSource* source);
    153 
    154   // Asks the PeerConnection factory to create a Local VideoTrack object with
    155   // the video source using |capturer|.
    156   virtual scoped_refptr<webrtc::VideoTrackInterface>
    157       CreateLocalVideoTrack(const std::string& id,
    158                             cricket::VideoCapturer* capturer);
    159 
    160   virtual const scoped_refptr<webrtc::PeerConnectionFactoryInterface>&
    161       GetPcFactory();
    162   virtual bool PeerConnectionFactoryCreated();
    163 
    164   // Returns a new capturer or existing capturer based on the |render_view_id|
    165   // and |device_info|. When the |render_view_id| and |device_info| are valid,
    166   // it reuses existing capture if any; otherwise it creates a new capturer.
    167   virtual scoped_refptr<WebRtcAudioCapturer> CreateAudioCapturer(
    168       int render_view_id, const StreamDeviceInfo& device_info,
    169       const blink::WebMediaConstraints& constraints,
    170       MediaStreamAudioSource* audio_source);
    171 
    172   // Adds the audio device as a sink to the audio track and starts the local
    173   // audio track. This is virtual for test purposes since no real audio device
    174   // exist in unit tests.
    175   virtual void StartLocalAudioTrack(WebRtcLocalAudioTrack* audio_track);
    176 
    177  private:
    178   // Creates |pc_factory_|, which in turn is used for
    179   // creating PeerConnection objects.
    180   void CreatePeerConnectionFactory();
    181 
    182   void InitializeWorkerThread(talk_base::Thread** thread,
    183                               base::WaitableEvent* event);
    184 
    185   void CreateIpcNetworkManagerOnWorkerThread(base::WaitableEvent* event);
    186   void DeleteIpcNetworkManager();
    187   void CleanupPeerConnectionFactory();
    188 
    189   // Helper method to create a WebRtcAudioDeviceImpl.
    190   void EnsureWebRtcAudioDeviceImpl();
    191 
    192   // We own network_manager_, must be deleted on the worker thread.
    193   // The network manager uses |p2p_socket_dispatcher_|.
    194   IpcNetworkManager* network_manager_;
    195   scoped_ptr<IpcPacketSocketFactory> socket_factory_;
    196 
    197   scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
    198 
    199   scoped_refptr<P2PSocketDispatcher> p2p_socket_dispatcher_;
    200   scoped_refptr<WebRtcAudioDeviceImpl> audio_device_;
    201 
    202   // This is only used if audio track processing is disabled.
    203   // TODO(xians): Remove when option to disable audio track processing is
    204   // removed.
    205   scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_;
    206 
    207   // PeerConnection threads. signaling_thread_ is created from the
    208   // "current" chrome thread.
    209   talk_base::Thread* signaling_thread_;
    210   talk_base::Thread* worker_thread_;
    211   base::Thread chrome_worker_thread_;
    212 
    213   DISALLOW_COPY_AND_ASSIGN(PeerConnectionDependencyFactory);
    214 };
    215 
    216 }  // namespace content
    217 
    218 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
    219