Refactor "secure bool" into explicit PROTO_TLS.

webrtc/p2p/base/port_unittest.cc

 /*
  *  Copyright 2004 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 525 matching lines @@
                              0, 0, username, password_);
     // TODO: Add an external address for ext_proto, so that the
     // other side can connect to this port using a non-UDP protocol.
   }
   rtc::NATServer* CreateNatServer(const SocketAddress& addr,
                                         rtc::NATType type) {
     return new rtc::NATServer(type, ss_.get(), addr, addr, ss_.get(), addr);
   }
   static const char* StunName(NATType type) {
     switch (type) {
-      case NAT_OPEN_CONE:       return "stun(open cone)";
-      case NAT_ADDR_RESTRICTED: return "stun(addr restricted)";
-      case NAT_PORT_RESTRICTED: return "stun(port restricted)";
-      case NAT_SYMMETRIC:       return "stun(symmetric)";
-      default:                  return "stun(?)";
+      case NAT_OPEN_CONE:
+        return "stun(open cone)";
+      case NAT_ADDR_RESTRICTED:
+        return "stun(addr restricted)";
+      case NAT_PORT_RESTRICTED:
+        return "stun(port restricted)";
+      case NAT_SYMMETRIC:
+        return "stun(symmetric)";
+      default:
+        return "stun(?)";
     }
   }
   static const char* RelayName(RelayType type, ProtocolType proto) {
     if (type == RELAY_TURN) {
       switch (proto) {
-        case PROTO_UDP:           return "turn(udp)";
-        case PROTO_TCP:           return "turn(tcp)";
-        case PROTO_SSLTCP:        return "turn(ssltcp)";
-        default:                  return "turn(?)";
+        case PROTO_UDP:
+          return "turn(udp)";
+        case PROTO_TCP:
+          return "turn(tcp)";
+        case PROTO_SSLTCP:
+          return "turn(ssltcp)";
+        case PROTO_TLS:
+          return "turn(tls)";
+        default:
+          return "turn(?)";
       }
     } else {
       switch (proto) {
-        case PROTO_UDP:           return "gturn(udp)";
-        case PROTO_TCP:           return "gturn(tcp)";
-        case PROTO_SSLTCP:        return "gturn(ssltcp)";
-        default:                  return "gturn(?)";
+        case PROTO_UDP:
+          return "gturn(udp)";
+        case PROTO_TCP:
+          return "gturn(tcp)";
+        case PROTO_SSLTCP:
+          return "gturn(ssltcp)";
+        case PROTO_TLS:
+          return "gturn(tls)";
+        default:
+          return "gturn(?)";
       }
     }
   }
 
   void SetNetworkType(rtc::AdapterType adapter_type) {
     network_.set_type(adapter_type);
   }
 
   void TestCrossFamilyPorts(int type);
 
@@ skipping 1793 matching lines @@
   EXPECT_TRUE(cand1.priority() > cand2.priority());
 }
 
 // Test the Connection priority is calculated correctly.
 TEST_F(PortTest, TestConnectionPriority) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_HOST);
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
-  rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY);
+  rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY_UDP);
   lport->set_component(123);
   lport->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
   rport->set_component(23);
   rport->AddCandidateAddress(SocketAddress("10.1.1.100", 1234));
 
   EXPECT_EQ(0x7E001E85U, lport->Candidates()[0].priority());
   EXPECT_EQ(0x2001EE9U, rport->Candidates()[0].priority());
 
   // RFC 5245
   // pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
@@ skipping 354 matching lines @@
       port->CreateConnection(candidate, Port::ORIGIN_MESSAGE);
   EXPECT_NE(conn1, conn2);
   conn_in_use = port->GetConnection(address);
   EXPECT_EQ(conn2, conn_in_use);
   EXPECT_EQ(2u, conn_in_use->remote_candidate().generation());
 
   // Make sure the new connection was not deleted.
   rtc::Thread::Current()->ProcessMessages(300);
   EXPECT_TRUE(port->GetConnection(address) != nullptr);
 }