Effects Pepper Plugin and MediaStream Glue.

content/renderer/media/media_stream_dependency_factory.cc

 // 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.
 
 #include "content/renderer/media/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
@@ skipping 23 matching lines @@
 #endif
 
 namespace content {
 
 // Constant constraint keys which disables all audio constraints.
 // Only used in combination with WebAudio sources.
 struct {
   const char* key;
   const char* value;
 } const kWebAudioConstraints[] = {
-  {webrtc::MediaConstraintsInterface::kEchoCancellation,
-   webrtc::MediaConstraintsInterface::kValueFalse},
-  {webrtc::MediaConstraintsInterface::kAutoGainControl,
-   webrtc::MediaConstraintsInterface::kValueFalse},
-  {webrtc::MediaConstraintsInterface::kNoiseSuppression,
-   webrtc::MediaConstraintsInterface::kValueFalse},
-  {webrtc::MediaConstraintsInterface::kHighpassFilter,
-   webrtc::MediaConstraintsInterface::kValueFalse},
+    {webrtc::MediaConstraintsInterface::kEchoCancellation,
+     webrtc::MediaConstraintsInterface::kValueFalse},
+    {webrtc::MediaConstraintsInterface::kAutoGainControl,
+     webrtc::MediaConstraintsInterface::kValueFalse},
+    {webrtc::MediaConstraintsInterface::kNoiseSuppression,
+     webrtc::MediaConstraintsInterface::kValueFalse},
+    {webrtc::MediaConstraintsInterface::kHighpassFilter,
+     webrtc::MediaConstraintsInterface::kValueFalse},
 };
 
 class WebAudioConstraints : public RTCMediaConstraints {
  public:
   WebAudioConstraints()
       : RTCMediaConstraints(WebKit::WebMediaConstraints()) {
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kWebAudioConstraints); ++i) {
       webrtc::MediaConstraintsInterface::Constraint constraint;
       constraint.key = kWebAudioConstraints[i].key;
       constraint.value = kWebAudioConstraints[i].value;
@@ skipping 333 matching lines @@
     }
     return native_stream->AddTrack(audio_track);
   } else {
     scoped_refptr<webrtc::VideoTrackInterface> video_track(
         CreateLocalVideoTrack(track_id, source_data->video_source()));
     video_track->set_enabled(track.isEnabled());
     return native_stream->AddTrack(video_track);
   }
 }
 
+bool MediaStreamDependencyFactory::AddNativeVideoMediaTrack(
+    const std::string& track_id,
+    WebKit::WebMediaStream* stream,
+    cricket::VideoCapturer* capturer) {
+  if (!stream) {
+    LOG(ERROR) << "AddNativeVideoMediaTrack called with null WebMediaStream.";
+    return false;
+  }
+
+  // Create native track from the source.
+  scoped_refptr<webrtc::VideoTrackInterface> native_track =
+      CreateLocalVideoTrack(track_id, capturer);
+
+  // Add the native track to native stream
+  MediaStreamExtraData* extra_data =
+      static_cast<MediaStreamExtraData*>(stream->extraData());
+  DCHECK(extra_data);
+  webrtc::MediaStreamInterface* native_stream = extra_data->stream();
+  native_stream->AddTrack(native_track);
+
+  // Create a new webkit video track.
+  WebKit::WebMediaStreamTrack webkit_track;
+  WebKit::WebMediaStreamSource webkit_source;
+  WebKit::WebString webkit_track_id(UTF8ToUTF16(track_id));
+  WebKit::WebMediaStreamSource::Type type =
+      WebKit::WebMediaStreamSource::TypeVideo;
+  webkit_source.initialize(webkit_track_id, type, webkit_track_id);
+  webkit_track.initialize(webkit_track_id, webkit_source);
+
+  // Add the track to WebMediaStream.
+  stream->addTrack(webkit_track);
+  return true;
+}
+
 bool MediaStreamDependencyFactory::RemoveNativeMediaStreamTrack(
     const WebKit::WebMediaStream& stream,
     const WebKit::WebMediaStreamTrack& track) {
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream.extraData());
   webrtc::MediaStreamInterface* native_stream = extra_data->stream();
   DCHECK(native_stream);
 
   WebKit::WebMediaStreamSource::Type type = track.source().type();
   DCHECK(type == WebKit::WebMediaStreamSource::TypeAudio ||
@@ skipping 132 matching lines @@
   return true;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoSourceInterface* source) {
   return pc_factory_->CreateVideoTrack(id, source).get();
 }
 
+scoped_refptr<webrtc::VideoTrackInterface>
+MediaStreamDependencyFactory::CreateLocalVideoTrack(
+    const std::string& id, cricket::VideoCapturer* capturer) {
+  if (!capturer) {
+    LOG(ERROR) << "CreateLocalVideoTrack called with null VideoCapturer.";
+    return NULL;
+  }
+
+  // Create video source from the |capturer|.
+  scoped_refptr<webrtc::VideoSourceInterface> source =
+      pc_factory_->CreateVideoSource(capturer, NULL).get();
+
+  // Create native track from the source.
+  return pc_factory_->CreateVideoTrack(id, source).get();
+}
+
 scoped_refptr<webrtc::AudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
     webrtc::AudioSourceInterface* source) {
   // TODO(xians): Merge |source| to the capturer(). We can't do this today
   // because only one capturer() is supported while one |source| is created
   // for each audio track.
   return WebRtcLocalAudioTrack::Create(id, GetWebRtcAudioDevice()->capturer(),
                                        source);
 }
@@ skipping 130 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content