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 {
+
+// Returns true if the mandatory constraints in |c2| match the mandatory
+// constraints in |c1|. All mandatory constraints in |c1| do not need to exist
+// in |c2|.
+bool MandatoryConstraintsMatch(const blink::WebMediaConstraints& c1,

[Ronghua Wu (Left Chromium), 2014/01/16 23:02:37]

c1->original
c2->new

[perkj_chrome, 2014/01/17 13:19:45]

Done.

+                               const blink::WebMediaConstraints& c2) {
+  if (c1.isNull() && c2.isNull()) {
+    // WebMediaConstraints are NULL in unit tests unfortunately.

[Ronghua Wu (Left Chromium), 2014/01/16 23:02:37]

being null makes sense in real case also, right? i meant can we remove this
comment?

[perkj_chrome, 2014/01/17 13:19:45]

Not 100% sure.
Better safe than sorry.

+    return true;
+  }
+  blink::WebVector<blink::WebMediaConstraint> m1;
+  c1.getMandatoryConstraints(m1);
+  blink::WebVector<blink::WebMediaConstraint> m2;
+  c2.getMandatoryConstraints(m2);
+
+  if (m1.size() < m2.size())
+    return false;
+
+  size_t matched_constraints = 0;
+
+  for (size_t i = 0; i < m1.size(); ++i) {
+    blink::WebString value;
+    if (!c2.getMandatoryConstraintValue(m1[i].m_name, value))
+      continue;
+    if (value != m1[i].m_value)
+      return false;
+    ++matched_constraints;
+  }
+  return m1.size() >= matched_constraints + m2.size();

[Ronghua Wu (Left Chromium), 2014/01/16 23:02:37]

sorry I don't get this one. Why matched_constraints + m2.size()? Isn't
matched_constraints part of m2?

[Jói, 2014/01/17 08:57:08]

Perhaps the check you want is |matched_constraints == m2.size()|? If that is the
case then please update the documentation of the method to say that c2 does not
need to contain all the constraints in c1, but all of the constraints that c2
does contain need to appear in c1 and match the values from there.

[perkj_chrome, 2014/01/17 13:19:45]

Thinking about it more I think we need to skip this for now. The purpose was to
check that a second call to GetUserMedia failed if constraints were set that
forced a resolution change. 

But the current Chrome implementation don't do that and I can't do it properly
in this cl since the constraints parsing is done in libjingle which mean that I
don't really know that resolution was decided in the first place and therefore
can't properly match the constraints int the second call either.
So I would like to skip this for now and keep the current (not 100% correct)
behaviour until we actually parse the constraints here. 

+}
+
+}  // anonymous namespace
+
 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_) {
+    GetAdapter()->UnregisterObserver(this);
+  }
+}
+
 void MediaStreamVideoSource::AddTrack(
     const blink::WebMediaStreamTrack& track,
-    const blink::WebMediaConstraints& constraints) {
+    const blink::WebMediaConstraints& constraints,
+    const ConstraintsCallback& callback) {
+  if (!GetAdapter()) {
+    Init(constraints);
+    DCHECK(GetAdapter());

[Ronghua Wu (Left Chromium), 2014/01/16 23:02:37]

any particular reason why use getter instead of using adapter_ directly?

[perkj_chrome, 2014/01/17 13:19:45]

Done.

+
+    current_constraints_ = constraints;
+    initializing_ = true;
+    GetAdapter()->RegisterObserver(this);

[Ronghua Wu (Left Chromium), 2014/01/16 23:02:37]

this doesn't seem be right. i.e. when will you RegisterObserver if adapter is
created before addtrack.

In fact, i think we should return error if adapter is null when addtrack is
called.

[perkj_chrome, 2014/01/17 13:19:45]

The adapter is the webrtc::source and I register to know if it has been started
sucessfully. Init creates the adapter.
In case of local video capture - we can not create adapter until the constraints
has been set. (video resolution) and we don't know if the camera was started
until the adapter change state.

+  }
+
+  // Currently, reconfiguring the source is not supported.
+  if (!MandatoryConstraintsMatch(current_constraints_, constraints)) {
+    callback.Run(this, false);
+    return;
+  }
+
+  // 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() {
+  webrtc::VideoSourceInterface* webrtc_source = GetAdapter();
+
+  if (webrtc_source->state() == webrtc::MediaSourceInterface::kInitializing)
+    return;
+
+  bool success = webrtc_source->state() == webrtc::MediaSourceInterface::kLive
+      ? true : false;
+
+  if (initializing_) {
+    webrtc_source->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