Adds MediaStreamSource, MediaStreamAudioSource and MediaStreamVideoCaptureDeviceSource

content/renderer/media/media_stream_impl.h

 // Copyright (c) 2012 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_MEDIA_STREAM_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 12 matching lines @@
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebUserMediaClient.h"
 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
 namespace content {
 class MediaStreamAudioRenderer;
 class MediaStreamDependencyFactory;
 class MediaStreamDispatcher;
-class MediaStreamSourceExtraData;
+class MediaStreamSource;
 class WebRtcAudioRenderer;
 class WebRtcLocalAudioRenderer;
 
 // MediaStreamImpl is a delegate for the Media Stream API messages used by
 // WebKit. It ties together WebKit, native PeerConnection in libjingle and
 // MediaStreamManager (via MediaStreamDispatcher and MediaStreamDispatcherHost)
 // in the browser process. It must be created, called and destroyed on the
 // render thread.
 // MediaStreamImpl have weak pointers to a MediaStreamDispatcher.
 class CONTENT_EXPORT MediaStreamImpl
@@ skipping 41 matching lines @@
       int request_id,
       const std::string& label,
       const StreamDeviceInfo& device_info) OVERRIDE;
   virtual void OnDeviceOpenFailed(int request_id) OVERRIDE;
 
   // RenderViewObserver OVERRIDE
   virtual void FrameDetached(blink::WebFrame* frame) OVERRIDE;
   virtual void FrameWillClose(blink::WebFrame* frame) OVERRIDE;
 
  protected:
-  void OnLocalSourceStop(const blink::WebMediaStreamSource& source);
+  // Called when |source| has been stopped from JavaScript.
+  void OnLocalSourceStopped(const blink::WebMediaStreamSource& source);
 
+  // Called when a MediaStream with label |label| has been ordered to stop from
+  // JavaScript. The implementation must stop all sources that are not used by
+  // other MediaStreams.
+  // TODO(perkj): MediaStream::Stop has been deprecated from the spec and all
+  // applications should move to use MediaStreamTrack::Stop instead and this
+  // method be removed.
   void OnLocalMediaStreamStop(const std::string& label);
 
-  // Callback function triggered when all native (libjingle) versions of the
-  // underlying media sources have been created and started.
-  // |web_stream| is a raw pointer to the web_stream in
-  // UserMediaRequests::web_stream for which the underlying sources have been
-  // created.
-  void OnCreateNativeSourcesComplete(
-      blink::WebMediaStream* web_stream,
-      bool request_succeeded);
-
   // This function is virtual for test purposes. A test can override this to
   // test requesting local media streams. The function notifies WebKit that the
   // |request| have completed and generated the MediaStream |stream|.
   virtual void CompleteGetUserMediaRequest(
       const blink::WebMediaStream& stream,
       blink::WebUserMediaRequest* request_info,
       bool request_succeeded);
 
   // Returns the WebKit representation of a MediaStream given an URL.
   // This is virtual for test purposes.
   virtual blink::WebMediaStream GetMediaStream(const GURL& url);
 
  private:
-  // Structure for storing information about a WebKit request to create a
+  // Class for storing information about a WebKit request to create a
   // MediaStream.
