Unify Transport and newapi::Transport interfaces.

webrtc/voice_engine/channel.cc

 /*
  *  Copyright (c) 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 196 matching lines @@
 {
     CriticalSectionScoped cs(&_callbackCritSect);
     if (_rxVadObserverPtr)
     {
         _rxVadObserverPtr->OnRxVad(_channelId, vadDecision);
     }
 
     return 0;
 }
 
-int
-Channel::SendPacket(const void *data, size_t len)
+bool
+Channel::SendRtp(const uint8_t *data, size_t len)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::SendPacket(channel=%d, len=%" PRIuS ")", len);
 
     CriticalSectionScoped cs(&_callbackCritSect);
 
     if (_transportPtr == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
                      "Channel::SendPacket() failed to send RTP packet due to"
                      " invalid transport object");
-        return -1;
+        return false;
     }
 
     uint8_t* bufferToSendPtr = (uint8_t*)data;
     size_t bufferLength = len;
 
-    int n = _transportPtr->SendPacket(bufferToSendPtr, bufferLength);
-    if (n < 0) {
+    if (!_transportPtr->SendRtp(bufferToSendPtr, bufferLength)) {
       std::string transport_name =
           _externalTransport ? "external transport" : "WebRtc sockets";
       WEBRTC_TRACE(kTraceError, kTraceVoice,
                    VoEId(_instanceId,_channelId),
                    "Channel::SendPacket() RTP transmission using %s failed",
                    transport_name.c_str());
-      return -1;
+      return false;
     }
-    return n;
+    return true;
 }
 
-int
-Channel::SendRTCPPacket(const void *data, size_t len)
+bool
+Channel::SendRtcp(const uint8_t *data, size_t len)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::SendRTCPPacket(len=%" PRIuS ")", len);
+                 "Channel::SendRtcp(len=%" PRIuS ")", len);
 
     CriticalSectionScoped cs(&_callbackCritSect);
     if (_transportPtr == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice,
                      VoEId(_instanceId,_channelId),
-                     "Channel::SendRTCPPacket() failed to send RTCP packet"
+                     "Channel::SendRtcp() failed to send RTCP packet"
                      " due to invalid transport object");
-        return -1;
+        return false;
     }
 
     uint8_t* bufferToSendPtr = (uint8_t*)data;
     size_t bufferLength = len;
 
-    int n = _transportPtr->SendRTCPPacket(bufferToSendPtr, bufferLength);
+    int n = _transportPtr->SendRtcp(bufferToSendPtr, bufferLength);
     if (n < 0) {
       std::string transport_name =
           _externalTransport ? "external transport" : "WebRtc sockets";
       WEBRTC_TRACE(kTraceInfo, kTraceVoice,
                    VoEId(_instanceId,_channelId),
-                   "Channel::SendRTCPPacket() transmission using %s failed",
+                   "Channel::SendRtcp() transmission using %s failed",
                    transport_name.c_str());
-      return -1;
+      return false;
     }
-    return n;
+    return true;
 }
 
 void Channel::OnPlayTelephoneEvent(uint8_t event,
                                    uint16_t lengthMs,
                                    uint8_t volume) {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::OnPlayTelephoneEvent(event=%u, lengthMs=%u,"
                  " volume=%u)", event, lengthMs, volume);
 
     if (!_playOutbandDtmfEvent || (event > 15))
@@ skipping 3412 matching lines @@
 
         assert(_audioFrame.samples_per_channel_ == toneSamples);
     } else
     {
         // Add 10ms to "delay-since-last-tone" counter
         _inbandDtmfGenerator.UpdateDelaySinceLastTone();
     }
     return 0;
 }
 
-int32_t
-Channel::SendPacketRaw(const void *data, size_t len, bool RTCP)
-{
-    CriticalSectionScoped cs(&_callbackCritSect);
-    if (_transportPtr == NULL)
-    {
-        return -1;
-    }
-    if (!RTCP)
-    {
-        return _transportPtr->SendPacket(data, len);
-    }
-    else
-    {
-        return _transportPtr->SendRTCPPacket(data, len);
-    }
-}
-
 void Channel::UpdatePlayoutTimestamp(bool rtcp) {
   uint32_t playout_timestamp = 0;
 
   if (audio_coding_->PlayoutTimestamp(&playout_timestamp) == -1)  {
     // This can happen if this channel has not been received any RTP packet. In
     // this case, NetEq is not capable of computing playout timestamp.
     return;
   }
 
   uint16_t delay_ms = 0;
@@ skipping 234 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt)
       != 0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc