Implement audio constraints for PeerConneciton API

content/renderer/media/mock_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/mock_media_stream_dependency_factory.h"
 
 #include "base/logging.h"
 #include "content/renderer/media/mock_peer_connection_impl.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 #include "third_party/libjingle/source/talk/base/scoped_ref_ptr.h"
@@ skipping 105 matching lines @@
   virtual ~MockLocalMediaStream() {}
 
  private:
   std::string label_;
   scoped_refptr<MockAudioTracks> audio_tracks_;
   scoped_refptr<MockVideoTracks> video_tracks_;
   AudioTrackVector audio_track_vector_;
   VideoTrackVector video_track_vector_;
 };
 
+MockAudioSource::MockAudioSource(
+    const webrtc::MediaConstraintsInterface* constraints)
+    : observer_(NULL),
+      state_(MediaSourceInterface::kInitializing),
+      optional_constraints_(constraints->GetOptional()),
+      mandatory_constraints_(constraints->GetMandatory()) {
+}
+
+MockAudioSource::~MockAudioSource() {}
+
+void MockAudioSource::RegisterObserver(webrtc::ObserverInterface* observer) {
+  observer_ = observer;
+}
+
+void MockAudioSource::UnregisterObserver(webrtc::ObserverInterface* observer) {
+  DCHECK(observer_ == observer);
+  observer_ = NULL;
+}
+
+void MockAudioSource::SetLive() {
+  DCHECK_EQ(MediaSourceInterface::kInitializing, state_);
+  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_;
+}
+
 MockVideoSource::MockVideoSource()
     : observer_(NULL),
       state_(MediaSourceInterface::kInitializing) {
 }
 
 MockVideoSource::~MockVideoSource() {}
 
 cricket::VideoCapturer* MockVideoSource::GetVideoCapturer() {
   NOTIMPLEMENTED();
   return NULL;
@@ skipping 233 matching lines @@
 scoped_refptr<webrtc::PeerConnectionInterface>
 MockMediaStreamDependencyFactory::CreatePeerConnection(
     const webrtc::JsepInterface::IceServers& ice_servers,
     const webrtc::MediaConstraintsInterface* constraints,
     WebKit::WebFrame* frame,
     webrtc::PeerConnectionObserver* observer) {
   DCHECK(mock_pc_factory_created_);
   return new talk_base::RefCountedObject<MockPeerConnectionImpl>(this);
 }
 
+scoped_refptr<webrtc::AudioSourceInterface>
+MockMediaStreamDependencyFactory::CreateLocalAudioSource(
+    const webrtc::MediaConstraintsInterface* constraints) {
+  last_audio_source_ =
+      new talk_base::RefCountedObject<MockAudioSource>(constraints);
+  return last_audio_source_;
+}
+
 scoped_refptr<webrtc::VideoSourceInterface>
-MockMediaStreamDependencyFactory::CreateVideoSource(
+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_;
 }
 
 bool MockMediaStreamDependencyFactory::InitializeAudioSource(
   const StreamDeviceInfo& device_info) {
   return true;
@@ skipping 18 matching lines @@
   DCHECK(mock_pc_factory_created_);
   scoped_refptr<webrtc::VideoTrackInterface> track(
       new talk_base::RefCountedObject<MockLocalVideoTrack>(
           id, source));
   return track;
 }
 
 scoped_refptr<webrtc::LocalAudioTrackInterface>
 MockMediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
-    webrtc::AudioDeviceModule* audio_device) {
+    webrtc::AudioSourceInterface* source) {
   DCHECK(mock_pc_factory_created_);
   scoped_refptr<webrtc::LocalAudioTrackInterface> track(
       new talk_base::RefCountedObject<MockLocalAudioTrack>(id));
   return track;
 }
 
 SessionDescriptionInterface*
 MockMediaStreamDependencyFactory::CreateSessionDescription(
       const std::string& type,
       const std::string& sdp) {
   return new MockSessionDescription(type, sdp);
 }
 
 webrtc::IceCandidateInterface*
 MockMediaStreamDependencyFactory::CreateIceCandidate(
     const std::string& sdp_mid,
     int sdp_mline_index,
     const std::string& sdp) {
   return new MockIceCandidate(sdp_mid, sdp_mline_index, sdp);
 }
 
 }  // namespace content