Rewrite PeerConnection integration tests using better testing practices.

webrtc/pc/peerconnection.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.
  */
 
 #include "webrtc/pc/peerconnection.h"
 
 #include <algorithm>
-#include <cctype>  // for isdigit
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/mediaconstraintsinterface.h"
 #include "webrtc/api/mediastreamproxy.h"
 #include "webrtc/api/mediastreamtrackproxy.h"
-#include "webrtc/base/arraysize.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/sctp/sctptransport.h"
 #include "webrtc/pc/audiotrack.h"
@@ skipping 21 matching lines @@
 using webrtc::RtpSenderInternal;
 using webrtc::RtpSenderInterface;
 using webrtc::RtpSenderProxy;
 using webrtc::RtpSenderProxyWithInternal;
 using webrtc::StreamCollection;
 
 static const char kDefaultStreamLabel[] = "default";
 static const char kDefaultAudioTrackLabel[] = "defaulta0";
 static const char kDefaultVideoTrackLabel[] = "defaultv0";
 
-// The min number of tokens must present in Turn host uri.
-// e.g. user@turn.example.org
-static const size_t kTurnHostTokensNum = 2;
-// Number of tokens must be preset when TURN uri has transport param.
-static const size_t kTurnTransportTokensNum = 2;
-// The default stun port.
-static const int kDefaultStunPort = 3478;
-static const int kDefaultStunTlsPort = 5349;
-static const char kTransport[] = "transport";
-
-// NOTE: Must be in the same order as the ServiceType enum.
-static const char* kValidIceServiceTypes[] = {"stun", "stuns", "turn", "turns"};
-
 // The length of RTCP CNAMEs.
 static const int kRtcpCnameLength = 16;
 
