Adding support for MediaStream and PeerConnection functionality

content/renderer/media/media_stream_impl.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_RENDERER_MEDIA_STREAM_MEDIA_STREAM_IMPL_H_
-#define CONTENT_RENDERER_MEDIA_STREAM_MEDIA_STREAM_IMPL_H_
+#ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_
+#define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_
+
+#include <string>
 
 #include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop_proxy.h"
+#include "base/threading/thread.h"
+#include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
+#include "third_party/libjingle/source/talk/app/webrtc/peerconnection.h"
+#include "third_party/libjingle/source/talk/app/webrtc/peerconnectionfactory.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamClient.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebPeerConnection.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "webkit/glue/media/media_stream_client.h"
 
+namespace base {
+class WaitableEvent;
+}
+
+namespace content {
+class IpcNetworkManager;
+class IpcPacketSocketFactory;
+class P2PSocketDispatcher;
+}
+
+namespace cricket {
+class HttpPortAllocator;
+class WebRtcMediaEngine;
+}
+
+namespace talk_base {
+class Thread;
+}
+
+namespace WebKit {
+class WebLocalMediaStream;
+class WebMediaStreamRecorder;
+class WebMediaStreamController;
+class WebMediaStreamTrack;
+class WebPeerConnection;
+class WebSecurityOrigin;
+}
+
+class MediaStreamDispatcher;
 class VideoCaptureImplManager;