-  struct UserMediaRequestInfo {
+  class UserMediaRequestInfo
+      : public base::SupportsWeakPtr<UserMediaRequestInfo> {
+   public:
+    typedef base::Callback<void(UserMediaRequestInfo* request_info,
+                                bool request_succeeded)> ResourcesReady;
+
     UserMediaRequestInfo(int request_id,
                          blink::WebFrame* frame,
                          const blink::WebUserMediaRequest& request,
                          bool enable_automatic_output_device_selection);
     ~UserMediaRequestInfo();
     int request_id;
     // True if MediaStreamDispatcher has generated the stream, see
     // OnStreamGenerated.
     bool generated;
     const bool enable_automatic_output_device_selection;
     blink::WebFrame* frame;  // WebFrame that requested the MediaStream.
     blink::WebMediaStream web_stream;
     blink::WebUserMediaRequest request;
-    std::vector<blink::WebMediaStreamSource> sources;
+
+    void StartTrack(const blink::WebMediaStreamTrack& track,
+                    const blink::WebMediaConstraints& constraints);
+
+    // Triggers |callback| when all sources used in this request have either
+    // successfully started, or a source has failed to start.
+    void CallbackOnTracksStarted(const ResourcesReady& callback);
+
+    bool IsSourceUsed(const blink::WebMediaStreamSource& source) const;
+    void RemoveSource(const blink::WebMediaStreamSource& source);
+
+    bool AreAllSourcesRemoved() const { return sources_.empty(); };
+
+   private:
+    void OnTrackStarted(MediaStreamSource* source, bool success);
+    void CheckAllTracksStarted();
+
+    ResourcesReady ready_callback_;
+    bool request_failed_;
+    // Sources used in this request.
+    std::vector<blink::WebMediaStreamSource> sources_;
+    std::vector<MediaStreamSource*> sources_waiting_for_callback_;
   };
   typedef ScopedVector<UserMediaRequestInfo> UserMediaRequests;
 
   struct LocalStreamSource {
     LocalStreamSource(blink::WebFrame* frame,
                       const blink::WebMediaStreamSource& source)
         : frame(frame), source(source) {
     }
     // |frame| is the WebFrame that requested |source|. NULL in unit tests.
     // TODO(perkj): Change so that |frame| is not NULL in unit tests.
     blink::WebFrame* frame;
     blink::WebMediaStreamSource source;
   };
   typedef std::vector<LocalStreamSource> LocalStreamSources;
 
   // Creates a WebKit representation of stream sources based on
   // |devices| from the MediaStreamDispatcher.
-  void CreateWebKitSourceVector(
-      const std::string& label,
+  void InitializeSourceObject(
+      const StreamDeviceInfo& device,
+      blink::WebMediaStreamSource::Type type,
+      const blink::WebMediaConstraints& constraints,
+      blink::WebFrame* frame,
+      blink::WebMediaStreamSource* webkit_source);
+
+  void CreateVideoTracks(
       const StreamDeviceInfoArray& devices,
-      blink::WebMediaStreamSource::Type type,
-      blink::WebFrame* frame,
-      blink::WebVector<blink::WebMediaStreamSource>& webkit_sources);
+      const blink::WebMediaConstraints& constraints,
+      blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
+      UserMediaRequestInfo* request);
+
+  void CreateAudioTracks(
+      const StreamDeviceInfoArray& devices,
+      const blink::WebMediaConstraints& constraints,
+      blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
+      UserMediaRequestInfo* request);
+
+  // Callback function triggered when all native versions of the
+  // underlying media sources and tracks have been created and started.
+  void OnCreateNativeTracksCompleted(
+      UserMediaRequestInfo* request,
+      bool request_succeeded);
 
   UserMediaRequestInfo* FindUserMediaRequestInfo(int request_id);
   UserMediaRequestInfo* FindUserMediaRequestInfo(
-      blink::WebMediaStream* web_stream);
-  UserMediaRequestInfo* FindUserMediaRequestInfo(
       const blink::WebUserMediaRequest& request);
   UserMediaRequestInfo* FindUserMediaRequestInfo(const std::string& label);
   void DeleteUserMediaRequestInfo(UserMediaRequestInfo* request);
 
   // Returns the source that use a device with |device.session_id|
   // and |device.device.id|. NULL if such source doesn't exist.
   const blink::WebMediaStreamSource* FindLocalSource(
       const StreamDeviceInfo& device) const;
 
   // Returns true if |source| exists in |user_media_requests_|
-  bool FindSourceInRequests(const blink::WebMediaStreamSource& source) const;
+  bool IsSourceInRequests(const blink::WebMediaStreamSource& source) const;
 
   void StopLocalSource(const blink::WebMediaStreamSource& source,
                        bool notify_dispatcher);
   // Stops all local sources that don't exist in exist in
   // |user_media_requests_|.
   void StopUnreferencedSources(bool notify_dispatcher);
 
   scoped_refptr<WebRtcAudioRenderer> CreateRemoteAudioRenderer(
       webrtc::MediaStreamInterface* stream, int render_frame_id);
   scoped_refptr<WebRtcLocalAudioRenderer> CreateLocalAudioRenderer(
@@ skipping 21 matching lines @@
   UserMediaRequests user_media_requests_;
 
   LocalStreamSources local_sources_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_