-// NOTE: A loop below assumes that the first value of this enum is 0 and all
-// other values are incremental.
-enum ServiceType {
-  STUN = 0,  // Indicates a STUN server.
-  STUNS,     // Indicates a STUN server used with a TLS session.
-  TURN,      // Indicates a TURN server
-  TURNS,     // Indicates a TURN server used with a TLS session.
-  INVALID,   // Unknown.
-};
-static_assert(INVALID == arraysize(kValidIceServiceTypes),
-              "kValidIceServiceTypes must have as many strings as ServiceType "
-              "has values.");
-
 enum {
   MSG_SET_SESSIONDESCRIPTION_SUCCESS = 0,
   MSG_SET_SESSIONDESCRIPTION_FAILED,
   MSG_CREATE_SESSIONDESCRIPTION_FAILED,
   MSG_GETSTATS,
   MSG_FREE_DATACHANNELS,
 };
 
 struct SetSessionDescriptionMsg : public rtc::MessageData {
   explicit SetSessionDescriptionMsg(
@@ skipping 16 matching lines @@
 
 struct GetStatsMsg : public rtc::MessageData {
   GetStatsMsg(webrtc::StatsObserver* observer,
               webrtc::MediaStreamTrackInterface* track)
       : observer(observer), track(track) {
   }
   rtc::scoped_refptr<webrtc::StatsObserver> observer;
   rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track;
 };
 
-// |in_str| should be of format
-// stunURI       = scheme ":" stun-host [ ":" stun-port ]
-// scheme        = "stun" / "stuns"
-// stun-host     = IP-literal / IPv4address / reg-name
-// stun-port     = *DIGIT
-//
-// draft-petithuguenin-behave-turn-uris-01
-// turnURI       = scheme ":" turn-host [ ":" turn-port ]
-// turn-host     = username@IP-literal / IPv4address / reg-name
-bool GetServiceTypeAndHostnameFromUri(const std::string& in_str,
-                                      ServiceType* service_type,
-                                      std::string* hostname) {
-  const std::string::size_type colonpos = in_str.find(':');
-  if (colonpos == std::string::npos) {
-    LOG(LS_WARNING) << "Missing ':' in ICE URI: " << in_str;
-    return false;
-  }
-  if ((colonpos + 1) == in_str.length()) {
-    LOG(LS_WARNING) << "Empty hostname in ICE URI: " << in_str;
-    return false;
-  }
-  *service_type = INVALID;
-  for (size_t i = 0; i < arraysize(kValidIceServiceTypes); ++i) {
-    if (in_str.compare(0, colonpos, kValidIceServiceTypes[i]) == 0) {
-      *service_type = static_cast<ServiceType>(i);
-      break;
-    }
-  }
-  if (*service_type == INVALID) {
-    return false;
-  }
-  *hostname = in_str.substr(colonpos + 1, std::string::npos);
-  return true;
-}
-
-bool ParsePort(const std::string& in_str, int* port) {
-  // Make sure port only contains digits. FromString doesn't check this.
-  for (const char& c : in_str) {
-    if (!std::isdigit(c)) {
-      return false;
-    }
-  }
-  return rtc::FromString(in_str, port);
-}
-
-// This method parses IPv6 and IPv4 literal strings, along with hostnames in
-// standard hostname:port format.
-// Consider following formats as correct.
-// |hostname:port|, |[IPV6 address]:port|, |IPv4 address|:port,
-// |hostname|, |[IPv6 address]|, |IPv4 address|.
-bool ParseHostnameAndPortFromString(const std::string& in_str,
-                                    std::string* host,
-                                    int* port) {
-  RTC_DCHECK(host->empty());
-  if (in_str.at(0) == '[') {
-    std::string::size_type closebracket = in_str.rfind(']');
-    if (closebracket != std::string::npos) {
-      std::string::size_type colonpos = in_str.find(':', closebracket);
-      if (std::string::npos != colonpos) {
-        if (!ParsePort(in_str.substr(closebracket + 2, std::string::npos),
-                       port)) {
-          return false;
-        }
-      }
-      *host = in_str.substr(1, closebracket - 1);
-    } else {
-      return false;
-    }
-  } else {
-    std::string::size_type colonpos = in_str.find(':');
-    if (std::string::npos != colonpos) {
-      if (!ParsePort(in_str.substr(colonpos + 1, std::string::npos), port)) {
-        return false;
-      }
-      *host = in_str.substr(0, colonpos);
-    } else {
-      *host = in_str;
-    }
-  }
-  return !host->empty();
-}
-
-// Adds a STUN or TURN server to the appropriate list,
-// by parsing |url| and using the username/password in |server|.
-RTCErrorType ParseIceServerUrl(
-    const PeerConnectionInterface::IceServer& server,
-    const std::string& url,
-    cricket::ServerAddresses* stun_servers,
-    std::vector<cricket::RelayServerConfig>* turn_servers) {
-  // draft-nandakumar-rtcweb-stun-uri-01
-  // stunURI       = scheme ":" stun-host [ ":" stun-port ]
-  // scheme        = "stun" / "stuns"
-  // stun-host     = IP-literal / IPv4address / reg-name
-  // stun-port     = *DIGIT
-
-  // draft-petithuguenin-behave-turn-uris-01
-  // turnURI       = scheme ":" turn-host [ ":" turn-port ]
-  //                 [ "?transport=" transport ]
-  // scheme        = "turn" / "turns"
-  // transport     = "udp" / "tcp" / transport-ext
-  // transport-ext = 1*unreserved
-  // turn-host     = IP-literal / IPv4address / reg-name
-  // turn-port     = *DIGIT
-  RTC_DCHECK(stun_servers != nullptr);
-  RTC_DCHECK(turn_servers != nullptr);
-  std::vector<std::string> tokens;
-  cricket::ProtocolType turn_transport_type = cricket::PROTO_UDP;
-  RTC_DCHECK(!url.empty());
-  rtc::tokenize_with_empty_tokens(url, '?', &tokens);
-  std::string uri_without_transport = tokens[0];
-  // Let's look into transport= param, if it exists.
-  if (tokens.size() == kTurnTransportTokensNum) {  // ?transport= is present.
-    std::string uri_transport_param = tokens[1];
-    rtc::tokenize_with_empty_tokens(uri_transport_param, '=', &tokens);
-    if (tokens[0] != kTransport) {
-      LOG(LS_WARNING) << "Invalid transport parameter key.";
-      return RTCErrorType::SYNTAX_ERROR;
-    }
-    if (tokens.size() < 2) {
-      LOG(LS_WARNING) << "Transport parameter missing value.";
-      return RTCErrorType::SYNTAX_ERROR;
-    }
-    if (!cricket::StringToProto(tokens[1].c_str(), &turn_transport_type) ||
-        (turn_transport_type != cricket::PROTO_UDP &&
-         turn_transport_type != cricket::PROTO_TCP)) {
-      LOG(LS_WARNING) << "Transport parameter should always be udp or tcp.";
-      return RTCErrorType::SYNTAX_ERROR;
-    }
-  }
-
-  std::string hoststring;
-  ServiceType service_type;
-  if (!GetServiceTypeAndHostnameFromUri(uri_without_transport,
-                                       &service_type,
-                                       &hoststring)) {
-    LOG(LS_WARNING) << "Invalid transport parameter in ICE URI: " << url;
-    return RTCErrorType::SYNTAX_ERROR;
-  }
-
-  // GetServiceTypeAndHostnameFromUri should never give an empty hoststring
-  RTC_DCHECK(!hoststring.empty());
-
-  // Let's break hostname.
-  tokens.clear();
-  rtc::tokenize_with_empty_tokens(hoststring, '@', &tokens);
-
-  std::string username(server.username);
-  if (tokens.size() > kTurnHostTokensNum) {
-    LOG(LS_WARNING) << "Invalid user@hostname format: " << hoststring;
-    return RTCErrorType::SYNTAX_ERROR;
-  }
-  if (tokens.size() == kTurnHostTokensNum) {
-    if (tokens[0].empty() || tokens[1].empty()) {
-      LOG(LS_WARNING) << "Invalid user@hostname format: " << hoststring;
-      return RTCErrorType::SYNTAX_ERROR;
-    }
-    username.assign(rtc::s_url_decode(tokens[0]));
-    hoststring = tokens[1];
-  } else {
-    hoststring = tokens[0];
-  }
-
-  int port = kDefaultStunPort;
-  if (service_type == TURNS) {
-    port = kDefaultStunTlsPort;
-    turn_transport_type = cricket::PROTO_TLS;
-  }
-
-  std::string address;
-  if (!ParseHostnameAndPortFromString(hoststring, &address, &port)) {
-    LOG(WARNING) << "Invalid hostname format: " << uri_without_transport;
-    return RTCErrorType::SYNTAX_ERROR;
-  }
-
-  if (port <= 0 || port > 0xffff) {
-    LOG(WARNING) << "Invalid port: " << port;
-    return RTCErrorType::SYNTAX_ERROR;
-  }
-
-  switch (service_type) {
-    case STUN:
-    case STUNS:
-      stun_servers->insert(rtc::SocketAddress(address, port));
-      break;
-    case TURN:
-    case TURNS: {
-      if (username.empty() || server.password.empty()) {
-        // The WebRTC spec requires throwing an InvalidAccessError when username
-        // or credential are ommitted; this is the native equivalent.
-        return RTCErrorType::INVALID_PARAMETER;
-      }
-      cricket::RelayServerConfig config = cricket::RelayServerConfig(
-          address, port, username, server.password, turn_transport_type);
-      if (server.tls_cert_policy ==
-          PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck) {
-        config.tls_cert_policy =
-            cricket::TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK;
-      }
-      turn_servers->push_back(config);
-      break;
-    }
-    default:
-      // We shouldn't get to this point with an invalid service_type, we should
-      // have returned an error already.
-      RTC_NOTREACHED() << "Unexpected service type";
-      return RTCErrorType::INTERNAL_ERROR;
-  }
-  return RTCErrorType::NONE;
-}
-
 // Check if we can send |new_stream| on a PeerConnection.
 bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
                             webrtc::MediaStreamInterface* new_stream) {
   if (!new_stream || !current_streams) {
     return false;
   }
   if (current_streams->find(new_stream->label()) != nullptr) {
     LOG(LS_ERROR) << "MediaStream with label " << new_stream->label()
                   << " is already added.";
     return false;
@@ skipping 272 matching lines @@
   for (auto& kv : session_options->transport_options) {
     kv.second.ice_restart = ice_restart;
   }
 
   if (!constraints) {
     return true;
   }
   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
 }
 
-RTCErrorType ParseIceServers(
-    const PeerConnectionInterface::IceServers& servers,
-    cricket::ServerAddresses* stun_servers,
-    std::vector<cricket::RelayServerConfig>* turn_servers) {
-  for (const webrtc::PeerConnectionInterface::IceServer& server : servers) {
-    if (!server.urls.empty()) {
-      for (const std::string& url : server.urls) {
-        if (url.empty()) {
-          LOG(LS_ERROR) << "Empty uri.";
-          return RTCErrorType::SYNTAX_ERROR;
-        }
-        RTCErrorType err =
-            ParseIceServerUrl(server, url, stun_servers, turn_servers);
-        if (err != RTCErrorType::NONE) {
-          return err;
-        }
-      }
-    } else if (!server.uri.empty()) {
-      // Fallback to old .uri if new .urls isn't present.
-      RTCErrorType err =
-          ParseIceServerUrl(server, server.uri, stun_servers, turn_servers);
-      if (err != RTCErrorType::NONE) {
-        return err;
-      }
-    } else {
-      LOG(LS_ERROR) << "Empty uri.";
-      return RTCErrorType::SYNTAX_ERROR;
-    }
-  }
-  // Candidates must have unique priorities, so that connectivity checks
-  // are performed in a well-defined order.
-  int priority = static_cast<int>(turn_servers->size() - 1);
-  for (cricket::RelayServerConfig& turn_server : *turn_servers) {
-    // First in the list gets highest priority.
-    turn_server.priority = priority--;
-  }
-  return RTCErrorType::NONE;
-}
-
 PeerConnection::PeerConnection(PeerConnectionFactory* factory)
     : factory_(factory),
       observer_(NULL),
       uma_observer_(NULL),
       signaling_state_(kStable),
       ice_connection_state_(kIceConnectionNew),
       ice_gathering_state_(kIceGatheringNew),
       event_log_(RtcEventLog::Create()),
       rtcp_cname_(GenerateRtcpCname()),
       local_streams_(StreamCollection::Create()),
@@ skipping 1904 matching lines @@
   }
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   if (event_log_) {
     event_log_->StopLogging();
   }
 }
 }  // namespace webrtc