Webrtc deps roll.

content/renderer/media/mock_peer_connection_impl.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_peer_connection_impl.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
@@ skipping 57 matching lines @@
         streams_.erase(it);
         break;
       }
     }
   }
 
  protected:
   virtual ~MockStreamCollection() {}
 
  private:
-  typedef std::vector<talk_base::scoped_refptr<MediaStreamInterface> >
+  typedef std::vector<rtc::scoped_refptr<MediaStreamInterface> >
       StreamVector;
   StreamVector streams_;
 };
 
 class MockDataChannel : public webrtc::DataChannelInterface {
  public:
   MockDataChannel(const std::string& label,
                   const webrtc::DataChannelInit* config)
       : label_(label),
         reliable_(config->reliable),
@@ skipping 98 matching lines @@
   virtual std::string tones() const OVERRIDE {
     return tones_;
   }
   virtual int duration() const OVERRIDE { return duration_; }
   virtual int inter_tone_gap() const OVERRIDE { return inter_tone_gap_; }
 
  protected:
   virtual ~MockDtmfSender() {}
 
  private:
-  talk_base::scoped_refptr<AudioTrackInterface> track_;
+  rtc::scoped_refptr<AudioTrackInterface> track_;
   DtmfSenderObserverInterface* observer_;
   std::string tones_;
   int duration_;
   int inter_tone_gap_;
 };
 
 const char MockPeerConnectionImpl::kDummyOffer[] = "dummy offer";
 const char MockPeerConnectionImpl::kDummyAnswer[] = "dummy answer";
 
 MockPeerConnectionImpl::MockPeerConnectionImpl(
     MockPeerConnectionDependencyFactory* factory)
     : dependency_factory_(factory),
-      local_streams_(new talk_base::RefCountedObject<MockStreamCollection>),
-      remote_streams_(new talk_base::RefCountedObject<MockStreamCollection>),
+      local_streams_(new rtc::RefCountedObject<MockStreamCollection>),
+      remote_streams_(new rtc::RefCountedObject<MockStreamCollection>),
       hint_audio_(false),
       hint_video_(false),
       getstats_result_(true),
       sdp_mline_index_(-1) {
   ON_CALL(*this, SetLocalDescription(_, _)).WillByDefault(testing::Invoke(
       this, &MockPeerConnectionImpl::SetLocalDescriptionWorker));
   ON_CALL(*this, SetRemoteDescription(_, _)).WillByDefault(testing::Invoke(
       this, &MockPeerConnectionImpl::SetRemoteDescriptionWorker));
 }
 
 MockPeerConnectionImpl::~MockPeerConnectionImpl() {}
 
-talk_base::scoped_refptr<webrtc::StreamCollectionInterface>
+rtc::scoped_refptr<webrtc::StreamCollectionInterface>
 MockPeerConnectionImpl::local_streams() {
   return local_streams_;
 }
 
-talk_base::scoped_refptr<webrtc::StreamCollectionInterface>
+rtc::scoped_refptr<webrtc::StreamCollectionInterface>
 MockPeerConnectionImpl::remote_streams() {
   return remote_streams_;
 }
 
 bool MockPeerConnectionImpl::AddStream(
     MediaStreamInterface* local_stream,
     const MediaConstraintsInterface* constraints) {
   DCHECK(stream_label_.empty());
   stream_label_ = local_stream->label();
   local_streams_->AddStream(local_stream);
   return true;
 }
 
 void MockPeerConnectionImpl::RemoveStream(
     MediaStreamInterface* local_stream) {
   DCHECK_EQ(stream_label_, local_stream->label());
   stream_label_.clear();
   local_streams_->RemoveStream(local_stream);
 }
 
-talk_base::scoped_refptr<DtmfSenderInterface>
+rtc::scoped_refptr<DtmfSenderInterface>
 MockPeerConnectionImpl::CreateDtmfSender(AudioTrackInterface* track) {
   if (!track) {
     return NULL;
   }
-  return new talk_base::RefCountedObject<MockDtmfSender>(track);
+  return new rtc::RefCountedObject<MockDtmfSender>(track);
 }
 
-talk_base::scoped_refptr<webrtc::DataChannelInterface>
+rtc::scoped_refptr<webrtc::DataChannelInterface>
 MockPeerConnectionImpl::CreateDataChannel(const std::string& label,
                       const webrtc::DataChannelInit* config) {
-  return new talk_base::RefCountedObject<MockDataChannel>(label, config);
+  return new rtc::RefCountedObject<MockDataChannel>(label, config);
 }
 
 bool MockPeerConnectionImpl::GetStats(
     webrtc::StatsObserver* observer,
     webrtc::MediaStreamTrackInterface* track,
     StatsOutputLevel level) {
   if (!getstats_result_)
     return false;
 
   DCHECK_EQ(kStatsOutputLevelStandard, level);
@@ skipping 87 matching lines @@
   sdp_mline_index_ = candidate->sdp_mline_index();
   return candidate->ToString(&ice_sdp_);
 }
 
 void MockPeerConnectionImpl::RegisterUMAObserver(
     webrtc::UMAObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace content