Adds MediaStreamSource, MediaStreamAudioSource and MediaStreamVideoCaptureDeviceSource

content/renderer/media/media_stream_video_source.cc

 // Copyright 2014 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.
 
 #include "content/renderer/media/media_stream_video_source.h"
 
 #include "content/renderer/media/media_stream_dependency_factory.h"
+#include "content/renderer/media/rtc_media_constraints.h"
 #include "media/base/video_frame.h"
 #include "third_party/libjingle/source/talk/app/webrtc/remotevideocapturer.h"
 #include "third_party/libjingle/source/talk/media/webrtc/webrtcvideoframe.h"
 
 namespace content {
 
 MediaStreamVideoSource::MediaStreamVideoSource(
     MediaStreamDependencyFactory* factory)
-    : factory_(factory),
+    : initializing_(false),
+      factory_(factory),
       width_(0),
       height_(0),
       first_frame_timestamp_(media::kNoTimestamp()) {
   DCHECK(factory_);
 }
 
+MediaStreamVideoSource::~MediaStreamVideoSource() {
+  if (initializing_) {
+    adapter_->UnregisterObserver(this);
+  }
+}
+
 void MediaStreamVideoSource::AddTrack(
     const blink::WebMediaStreamTrack& track,
-    const blink::WebMediaConstraints& constraints) {
+    const blink::WebMediaConstraints& constraints,
+    const ConstraintsCallback& callback) {
+  if (!adapter_) {
+    // Create the webrtc::MediaStreamVideoSourceInterface adapter.
+    Init(constraints);
+    DCHECK(adapter_);
+
+    current_constraints_ = constraints;
+    initializing_ = true;
+    // Register to the adapter to get notified when it has been started
+    // successfully.
+    adapter_->RegisterObserver(this);
+  }
+
+  // TODO(perkj): Currently, reconfiguring the source is not supported. For now
+  // we ignore it the constraints do not match the constraints that was used
+  // when the source was started
+
+  // There might be multiple tracks attaching to the source while it is being
+  // configured.
+  constraints_callbacks_.push_back(callback);
+  CheckIfAdapterIsLive();
+
+  // TODO(perkj): Use the MediaStreamDependencyFactory for now to create the
+  // MediaStreamVideoTrack since creation is currently still depending on
+  // libjingle. The webrtc video track implementation will attach to the
+  // webrtc::VideoSourceInterface returned by GetAdapter() to receive video
+  // frames.
   factory_->CreateNativeMediaStreamTrack(track);
 }
 
 void MediaStreamVideoSource::RemoveTrack(
     const blink::WebMediaStreamTrack& track) {
   // TODO(ronghuawu): What should be done here? Do we really need RemoveTrack?
 }
 
-void MediaStreamVideoSource::Init() {
-  if (!adapter_) {
-    const webrtc::MediaConstraintsInterface* constraints = NULL;
-    adapter_ = factory_->CreateVideoSource(new webrtc::RemoteVideoCapturer(),
-                                           constraints);
-  }
+void MediaStreamVideoSource::Init(
+    const blink::WebMediaConstraints& constraints) {
+  DCHECK(!adapter_);
+  RTCMediaConstraints webrtc_constraints(constraints);
+  adapter_ = factory_->CreateVideoSource(new webrtc::RemoteVideoCapturer(),
+                                         &webrtc_constraints);
 }
 
 void MediaStreamVideoSource::SetReadyState(
     blink::WebMediaStreamSource::ReadyState state) {
   // TODO(ronghuawu): Sets WebMediaStreamSource's ready state and notifies the
   // ready state to all registered tracks.
 }
 
 void MediaStreamVideoSource::DeliverVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
@@ skipping 22 matching lines @@
   const size_t pixel_height = 1;
   const int rotation = 0;
   cricket_frame.Alias(frame->data(0), size,
                       width_, height_,
                       pixel_width, pixel_height,
                       elapsed_time_ns, time_stamp_ns,
                       rotation);
   input->RenderFrame(&cricket_frame);
 }
 
-MediaStreamVideoSource::~MediaStreamVideoSource() {
+void MediaStreamVideoSource::OnChanged() {
+  DCHECK(CalledOnValidThread());
+  CheckIfAdapterIsLive();
+}
+
+void MediaStreamVideoSource::CheckIfAdapterIsLive() {
+  if (adapter_->state() == webrtc::MediaSourceInterface::kInitializing)
+    return;
+
+  bool success = adapter_->state() == webrtc::MediaSourceInterface::kLive
+      ? true : false;
+
+  if (initializing_) {
+    adapter_->UnregisterObserver(this);
+    initializing_ = false;
+  }
+
+  std::vector<ConstraintsCallback> callbacks(constraints_callbacks_);
+  constraints_callbacks_.clear();
+
+  for (std::vector<ConstraintsCallback>::iterator it = callbacks.begin();
+       it != callbacks.end(); ++it) {
+    if (!it->is_null())
+      it->Run(this, success);
+  }
 }
 
 }  // namespace content