Webrtc deps roll.

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 "base/logging.h"
 #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/webrtc_video_capturer_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"
+#include "third_party/webrtc/base/scoped_ref_ptr.h"
 
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::IceCandidateCollection;
 using webrtc::IceCandidateInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::ObserverInterface;
 using webrtc::SessionDescriptionInterface;
 using webrtc::VideoRendererInterface;
@@ skipping 54 matching lines @@
 }
 
 AudioTrackVector MockMediaStream::GetAudioTracks() {
   return audio_track_vector_;
 }
 
 VideoTrackVector MockMediaStream::GetVideoTracks() {
   return video_track_vector_;
 }
 
-talk_base::scoped_refptr<AudioTrackInterface> MockMediaStream::FindAudioTrack(
+rtc::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(
+rtc::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(observers_.find(observer) == observers_.end());
   observers_.insert(observer);
 }
 
@@ skipping 326 matching lines @@
 }
 
 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 talk_base::RefCountedObject<MockPeerConnectionImpl>(this);
+  return new rtc::RefCountedObject<MockPeerConnectionImpl>(this);
 }
 
 scoped_refptr<webrtc::AudioSourceInterface>
 MockPeerConnectionDependencyFactory::CreateLocalAudioSource(
     const webrtc::MediaConstraintsInterface* constraints) {
   last_audio_source_ =
-      new talk_base::RefCountedObject<MockAudioSource>(constraints);
+      new rtc::RefCountedObject<MockAudioSource>(constraints);
   return last_audio_source_;
 }
 
 WebRtcVideoCapturerAdapter*
 MockPeerConnectionDependencyFactory::CreateVideoCapturer(
     bool is_screen_capture) {
   return new MockRtcVideoCapturer(is_screen_capture);
 }
 
 scoped_refptr<webrtc::VideoSourceInterface>
 MockPeerConnectionDependencyFactory::CreateVideoSource(
     cricket::VideoCapturer* capturer,
     const blink::WebMediaConstraints& constraints) {
-  last_video_source_ = new talk_base::RefCountedObject<MockVideoSource>();
+  last_video_source_ = new rtc::RefCountedObject<MockVideoSource>();
   last_video_source_->SetVideoCapturer(capturer);
   return last_video_source_;
 }
 
 scoped_refptr<WebAudioCapturerSource>
 MockPeerConnectionDependencyFactory::CreateWebAudioSource(
     blink::WebMediaStreamSource* source) {
   return NULL;
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 MockPeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
-  return new talk_base::RefCountedObject<MockMediaStream>(label);
+  return new rtc::RefCountedObject<MockMediaStream>(label);
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MockPeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoSourceInterface* source) {
   scoped_refptr<webrtc::VideoTrackInterface> track(
-      new talk_base::RefCountedObject<MockWebRtcVideoTrack>(
+      new rtc::RefCountedObject<MockWebRtcVideoTrack>(
           id, source));
   return track;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MockPeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     cricket::VideoCapturer* capturer) {
   scoped_refptr<MockVideoSource> source =
-      new talk_base::RefCountedObject<MockVideoSource>();
+      new rtc::RefCountedObject<MockVideoSource>();
   source->SetVideoCapturer(capturer);
 
   return
-      new talk_base::RefCountedObject<MockWebRtcVideoTrack>(id, source.get());
+      new rtc::RefCountedObject<MockWebRtcVideoTrack>(id, source.get());
 }
 
 SessionDescriptionInterface*
 MockPeerConnectionDependencyFactory::CreateSessionDescription(
     const std::string& type,
     const std::string& sdp,
     webrtc::SdpParseError* error) {
   return new MockSessionDescription(type, sdp);
 }
 
@@ skipping 18 matching lines @@
   return WebRtcAudioCapturer::CreateCapturer(-1, device_info,
                                              constraints, NULL, audio_source);
 }
 
 void MockPeerConnectionDependencyFactory::StartLocalAudioTrack(
       WebRtcLocalAudioTrack* audio_track) {
   audio_track->Start();
 }
 
 }  // namespace content