Remove old-style constraints from Chrome internals

content/renderer/media/webrtc/mock_peer_connection_dependency_factory.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/webrtc/mock_peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 149 matching lines @@
 MockVideoRenderer::MockVideoRenderer()
     : num_(0) {}
 
 MockVideoRenderer::~MockVideoRenderer() {}
 
 bool MockVideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
   ++num_;
   return true;
 }
 
-MockAudioSource::MockAudioSource(
-    const webrtc::MediaConstraintsInterface* constraints, bool remote)
-    : remote_(remote), state_(MediaSourceInterface::kLive),
-      optional_constraints_(constraints->GetOptional()),
-      mandatory_constraints_(constraints->GetMandatory()) {
-}
+MockAudioSource::MockAudioSource(const cricket::AudioOptions& options,
+                                 bool remote)
+    : remote_(remote), state_(MediaSourceInterface::kLive) {}
 
 MockAudioSource::~MockAudioSource() {}
 
 void MockAudioSource::RegisterObserver(webrtc::ObserverInterface* observer) {
   DCHECK(observers_.find(observer) == observers_.end());
   observers_.insert(observer);
 }
 
 void MockAudioSource::UnregisterObserver(webrtc::ObserverInterface* observer) {
   DCHECK(observers_.find(observer) != observers_.end());
@@ skipping 147 matching lines @@
 MockPeerConnectionDependencyFactory::MockPeerConnectionDependencyFactory()
     : PeerConnectionDependencyFactory(NULL),
       fail_to_create_next_audio_capturer_(false) {
 }
 
 MockPeerConnectionDependencyFactory::~MockPeerConnectionDependencyFactory() {}
 
 scoped_refptr<webrtc::PeerConnectionInterface>
 MockPeerConnectionDependencyFactory::CreatePeerConnection(
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
-    const webrtc::MediaConstraintsInterface* constraints,
     blink::WebFrame* frame,
     webrtc::PeerConnectionObserver* observer) {
   return new rtc::RefCountedObject<MockPeerConnectionImpl>(this, observer);
 }
 
 scoped_refptr<webrtc::AudioSourceInterface>
 MockPeerConnectionDependencyFactory::CreateLocalAudioSource(
-    const webrtc::MediaConstraintsInterface* constraints) {
+    const cricket::AudioOptions& options) {
   last_audio_source_ =
-      new rtc::RefCountedObject<MockAudioSource>(constraints, false);
+      new rtc::RefCountedObject<MockAudioSource>(options, false);
   return last_audio_source_;
 }
 
 WebRtcVideoCapturerAdapter*
 MockPeerConnectionDependencyFactory::CreateVideoCapturer(
     bool is_screen_capture) {
   return new MockRtcVideoCapturer(is_screen_capture);
 }
 
 scoped_refptr<webrtc::VideoTrackSourceInterface>
 MockPeerConnectionDependencyFactory::CreateVideoSource(
-    cricket::VideoCapturer* capturer,
-    const blink::WebMediaConstraints& constraints) {
+    cricket::VideoCapturer* capturer) {
   // Video source normally take ownership of |capturer|.
   delete capturer;
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 void MockPeerConnectionDependencyFactory::CreateWebAudioSource(
     blink::WebMediaStreamSource* source) {}
 
 scoped_refptr<webrtc::MediaStreamInterface>
@@ skipping 44 matching lines @@
   if (fail_to_create_next_audio_capturer_) {
     fail_to_create_next_audio_capturer_ = false;
     return NULL;
   }
   DCHECK(audio_source);
   return WebRtcAudioCapturer::CreateCapturer(-1, device_info, constraints, NULL,
                                              audio_source);
 }
 
 }  // namespace content