Unify Transport and newapi::Transport interfaces.

webrtc/test/channel_transport/udp_transport_impl.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 1838 matching lines @@
     {
         return _ptrSendRtpSocket->SendTo(data,length,to);
 
     } else if(_ptrRtpSocket)
     {
         return _ptrRtpSocket->SendTo(data,length,to);
     }
     return -1;
 }
 
-int32_t UdpTransportImpl::SendRTCPPacketTo(const int8_t* data,
+int32_t UdpTransportImpl::SendRtcpTo(const int8_t* data,
                                            size_t length,
                                            const SocketAddress& to)
 {
 
     CriticalSectionScoped cs(_crit);
 
     if(_ptrSendRtcpSocket)
     {
         return _ptrSendRtcpSocket->SendTo(data,length,to);
 
@@ skipping 25 matching lines @@
     {
         return _ptrSendRtpSocket->SendTo(data,length,to);
 
     } else if(_ptrRtpSocket)
     {
         return _ptrRtpSocket->SendTo(data,length,to);
     }
     return -1;
 }
 
-int32_t UdpTransportImpl::SendRTCPPacketTo(const int8_t* data,
+int32_t UdpTransportImpl::SendRtcpTo(const int8_t* data,
                                            size_t length,
                                            const uint16_t rtcpPort)
 {
     CriticalSectionScoped cs(_crit);
 
     // Use the current SocketAdress but update it with rtcpPort.
     SocketAddress to;
     memcpy(&to, &_remoteRTCPAddr, sizeof(SocketAddress));
 
     if(_ipV6Enabled)
     {
         to._sockaddr_in6.sin6_port = Htons(rtcpPort);
     } else
     {
         to._sockaddr_in.sin_port = Htons(rtcpPort);
     }
 
     if(_ptrSendRtcpSocket)
     {
         return _ptrSendRtcpSocket->SendTo(data,length,to);
 
     } else if(_ptrRtcpSocket)
     {
         return _ptrRtcpSocket->SendTo(data,length,to);
     }
     return -1;
 }
 
-int UdpTransportImpl::SendPacket(const void* data, size_t length) {
+bool UdpTransportImpl::SendRtp(const uint8_t* data, size_t length) {
     WEBRTC_TRACE(kTraceStream, kTraceTransport, _id, "%s", __FUNCTION__);
 
     CriticalSectionScoped cs(_crit);
 
     if(_destIP[0] == 0)
     {
-        return -1;
+        return false;
     }
     if(_destPort == 0)
     {
-        return -1;
+        return false;
     }
 
     // Create socket if it hasn't been set up already.
     // TODO (hellner): why not fail here instead. Sockets not being initialized
     //                 indicates that there is a problem somewhere.
     if( _ptrSendRtpSocket == NULL &&
         _ptrRtpSocket == NULL)
     {
         WEBRTC_TRACE(
             kTraceStateInfo,
@@ skipping 17 matching lines @@
         }
         _localPort = _destPort;
 
         ErrorCode retVal = BindLocalRTPSocket();
         if(retVal != kNoSocketError)
         {
             WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                          "SendPacket() failed to bind RTP socket");
             _lastError = retVal;
             CloseReceiveSockets();
-            return -1;
+            return false;
         }
     }
 
     if(_ptrSendRtpSocket)
     {
         return _ptrSendRtpSocket->SendTo((const int8_t*)data, length,
-                                         _remoteRTPAddr);
+                                         _remoteRTPAddr) >= 0;
 
     } else if(_ptrRtpSocket)
     {
         return _ptrRtpSocket->SendTo((const int8_t*)data, length,
-                                     _remoteRTPAddr);
+                                     _remoteRTPAddr) >= 0;
     }
-    return -1;
+    return false;
 }
 
-int UdpTransportImpl::SendRTCPPacket(const void* data, size_t length) {
+bool UdpTransportImpl::SendRtcp(const uint8_t* data, size_t length) {
     CriticalSectionScoped cs(_crit);
     if(_destIP[0] == 0)
     {
-        return -1;
+        return false;
     }
     if(_destPortRTCP == 0)
     {
-        return -1;
+        return false;
     }
 
     // Create socket if it hasn't been set up already.
     // TODO (hellner): why not fail here instead. Sockets not being initialized
     //                 indicates that there is a problem somewhere.
     if( _ptrSendRtcpSocket == NULL &&
         _ptrRtcpSocket == NULL)
     {
         WEBRTC_TRACE(
             kTraceStateInfo,
@@ skipping 15 matching lines @@
             strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
                     kIpAddressVersion6Length);
         }
         _localPortRTCP = _destPortRTCP;
 
         ErrorCode retVal = BindLocalRTCPSocket();
         if(retVal != kNoSocketError)
         {
             _lastError = retVal;
             WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
-                         "SendRTCPPacket() failed to bind RTCP socket");
+                         "SendRtcp() failed to bind RTCP socket");
             CloseReceiveSockets();
-            return -1;
+            return false;
         }
     }
 
     if(_ptrSendRtcpSocket)
     {
         return _ptrSendRtcpSocket->SendTo((const int8_t*)data, length,
-                                          _remoteRTCPAddr);
+                                          _remoteRTCPAddr) >= 0;
     } else if(_ptrRtcpSocket)
     {
         return _ptrRtcpSocket->SendTo((const int8_t*)data, length,
-                                      _remoteRTCPAddr);
+                                      _remoteRTCPAddr) >= 0;
     }
-    return -1;
+    return false;
 }
 
 int32_t UdpTransportImpl::SetSendIP(const char* ipaddr)
 {
     if(!IsIpAddressValid(ipaddr,IpV6Enabled()))
     {
         return kIpAddressInvalid;
     }
     CriticalSectionScoped cs(_crit);
     strncpy(_destIP, ipaddr,kIpAddressVersion6Length);
@@ skipping 913 matching lines @@
         if (nDots != 3 || !allUnder256)
         {
             return false;
         }
     }
     return true;
 }
 
 }  // namespace test
 }  // namespace webrtc