Fix IceTransportTest.TestBrokenTransport

remoting/protocol/ice_transport_channel.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/ice_transport_channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/protocol/channel_socket_adapter.h"
 #include "remoting/protocol/port_allocator_factory.h"
 #include "remoting/protocol/transport_context.h"
 #include "third_party/webrtc/base/network.h"
 #include "third_party/webrtc/p2p/base/constants.h"
 #include "third_party/webrtc/p2p/base/p2ptransportchannel.h"
 #include "third_party/webrtc/p2p/base/port.h"
 #include "third_party/webrtc/p2p/client/httpportallocator.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
-// Try connecting ICE twice with timeout of 15 seconds for each attempt.
-const int kMaxReconnectAttempts = 2;
-const int kReconnectDelaySeconds = 15;
-
 // Utility function to map a cricket::Candidate string type to a
 // TransportRoute::RouteType enum value.
 TransportRoute::RouteType CandidateTypeToTransportRouteType(
     const std::string& candidate_type) {
   if (candidate_type == "local") {
     return TransportRoute::DIRECT;
   } else if (candidate_type == "stun" || candidate_type == "prflx") {
     return TransportRoute::STUN;
   } else if (candidate_type == "relay") {
     return TransportRoute::RELAY;
   } else {
     LOG(FATAL) << "Unknown candidate type: " << candidate_type;
     return TransportRoute::DIRECT;
   }
 }
 
 }  // namespace
 
 IceTransportChannel::IceTransportChannel(
     scoped_refptr<TransportContext> transport_context)
     : transport_context_(transport_context),
       ice_username_fragment_(
           rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
-      connect_attempts_left_(kMaxReconnectAttempts),
+      connect_attempts_left_(
+          transport_context->network_settings().ice_reconnect_attempts),
       weak_factory_(this) {
   DCHECK(!ice_username_fragment_.empty());
 }
 
 IceTransportChannel::~IceTransportChannel() {
   DCHECK(delegate_);
 
   delegate_->OnChannelDeleted(this);
 
   auto task_runner = base::ThreadTaskRunnerHandle::Get();
@@ skipping 51 matching lines @@
   }
 
   while (!pending_candidates_.empty()) {
     channel_->AddRemoteCandidate(pending_candidates_.front());
     pending_candidates_.pop_front();
   }
 
   --connect_attempts_left_;
 
   // Start reconnection timer.
-  reconnect_timer_.Start(
-      FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds),
-      this, &IceTransportChannel::TryReconnect);
+  reconnect_timer_.Start(FROM_HERE,
+                         transport_context_->network_settings().ice_timeout,
+                         this, &IceTransportChannel::TryReconnect);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&IceTransportChannel::NotifyConnected,
                             weak_factory_.GetWeakPtr()));
 }
 
 void IceTransportChannel::NotifyConnected() {
   // Create P2PDatagramSocket adapter for the P2PTransportChannel.
   scoped_ptr<TransportChannelSocketAdapter> socket(
       new TransportChannelSocketAdapter(channel_.get()));
@@ skipping 53 matching lines @@
     const cricket::Candidate& candidate) {
   // Ignore notifications if the channel is not writable.
   if (channel_->writable())
     NotifyRouteChanged();
 }
 
 void IceTransportChannel::OnWritableState(cricket::TransportChannel* channel) {
   DCHECK_EQ(channel, static_cast<cricket::TransportChannel*>(channel_.get()));
 
   if (channel->writable()) {
-    connect_attempts_left_ = kMaxReconnectAttempts;
+    connect_attempts_left_ =
+        transport_context_->network_settings().ice_reconnect_attempts;
     reconnect_timer_.Stop();
 
     // Route change notifications are ignored when the |channel_| is not
     // writable. Notify the event handler about the current route once the
     // channel is writable.
     NotifyRouteChanged();
   } else {
     reconnect_timer_.Reset();
     TryReconnect();
   }
@@ skipping 52 matching lines @@
 
   // Restart ICE by resetting ICE password.
   std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
   delegate_->OnChannelIceCredentials(this, ice_username_fragment_,
                                      ice_password);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password);
 }
 
 }  // namespace protocol
 }  // namespace remoting