Reland of: Adding error output param to SetConfiguration, using new RTCError type.

webrtc/api/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.
  */
 
@@ skipping 31 matching lines @@
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace {
 
 using webrtc::DataChannel;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
+using webrtc::RtcError;
 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";
 
@@ skipping 139 matching lines @@
       *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|.
-bool ParseIceServerUrl(const PeerConnectionInterface::IceServer& server,
-                       const std::string& url,
-                       cricket::ServerAddresses* stun_servers,
-                       std::vector<cricket::RelayServerConfig>* turn_servers) {
+RtcError 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 false;
+      return RtcError::SYNTAX_ERROR;
     }
     if (tokens.size() < 2 ||
         !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 param should always be udp or tcp.";
-      return false;
+      return RtcError::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 false;
+    return RtcError::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 false;
+    return RtcError::SYNTAX_ERROR;
   }
   if (tokens.size() == kTurnHostTokensNum) {
     if (tokens[0].empty() || tokens[1].empty()) {
       LOG(LS_WARNING) << "Invalid user@hostname format: " << hoststring;
-      return false;
+      return RtcError::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 false;
+    return RtcError::SYNTAX_ERROR;
   }
 
   if (port <= 0 || port > 0xffff) {
     LOG(WARNING) << "Invalid port: " << port;
-    return false;
+    return RtcError::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 RtcError::INVALID_PARAMETER;
+      }
       turn_servers->push_back(cricket::RelayServerConfig(
           address, port, username, server.password, turn_transport_type));
       break;
     }
-    case INVALID:
     default:
-      LOG(WARNING) << "Configuration not supported: " << url;
-      return false;
+      // We shouldn't get to this point with an invalid service_type, we should
+      // have returned an error already.
+      RTC_DCHECK(false) << "Unexpected service type";
+      return RtcError::INTERNAL_ERROR;
   }
-  return true;
+  return RtcError::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()
@@ skipping 91 matching lines @@
   for (auto& receiver : receivers) {
     if (receiver->media_type() == media_type) {
       if (!channel) {
         receiver->internal()->Stop();
       }
       static_cast<RECEIVER*>(receiver->internal())->SetChannel(channel);
     }
   }
 }
 
