Move DTMF sender to RtpSender (as opposed to WebRtcSession).

webrtc/pc/dtmfsender.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 45 matching lines @@
     return false;
   }
   *code = p - kDtmfTonesTable - 1;
   return true;
 }
 
 rtc::scoped_refptr<DtmfSender> DtmfSender::Create(
     AudioTrackInterface* track,
     rtc::Thread* signaling_thread,
     DtmfProviderInterface* provider) {
-  if (!track || !signaling_thread) {
-    return NULL;
+  if (!signaling_thread) {
+    return nullptr;
   }
   rtc::scoped_refptr<DtmfSender> dtmf_sender(
       new rtc::RefCountedObject<DtmfSender>(track, signaling_thread,
                                                   provider));
   return dtmf_sender;
 }
 
 DtmfSender::DtmfSender(AudioTrackInterface* track,
                        rtc::Thread* signaling_thread,
                        DtmfProviderInterface* provider)
     : track_(track),
       observer_(NULL),
       signaling_thread_(signaling_thread),
       provider_(provider),
       duration_(kDtmfDefaultDurationMs),
       inter_tone_gap_(kDtmfDefaultGapMs) {
-  RTC_DCHECK(track_ != NULL);
   RTC_DCHECK(signaling_thread_ != NULL);
   // TODO(deadbeef): Once we can use shared_ptr and weak_ptr,
   // do that instead of relying on a "destroyed" signal.
   if (provider_) {
     RTC_DCHECK(provider_->GetOnDestroyedSignal() != NULL);
     provider_->GetOnDestroyedSignal()->connect(
         this, &DtmfSender::OnProviderDestroyed);
   }
 }
 
 DtmfSender::~DtmfSender() {
   StopSending();
 }
 
 void DtmfSender::RegisterObserver(DtmfSenderObserverInterface* observer) {
   observer_ = observer;
 }
 
 void DtmfSender::UnregisterObserver() {
   observer_ = NULL;
 }
 
 bool DtmfSender::CanInsertDtmf() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   if (!provider_) {
     return false;
   }
-  return provider_->CanInsertDtmf(track_->id());
+  return provider_->CanInsertDtmf();
 }
 
 bool DtmfSender::InsertDtmf(const std::string& tones, int duration,
                             int inter_tone_gap) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   if (duration > kDtmfMaxDurationMs ||
       duration < kDtmfMinDurationMs ||
       inter_tone_gap < kDtmfMinGapMs) {
     LOG(LS_ERROR) << "InsertDtmf is called with invalid duration or tones gap. "
@@ skipping 76 matching lines @@
     // Special case defined by WebRTC - The character',' indicates a delay of 2
     // seconds before processing the next character in the tones parameter.
     tone_gap = kDtmfTwoSecondInMs;
   } else {
     if (!provider_) {
       LOG(LS_ERROR) << "The DtmfProvider has been destroyed.";
       return;
     }
     // The provider starts playout of the given tone on the
     // associated RTP media stream, using the appropriate codec.
-    if (!provider_->InsertDtmf(track_->id(), code, duration_)) {
+    if (!provider_->InsertDtmf(code, duration_)) {
       LOG(LS_ERROR) << "The DtmfProvider can no longer send DTMF.";
       return;
     }
     // Wait for the number of milliseconds specified by |duration_|.
     tone_gap += duration_;
   }
 
   // Fire a “OnToneChange” event with the tone that's just processed.
   if (observer_) {
     observer_->OnToneChange(tones_.substr(first_tone_pos, 1));
@@ skipping 11 matching lines @@
   LOG(LS_INFO) << "The Dtmf provider is deleted. Clear the sending queue.";
   StopSending();
   provider_ = NULL;
 }
 
 void DtmfSender::StopSending() {
   signaling_thread_->Clear(this);
 }
 
 }  // namespace webrtc