#include "base/strings/utf_string_conversions.h"
#include "content/renderer/media/mock_peer_connection_impl.h"
#include "content/renderer/media/webaudio_capturer_source.h"
+#include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
#include "content/renderer/media/webrtc_audio_capturer.h"
-#include "content/renderer/media/webrtc_local_audio_track.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
#include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
#include "third_party/libjingle/source/talk/base/scoped_ref_ptr.h"
#include "third_party/libjingle/source/talk/media/base/videocapturer.h"
return it;
};
-class MockMediaStream : public webrtc::MediaStreamInterface {
- public:
- explicit MockMediaStream(const std::string& label)
- : label_(label),
- observer_(NULL) {
- }
- virtual bool AddTrack(AudioTrackInterface* track) OVERRIDE {
- audio_track_vector_.push_back(track);
- if (observer_)
- observer_->OnChanged();
- return true;
- }
- virtual bool AddTrack(VideoTrackInterface* track) OVERRIDE {
- video_track_vector_.push_back(track);
- if (observer_)
- observer_->OnChanged();
- return true;
- }
- virtual bool RemoveTrack(AudioTrackInterface* track) OVERRIDE {
- AudioTrackVector::iterator it = FindTrack(&audio_track_vector_,
- track->id());
- if (it == audio_track_vector_.end())
- return false;
- audio_track_vector_.erase(it);
- if (observer_)
- observer_->OnChanged();
- return true;
- }
- virtual bool RemoveTrack(VideoTrackInterface* track) OVERRIDE {
- VideoTrackVector::iterator it = FindTrack(&video_track_vector_,
- track->id());
- if (it == video_track_vector_.end())
- return false;
- video_track_vector_.erase(it);
- if (observer_)
- observer_->OnChanged();
- return true;
- }
- virtual std::string label() const OVERRIDE { return label_; }
- virtual AudioTrackVector GetAudioTracks() OVERRIDE {
- return audio_track_vector_;
- }
- virtual VideoTrackVector GetVideoTracks() OVERRIDE {
- return video_track_vector_;
- }
- virtual talk_base::scoped_refptr<AudioTrackInterface>
- FindAudioTrack(const std::string& track_id) OVERRIDE {
- AudioTrackVector::iterator it = FindTrack(&audio_track_vector_, track_id);
- return it == audio_track_vector_.end() ? NULL : *it;
- }
- virtual talk_base::scoped_refptr<VideoTrackInterface>
- FindVideoTrack(const std::string& track_id) OVERRIDE {
- VideoTrackVector::iterator it = FindTrack(&video_track_vector_, track_id);
- return it == video_track_vector_.end() ? NULL : *it;
- }
- virtual void RegisterObserver(ObserverInterface* observer) OVERRIDE {
- DCHECK(!observer_);
- observer_ = observer;
- }
- virtual void UnregisterObserver(ObserverInterface* observer) OVERRIDE {
- DCHECK(observer_ == observer);
- observer_ = NULL;
- }
+MockMediaStream::MockMediaStream(const std::string& label)
+ : label_(label),
+ observer_(NULL) {
+}
+
+bool MockMediaStream::AddTrack(AudioTrackInterface* track) {
+ audio_track_vector_.push_back(track);
+ if (observer_)
+ observer_->OnChanged();
+ return true;
+}
- protected:
- virtual ~MockMediaStream() {}
+bool MockMediaStream::AddTrack(VideoTrackInterface* track) {
+ video_track_vector_.push_back(track);
+ if (observer_)
+ observer_->OnChanged();
+ return true;
+}
- private:
- std::string label_;
- AudioTrackVector audio_track_vector_;
- VideoTrackVector video_track_vector_;
- webrtc::ObserverInterface* observer_;
-};
+bool MockMediaStream::RemoveTrack(AudioTrackInterface* track) {
+ AudioTrackVector::iterator it = FindTrack(&audio_track_vector_,
+ track->id());
+ if (it == audio_track_vector_.end())
+ return false;
+ audio_track_vector_.erase(it);
+ if (observer_)
+ observer_->OnChanged();
+ return true;
+}
+
+bool MockMediaStream::RemoveTrack(VideoTrackInterface* track) {
+ VideoTrackVector::iterator it = FindTrack(&video_track_vector_,
+ track->id());
+ if (it == video_track_vector_.end())
+ return false;
+ video_track_vector_.erase(it);
+ if (observer_)
+ observer_->OnChanged();
+ return true;
+}
+
+std::string MockMediaStream::label() const {
+ return label_;
+}
+
+AudioTrackVector MockMediaStream::GetAudioTracks() {
+ return audio_track_vector_;
+}
+
+VideoTrackVector MockMediaStream::GetVideoTracks() {
+ return video_track_vector_;
+}
+
+talk_base::scoped_refptr<AudioTrackInterface> MockMediaStream::FindAudioTrack(
+ const std::string& track_id) {
+ AudioTrackVector::iterator it = FindTrack(&audio_track_vector_, track_id);
+ return it == audio_track_vector_.end() ? NULL : *it;
+}
+
+talk_base::scoped_refptr<VideoTrackInterface> MockMediaStream::FindVideoTrack(
+ const std::string& track_id) {
+ VideoTrackVector::iterator it = FindTrack(&video_track_vector_, track_id);
+ return it == video_track_vector_.end() ? NULL : *it;
+}
+
+void MockMediaStream::RegisterObserver(ObserverInterface* observer) {
+ DCHECK(!observer_);
+ observer_ = observer;
+}
+
+void MockMediaStream::UnregisterObserver(ObserverInterface* observer) {
+ DCHECK(observer_ == observer);
+ observer_ = NULL;
+}
+
+MockMediaStream::~MockMediaStream() {}
MockVideoRenderer::MockVideoRenderer()
: width_(0),
MockAudioSource::MockAudioSource(
const webrtc::MediaConstraintsInterface* constraints)
: observer_(NULL),
- state_(MediaSourceInterface::kInitializing),
+ state_(MediaSourceInterface::kLive),
optional_constraints_(constraints->GetOptional()),
mandatory_constraints_(constraints->GetMandatory()) {
}
observer_ = NULL;
}
-void MockAudioSource::SetLive() {
- DCHECK(state_ == MediaSourceInterface::kInitializing ||
- state_ == MediaSourceInterface::kLive);
- state_ = MediaSourceInterface::kLive;
- if (observer_)
- observer_->OnChanged();
-}
-
-void MockAudioSource::SetEnded() {
- DCHECK_NE(MediaSourceInterface::kEnded, state_);
- state_ = MediaSourceInterface::kEnded;
- if (observer_)
- observer_->OnChanged();
-}
-
webrtc::MediaSourceInterface::SourceState MockAudioSource::state() const {
return state_;
}
};
MockMediaStreamDependencyFactory::MockMediaStreamDependencyFactory()
- : MediaStreamDependencyFactory(NULL),
- mock_pc_factory_created_(false) {
+ : MediaStreamDependencyFactory(NULL) {
}
MockMediaStreamDependencyFactory::~MockMediaStreamDependencyFactory() {}
-bool MockMediaStreamDependencyFactory::EnsurePeerConnectionFactory() {
- mock_pc_factory_created_ = true;
- return true;
-}
-
-bool MockMediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
- return mock_pc_factory_created_;
-}
-
scoped_refptr<webrtc::PeerConnectionInterface>
MockMediaStreamDependencyFactory::CreatePeerConnection(
const webrtc::PeerConnectionInterface::IceServers& ice_servers,
const webrtc::MediaConstraintsInterface* constraints,
blink::WebFrame* frame,
webrtc::PeerConnectionObserver* observer) {
- DCHECK(mock_pc_factory_created_);
return new talk_base::RefCountedObject<MockPeerConnectionImpl>(this);
}
return last_audio_source_;
}
-scoped_refptr<webrtc::VideoSourceInterface>
-MockMediaStreamDependencyFactory::CreateLocalVideoSource(
- int video_session_id,
- bool is_screencast,
- const webrtc::MediaConstraintsInterface* constraints) {
- last_video_source_ = new talk_base::RefCountedObject<MockVideoSource>();
- return last_video_source_;
+cricket::VideoCapturer* MockMediaStreamDependencyFactory::CreateVideoCapturer(
+ const StreamDeviceInfo& info) {
+ return NULL;
}
scoped_refptr<webrtc::VideoSourceInterface>
scoped_refptr<WebAudioCapturerSource>
MockMediaStreamDependencyFactory::CreateWebAudioSource(
- blink::WebMediaStreamSource* source,
- const RTCMediaConstraints& constraints) {
+ blink::WebMediaStreamSource* source) {
return NULL;
}
scoped_refptr<webrtc::MediaStreamInterface>
MockMediaStreamDependencyFactory::CreateLocalMediaStream(
const std::string& label) {
- DCHECK(mock_pc_factory_created_);
return new talk_base::RefCountedObject<MockMediaStream>(label);
}
MockMediaStreamDependencyFactory::CreateLocalVideoTrack(
const std::string& id,
webrtc::VideoSourceInterface* source) {
- DCHECK(mock_pc_factory_created_);
scoped_refptr<webrtc::VideoTrackInterface> track(
new talk_base::RefCountedObject<MockLocalVideoTrack>(
id, source));
MockMediaStreamDependencyFactory::CreateLocalVideoTrack(
const std::string& id,
cricket::VideoCapturer* capturer) {
- DCHECK(mock_pc_factory_created_);
-
scoped_refptr<MockVideoSource> source =
new talk_base::RefCountedObject<MockVideoSource>();
source->SetVideoCapturer(capturer);
scoped_refptr<webrtc::AudioTrackInterface>
MockMediaStreamDependencyFactory::CreateLocalAudioTrack(
- const std::string& id,
+ const blink::WebMediaStreamTrack& blink_track,
const scoped_refptr<WebRtcAudioCapturer>& capturer,
WebAudioCapturerSource* webaudio_source,
webrtc::AudioSourceInterface* source) {
- DCHECK(mock_pc_factory_created_);
- blink::WebMediaConstraints constraints;
- scoped_refptr<WebRtcAudioCapturer> audio_capturer = capturer ?
- capturer : WebRtcAudioCapturer::CreateCapturer(-1, StreamDeviceInfo(),
- constraints, NULL);
- return WebRtcLocalAudioTrack::Create(
- id, audio_capturer, webaudio_source, source);
+ return WebRtcLocalAudioTrackAdapter::Create(blink_track.id().utf8(), source);
}
SessionDescriptionInterface*
projects / platform / framework / web / crosswalk.git / blobdiff