+// Helper to set an error and return from a method.
+bool SafeSetError(webrtc::RtcError error, webrtc::RtcError* error_output) {
+  if (error_output) {
+    *error_output = error;
+  }
+  return error == webrtc::RtcError::NONE;
+}
+
 }  // namespace
 
 namespace webrtc {
 
 static const char* const kRtcErrorNames[] = {
     "NONE",
     "UNSUPPORTED_PARAMETER",
     "INVALID_PARAMETER",
     "INVALID_RANGE",
     "SYNTAX_ERROR",
     "INVALID_STATE",
     "INVALID_MODIFICATION",
     "NETWORK_ERROR",
     "INTERNAL_ERROR",
 };
+static_assert(static_cast<int>(RtcError::INTERNAL_ERROR) ==
+                  (arraysize(kRtcErrorNames) - 1),
+              "kRtcErrorNames must have as many strings as RtcError "
+              "has values.");
 
 std::ostream& operator<<(std::ostream& stream, RtcError error) {
   int index = static_cast<int>(error);
-  RTC_CHECK(index < static_cast<int>(sizeof(kRtcErrorNames) /
-                                     sizeof(kRtcErrorNames[0])));
   return stream << kRtcErrorNames[index];
 }
 
+bool PeerConnectionInterface::RTCConfiguration::operator==(
+    const PeerConnectionInterface::RTCConfiguration& o) const {
+  // This static_assert prevents us from accidentally breaking operator==.
+  struct stuff_being_tested_for_equality {
+    IceTransportsType type;
+    IceServers servers;
+    BundlePolicy bundle_policy;
+    RtcpMuxPolicy rtcp_mux_policy;
+    TcpCandidatePolicy tcp_candidate_policy;
+    CandidateNetworkPolicy candidate_network_policy;
+    int audio_jitter_buffer_max_packets;
+    bool audio_jitter_buffer_fast_accelerate;
+    int ice_connection_receiving_timeout;
+    int ice_backup_candidate_pair_ping_interval;
+    ContinualGatheringPolicy continual_gathering_policy;
+    std::vector<rtc::scoped_refptr<rtc::RTCCertificate>> certificates;
+    bool prioritize_most_likely_ice_candidate_pairs;
+    struct cricket::MediaConfig media_config;
+    bool disable_ipv6;
+    bool enable_rtp_data_channel;
+    bool enable_quic;
+    rtc::Optional<int> screencast_min_bitrate;
+    rtc::Optional<bool> combined_audio_video_bwe;
+    rtc::Optional<bool> enable_dtls_srtp;
+    int ice_candidate_pool_size;
+    bool prune_turn_ports;
+    bool presume_writable_when_fully_relayed;
+    bool enable_ice_renomination;
+    bool redetermine_role_on_ice_restart;
+  };
+  static_assert(sizeof(stuff_being_tested_for_equality) == sizeof(*this),
+                "Did you add something to RTCConfiguration and forget to "
+                "update operator==?");

[Taylor Brandstetter, 2016/12/20 02:04:39]

This may seem like overkill, but I think there's a high chance of someone
modifying RTCConfiguration and forgetting to update operator== so it seemed
worth it to me. This is only a compile-time thing.

+  return type == o.type && servers == o.servers &&
+         bundle_policy == o.bundle_policy &&
+         rtcp_mux_policy == o.rtcp_mux_policy &&
+         tcp_candidate_policy == o.tcp_candidate_policy &&
+         candidate_network_policy == o.candidate_network_policy &&
+         audio_jitter_buffer_max_packets == o.audio_jitter_buffer_max_packets &&
+         audio_jitter_buffer_fast_accelerate ==
+             o.audio_jitter_buffer_fast_accelerate &&
+         ice_connection_receiving_timeout ==
+             o.ice_connection_receiving_timeout &&
+         ice_backup_candidate_pair_ping_interval ==
+             o.ice_backup_candidate_pair_ping_interval &&
+         continual_gathering_policy == o.continual_gathering_policy &&
+         certificates == o.certificates &&
+         prioritize_most_likely_ice_candidate_pairs ==
+             o.prioritize_most_likely_ice_candidate_pairs &&
+         media_config == o.media_config && disable_ipv6 == o.disable_ipv6 &&
+         enable_rtp_data_channel == o.enable_rtp_data_channel &&
+         enable_quic == o.enable_quic &&
+         screencast_min_bitrate == o.screencast_min_bitrate &&
+         combined_audio_video_bwe == o.combined_audio_video_bwe &&
+         enable_dtls_srtp == o.enable_dtls_srtp &&
+         ice_candidate_pool_size == o.ice_candidate_pool_size &&
+         prune_turn_ports == o.prune_turn_ports &&
+         presume_writable_when_fully_relayed ==
+             o.presume_writable_when_fully_relayed &&
+         enable_ice_renomination == o.enable_ice_renomination &&
+         redetermine_role_on_ice_restart == o.redetermine_role_on_ice_restart;
+}
+
+bool PeerConnectionInterface::RTCConfiguration::operator!=(
+    const PeerConnectionInterface::RTCConfiguration& o) const {
+  return !(*this == o);
+}
+
 // Generate a RTCP CNAME when a PeerConnection is created.
 std::string GenerateRtcpCname() {
   std::string cname;
   if (!rtc::CreateRandomString(kRtcpCnameLength, &cname)) {
     LOG(LS_ERROR) << "Failed to generate CNAME.";
     RTC_DCHECK(false);
   }
   return cname;
 }
 
@@ skipping 79 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();
 }
 
-bool ParseIceServers(const PeerConnectionInterface::IceServers& servers,
-                     cricket::ServerAddresses* stun_servers,
-                     std::vector<cricket::RelayServerConfig>* turn_servers) {
+RtcError 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 false;
+          return RtcError::SYNTAX_ERROR;
         }