-
-// A implementation of StreamClient to provide supporting functions, such as
-// GetVideoDecoder.
-class MediaStreamImpl
-    : public webkit_glue::MediaStreamClient,
-      public base::RefCountedThreadSafe<MediaStreamImpl> {
+class RTCVideoDecoder;
+
+// MediaStreamImpl is a delegate for the Media Stream API messages used by
+// WebKit.
+class MediaStreamImpl : public WebKit::WebMediaStreamClient,
+                        public webkit_glue::MediaStreamClient,
+                        public MediaStreamDispatcherEventHandler,
+                        public webrtc::PeerConnectionObserver,
+                        public base::RefCountedThreadSafe<MediaStreamImpl> {
  public:
-  explicit MediaStreamImpl(VideoCaptureImplManager* vc_manager);
-  virtual ~MediaStreamImpl();
-
-  // Implement webkit_glue::StreamClient.
+  MediaStreamImpl(MediaStreamDispatcher* media_stream_dispatcher,
+                  content::P2PSocketDispatcher* p2p_socket_dispatcher,
+                  VideoCaptureImplManager* vc_manager);
+  ~MediaStreamImpl();
+
+  // WebKit::WebMediaStreamClient implementation.
+  virtual void setController(
+      WebKit::WebMediaStreamController* controller) OVERRIDE;
+  virtual void shutdown() OVERRIDE;
+  virtual void generateStream(
+      int request_id,
+      WebKit::WebGenerateStreamOptionFlags flags,
+      const WebKit::WebSecurityOrigin& web_security_origin) OVERRIDE;
+  virtual void stopGeneratedStream(
+      const WebKit::WebLocalMediaStream& stream) OVERRIDE;
+  virtual void recordStream(
+      const WebKit::WebMediaStreamRecorder& recorder) OVERRIDE;
+  virtual void getRecordedData(const WebKit::WebMediaStreamRecorder& recorder,
+                               int request_id) OVERRIDE;

[tommi (sloooow) - chröme, 2011/10/03 12:14:14]

there are two ways of wrapping arguments used in this file. it's better to pick
one and stick with it.

[Henrik Grunell, 2011/10/18 19:04:05]

Done.

+  virtual void disposeRecordedData(
+      const WebKit::WebMediaStreamRecorder& recorder) OVERRIDE;
+  virtual void setMediaStreamTrackEnabled(
+      const WebKit::WebMediaStreamTrack& track) OVERRIDE;
+  virtual void processSignalingMessage(
+      const WebKit::WebPeerConnection& peer_connection_web,
+      const WebKit::WebString& message) OVERRIDE;
+  virtual void message(const WebKit::WebPeerConnection& peer_connection_web,
+                       const WebKit::WebString& message) OVERRIDE;
+  virtual void addStream(const WebKit::WebPeerConnection& peer_connection_web,
+                         const WebKit::WebMediaStream& stream) OVERRIDE;
+  virtual void newPeerConnection(
+      const WebKit::WebPeerConnection& peer_connection_web,
+      const WebKit::WebString& configuration) OVERRIDE;
+  virtual void closePeerConnection(
+      const WebKit::WebPeerConnection& peer_connection_web) OVERRIDE;
+  virtual void startNegotiation(
+      const WebKit::WebPeerConnection& peer_connection_web) OVERRIDE;
+  virtual void removeStream(
+      const WebKit::WebPeerConnection& peer_connection_web,
+      const WebKit::WebMediaStream& stream) OVERRIDE;
+  virtual void commitStreamChanges(
+      const WebKit::WebPeerConnection& peer_connection_web) OVERRIDE;
+
+  // Implement media_stream::MediaStreamClient.
   virtual scoped_refptr<media::VideoDecoder> GetVideoDecoder(
-      const GURL& url, media::MessageLoopFactory* message_loop_factory);
+      const GURL& url, media::MessageLoopFactory* message_loop_factory)
+      OVERRIDE;
+
+  // Implement MediaStreamDispatcherEventHandler.
+  virtual void OnStreamGenerated(
+      int request_id,
+      const std::string& label,
+      const media_stream::StreamDeviceInfoArray& audio_array,
+      const media_stream::StreamDeviceInfoArray& video_array) OVERRIDE;
+  virtual void OnStreamGenerationFailed(int request_id) OVERRIDE;
+  virtual void OnVideoDeviceFailed(const std::string& label,
+                                   int index) OVERRIDE;
+  virtual void OnAudioDeviceFailed(const std::string& label,
+                                   int index) OVERRIDE;
+
+  // Implement webrtc::PeerConnectionObserver
+  virtual void OnError() OVERRIDE;
+  virtual void OnSignalingMessage(const std::string& msg) OVERRIDE;
+  virtual void OnAddStream(const std::string& stream_id, bool video) OVERRIDE;
+  virtual void OnRemoveStream(const std::string& stream_id,
+                              bool video) OVERRIDE;
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(MediaStreamImplTest, Basic);
+  FRIEND_TEST_ALL_PREFIXES(MediaStreamImplTest, TestFailure);
+
+  // TODO(grunell): These shall be removed or changed when libjingle's
+  // PeerConnection has been updated to closer follow the specification.
+  void OnAddStreamCallback(const std::string& stream_label);
+  void OnRemoveStreamCallback(const std::string& stream_label);
+  void DeletePeerConnection();
+
+  void InitializeWorkerThread(talk_base::Thread** thread,
+                              base::WaitableEvent* event);
+
+  // The controller_ is valid for the lifetime of the underlying
+  // WebCore::WebMediaStreamController. mediaStreamDestroyed() is
+  // invoked when the underlying object is destroyed. Additionally,

[tommi (sloooow) - chröme, 2011/10/03 12:14:14]

It's not clear to me what "the underlying object" is.  Can you clarify?

[Henrik Grunell, 2011/10/18 19:04:05]

Done.

+  // the dispatcher has the same life time as the controller since

[tommi (sloooow) - chröme, 2011/10/03 12:14:14]

I'm not sure which dispatcher... assuming (media_stream_dispatcher_ (?)

Ownership of the media stream dispatcher is outside this class but ownership of
the controller is in this class, so it feels to me that lifetime management
could go a bit a stray.  Are naked (non-refcounted) pointers to these objects
handed out to other classes (which could then try to use a bad pointer)?
I'm a bit worried about how tear-down works since the ownership of objects that
are expected to have the same lifetime, isn't all in the same place.

[Henrik Grunell, 2011/10/18 19:04:05]

Dispatcher was the previous name of this class, I've updated the comment and
other comments. Check if it's clear now or needs more info.

+  // it is owned by RenderView.
+  scoped_ptr<WebKit::WebMediaStreamController> controller_;
+
+  MediaStreamDispatcher* media_stream_dispatcher_;

[tommi (sloooow) - chröme, 2011/10/03 12:14:14]

would be good to document lifetime and ownership of media_engine_ and
p2p_socket_dispatcher_ too.

[Henrik Grunell, 2011/10/18 19:04:05]

Done.

+  cricket::WebRtcMediaEngine* media_engine_;
+
+  content::P2PSocketDispatcher* p2p_socket_dispatcher_;
   scoped_refptr<VideoCaptureImplManager> vc_manager_;
 
+  scoped_ptr<webrtc::PeerConnectionFactory> pc_factory_;
+  scoped_ptr<content::IpcNetworkManager> ipc_network_manager_;
+  scoped_ptr<content::IpcPacketSocketFactory> ipc_socket_factory_;
+  // TODO(grunell): Support several PeerConnections.
+  // peer_connection_web_ is WebKit's PeerConnection object
+  WebKit::WebPeerConnection peer_connection_web_;
+  // peer_connection_native_ is the native PeerConnection object,
+  // it handles the ICE processing and media engine.
+  scoped_ptr<webrtc::PeerConnection> peer_connection_native_;
+  scoped_refptr<RTCVideoDecoder> rtc_video_decoder_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+
+  // PeerConnection threads. Signaling_thread is created from the
+  // "current" chrome thread.
+  // threads will be deleted when MessageLoop are destroyed.
+  talk_base::Thread* signaling_thread_;
+  talk_base::Thread* worker_thread_;
+  base::Thread chrome_worker_thread_;
+
+  // TODO(grunell): This shall be removed or changed when libjingle's
+  // PeerConnection has been updated to closer follow the specification.
+  // Currently, a stream in WebKit has audio and/or video and has one label.
+  // Local and remote streams have different labels.
+  // In libjingle, a stream has audio or video (not both), and they have
+  // separate labels. A remote stream has the same label as the corresponding
+  // local stream. Hence the workarounds in the implementation to handle this.
+  // It could look like this:
+  // WebKit: Local stream audio and video, label "foo".
+  //         Remote stream audio and video, label "foo-remote".
+  // Libjingle: Local stream audio, label "foo-audio".
+  //            Local stream video, label "foo".
+  //            Remote stream audio, label "foo-audio".
+  //            Remote stream video, label "foo".
+  std::string local_label_;   // Label used in WebKit
+  std::string remote_label_;  // Label used in WebKit
+
+  // Call states. Possible transitions:
+  // NOT_STARTED -> INITIATING -> SENDING_AND_RECEIVING
+  // NOT_STARTED -> RECEIVING
+  // RECEIVING -> NOT_STARTED
+  // RECEIVING -> SENDING_AND_RECEIVING
+  // RECEIVING -> TERMINATING -> NOT_STARTED
+  // SENDING_AND_RECEIVING -> TERMINATING -> NOT_STARTED
+  // SENDING_AND_RECEIVING -> NOT_STARTED
+  // Note that when in state SENDING_AND_RECEIVING, the other side may or may
+  // not send media. Thus, this state does not necessarily mean full duplex.
+  // TODO(grunell): This shall be removed or changed when libjingle's
+  // PeerConnection has been updated to closer follow the specification.
+  enum CallState {
+    NOT_STARTED,
+    INITIATING,
+    RECEIVING,
+    SENDING_AND_RECEIVING,
+    TERMINATING
+  };
+  CallState call_state_;
+
+  // Make sure we only create the video capture module once. This is also
+  // temporary and will be handled differently when several PeerConnections
+  // and/or streams is supported.
+  // TODO(grunell): This shall be removed or changed when libjingle's
+  // PeerConnection has been updated to closer follow the specification.
+  bool vcm_is_created_;

[tommi (sloooow) - chröme, 2011/10/03 12:14:14]

nit: vcm_created_;

[Henrik Grunell, 2011/10/18 19:04:05]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(MediaStreamImpl);
 };
 
-#endif  // CONTENT_RENDERER_MEDIA_STREAM_MEDIA_STREAM_IMPL_H_
+#endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_