-        if (!ParseIceServerUrl(server, url, stun_servers, turn_servers)) {
-          return false;
+        RtcError err =
+            ParseIceServerUrl(server, url, stun_servers, turn_servers);
+        if (err != RtcError::NONE) {
+          return err;
         }
       }
     } else if (!server.uri.empty()) {
       // Fallback to old .uri if new .urls isn't present.
-      if (!ParseIceServerUrl(server, server.uri, stun_servers, turn_servers)) {
-        return false;
+      RtcError err =
+          ParseIceServerUrl(server, server.uri, stun_servers, turn_servers);
+      if (err != RtcError::NONE) {
+        return err;
       }
     } else {
       LOG(LS_ERROR) << "Empty uri.";
-      return false;
+      return RtcError::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 true;
+  return RtcError::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(webrtc::Clock::GetRealTimeClock())),
@@ skipping 22 matching lines @@
   network_thread()->Invoke<void>(RTC_FROM_HERE,
                                  [this] { port_allocator_.reset(nullptr); });
 }
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     std::unique_ptr<cricket::PortAllocator> allocator,
     std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
     PeerConnectionObserver* observer) {
   TRACE_EVENT0("webrtc", "PeerConnection::Initialize");
-  RTC_DCHECK(observer != nullptr);
+  if (!allocator) {
+    LOG(LS_ERROR) << "PeerConnection initialized without a PortAllocator? "
+                  << "This shouldn't happen if using PeerConnectionFactory.";
+    return false;

[Taylor Brandstetter, 2016/12/20 02:04:39]

There's no code path in which passing a null PortAllocator works, so I removed
the "if (port_allocator_)" statements and replaced them with this.

+  }
   if (!observer) {
+    // TODO(deadbeef): Why do we do this?
+    LOG(LS_ERROR) << "PeerConnection initialized without a "
+                  << "PeerConnectionObserver";
     return false;
   }
   observer_ = observer;
-
   port_allocator_ = std::move(allocator);
 
   // The port allocator lives on the network thread and should be initialized
   // there.
   if (!network_thread()->Invoke<bool>(
           RTC_FROM_HERE, rtc::Bind(&PeerConnection::InitializePortAllocator_n,
                                    this, configuration))) {
     return false;
   }
 
@@ skipping 635 matching lines @@
 
   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
   signaling_thread()->Post(RTC_FROM_HERE, this,
                            MSG_SET_SESSIONDESCRIPTION_SUCCESS, msg);
 }
 
 PeerConnectionInterface::RTCConfiguration PeerConnection::GetConfiguration() {
   return configuration_;
 }
 
-bool PeerConnection::SetConfiguration(const RTCConfiguration& configuration) {
+bool PeerConnection::SetConfiguration(const RTCConfiguration& configuration,
+                                      RtcError* error) {
   TRACE_EVENT0("webrtc", "PeerConnection::SetConfiguration");
 
   if (session_->local_description() &&
       configuration.ice_candidate_pool_size !=
           configuration_.ice_candidate_pool_size) {
     LOG(LS_ERROR) << "Can't change candidate pool size after calling "
                      "SetLocalDescription.";
-    return false;
-  }
-  // TODO(deadbeef): Return false and log an error if there are any unsupported
-  // modifications.
-  if (port_allocator_) {
-    if (!network_thread()->Invoke<bool>(
-            RTC_FROM_HERE,
-            rtc::Bind(&PeerConnection::ReconfigurePortAllocator_n, this,
-                      configuration))) {
-      LOG(LS_ERROR) << "Failed to apply configuration to PortAllocator.";
-      return false;
-    }
+    return SafeSetError(RtcError::INVALID_MODIFICATION, error);
   }
 
-  // TODO(deadbeef): Shouldn't have to hop to the network thread twice...
-  session_->SetIceConfig(session_->ParseIceConfig(configuration));
+  // The simplest (and most future-compatible) way to tell if the config was
+  // modified in an invalid way is to copy each property we do support
+  // modifying, then use operator==. There are far more properties we don't
+  // support modifying than those we do, and more could be added.
+  RTCConfiguration modified_config = configuration_;
+  modified_config.servers = configuration.servers;
+  modified_config.type = configuration.type;
+  modified_config.ice_candidate_pool_size =
+      configuration.ice_candidate_pool_size;
+  modified_config.prune_turn_ports = configuration.prune_turn_ports;
+  if (configuration != modified_config) {
+    LOG(LS_ERROR) << "Modifying the configuration in an unsupported way.";
+    return SafeSetError(RtcError::INVALID_MODIFICATION, error);
+  }
+
+  // Note that this isn't possible through chromium, since it's an unsigned
+  // short in WebIDL.
+  if (configuration.ice_candidate_pool_size < 0 ||
+      configuration.ice_candidate_pool_size > UINT16_MAX) {
+    return SafeSetError(RtcError::INVALID_RANGE, error);
+  }
+
+  // Parse ICE servers before hopping to network thread.
+  cricket::ServerAddresses stun_servers;
+  std::vector<cricket::RelayServerConfig> turn_servers;
+  RtcError parse_error =
+      ParseIceServers(configuration.servers, &stun_servers, &turn_servers);
+  if (parse_error != RtcError::NONE) {
+    return SafeSetError(parse_error, error);
+  }
+
+  // In theory this shouldn't fail.
+  if (!network_thread()->Invoke<bool>(
+          RTC_FROM_HERE,
+          rtc::Bind(&PeerConnection::ReconfigurePortAllocator_n, this,
+                    stun_servers, turn_servers, modified_config.type,
+                    modified_config.ice_candidate_pool_size,
+                    modified_config.prune_turn_ports))) {
+    LOG(LS_ERROR) << "Failed to apply configuration to PortAllocator.";
+    return SafeSetError(RtcError::INTERNAL_ERROR, error);
+  }
 
   // As described in JSEP, calling setConfiguration with new ICE servers or
   // candidate policy must set a "needs-ice-restart" bit so that the next offer
   // triggers an ICE restart which will pick up the changes.
-  if (configuration.servers != configuration_.servers ||
-      configuration.type != configuration_.type) {
+  if (modified_config.servers != configuration_.servers ||
+      modified_config.type != configuration_.type ||
+      modified_config.prune_turn_ports != configuration_.prune_turn_ports) {
     session_->SetNeedsIceRestartFlag();
   }
-  configuration_ = configuration;
-  return true;
+  configuration_ = modified_config;
+  return SafeSetError(RtcError::NONE, error);
 }
 
 bool PeerConnection::AddIceCandidate(
     const IceCandidateInterface* ice_candidate) {
   TRACE_EVENT0("webrtc", "PeerConnection::AddIceCandidate");
   if (IsClosed()) {
     return false;
   }
   return session_->ProcessIceMessage(ice_candidate);
 }
 
 bool PeerConnection::RemoveIceCandidates(
     const std::vector<cricket::Candidate>& candidates) {
   TRACE_EVENT0("webrtc", "PeerConnection::RemoveIceCandidates");
   return session_->RemoveRemoteIceCandidates(candidates);
 }
 
 void PeerConnection::RegisterUMAObserver(UMAObserver* observer) {
   TRACE_EVENT0("webrtc", "PeerConnection::RegisterUmaObserver");
   uma_observer_ = observer;
 
   if (session_) {
     session_->set_metrics_observer(uma_observer_);
   }
 
   // Send information about IPv4/IPv6 status.
-  if (uma_observer_ && port_allocator_) {
+  if (uma_observer_) {
     port_allocator_->SetMetricsObserver(uma_observer_);
     if (port_allocator_->flags() & cricket::PORTALLOCATOR_ENABLE_IPV6) {
       uma_observer_->IncrementEnumCounter(
           kEnumCounterAddressFamily, kPeerConnection_IPv6,
           kPeerConnectionAddressFamilyCounter_Max);
     } else {
       uma_observer_->IncrementEnumCounter(
           kEnumCounterAddressFamily, kPeerConnection_IPv4,
           kPeerConnectionAddressFamilyCounter_Max);
     }
@@ skipping 972 matching lines @@
       return channel;
     }
   }
   return nullptr;
 }
 
 bool PeerConnection::InitializePortAllocator_n(
     const RTCConfiguration& configuration) {
   cricket::ServerAddresses stun_servers;
   std::vector<cricket::RelayServerConfig> turn_servers;
-  if (!ParseIceServers(configuration.servers, &stun_servers, &turn_servers)) {
+  if (ParseIceServers(configuration.servers, &stun_servers, &turn_servers) !=
+      RtcError::NONE) {
     return false;
   }
 
   port_allocator_->Initialize();
 
   // To handle both internal and externally created port allocator, we will
   // enable BUNDLE here.
   int portallocator_flags = port_allocator_->flags();
   portallocator_flags |= cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
                          cricket::PORTALLOCATOR_ENABLE_IPV6;
@@ skipping 25 matching lines @@
 
   // Call this last since it may create pooled allocator sessions using the
   // properties set above.
   port_allocator_->SetConfiguration(stun_servers, turn_servers,
                                     configuration.ice_candidate_pool_size,
                                     configuration.prune_turn_ports);
   return true;
 }
 
 bool PeerConnection::ReconfigurePortAllocator_n(
-    const RTCConfiguration& configuration) {
-  cricket::ServerAddresses stun_servers;
-  std::vector<cricket::RelayServerConfig> turn_servers;
-  if (!ParseIceServers(configuration.servers, &stun_servers, &turn_servers)) {
-    return false;
-  }
+    const cricket::ServerAddresses& stun_servers,
+    const std::vector<cricket::RelayServerConfig>& turn_servers,
+    IceTransportsType type,
+    int candidate_pool_size,
+    bool prune_turn_ports) {
   port_allocator_->set_candidate_filter(
-      ConvertIceTransportTypeToCandidateFilter(configuration.type));
+      ConvertIceTransportTypeToCandidateFilter(type));
   // Call this last since it may create pooled allocator sessions using the
   // candidate filter set above.
   return port_allocator_->SetConfiguration(
-      stun_servers, turn_servers, configuration.ice_candidate_pool_size,
-      configuration.prune_turn_ports);
+      stun_servers, turn_servers, candidate_pool_size, prune_turn_ports);
 }
 
 bool PeerConnection::StartRtcEventLog_w(rtc::PlatformFile file,
                                         int64_t max_size_bytes) {
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   event_log_->StopLogging();
 }
 }  // namespace webrtc