Remove BasicPortAllocator::EnableProtocol.

p2p/client/basicportallocator.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 25 matching lines @@
   MSG_CONFIG_READY,
   MSG_ALLOCATE,
   MSG_ALLOCATION_PHASE,
   MSG_SEQUENCEOBJECTS_CREATED,
   MSG_CONFIG_STOP,
 };
 
 const int PHASE_UDP = 0;
 const int PHASE_RELAY = 1;
 const int PHASE_TCP = 2;
-const int PHASE_SSLTCP = 3;
 
-const int kNumPhases = 4;
+const int kNumPhases = 3;
 
 // Gets protocol priority: UDP > TCP > SSLTCP == TLS.
 int GetProtocolPriority(cricket::ProtocolType protocol) {
   switch (protocol) {
     case cricket::PROTO_UDP:
       return 2;
     case cricket::PROTO_TCP:
       return 1;
     case cricket::PROTO_SSLTCP:
     case cricket::PROTO_TLS:
@@ skipping 342 matching lines @@
 }
 
 void BasicPortAllocatorSession::GetCandidatesFromPort(
     const PortData& data,
     std::vector<Candidate>* candidates) const {
   RTC_CHECK(candidates != nullptr);
   for (const Candidate& candidate : data.port()->Candidates()) {
     if (!CheckCandidateFilter(candidate)) {
       continue;
     }
-    ProtocolType pvalue;
-    if (!StringToProto(candidate.protocol().c_str(), &pvalue) ||
-        !data.sequence()->ProtocolEnabled(pvalue)) {
-      continue;
-    }
     candidates->push_back(SanitizeRelatedAddress(candidate));
   }
 }
 
 Candidate BasicPortAllocatorSession::SanitizeRelatedAddress(
     const Candidate& c) const {
   Candidate copy = c;
   // If adapter enumeration is disabled or host candidates are disabled,
   // clear the raddr of STUN candidates to avoid local address leakage.
   bool filter_stun_related_address =
@@ skipping 384 matching lines @@
       pruned = PruneTurnPorts(port);
     }
     // If the current port is not pruned yet, SignalPortReady.
     if (!data->pruned()) {
       LOG_J(LS_INFO, port) << "Port ready.";
       SignalPortReady(this, port);
       port->KeepAliveUntilPruned();
     }
   }
 
-  ProtocolType pvalue;
-  bool candidate_protocol_enabled =
-      StringToProto(c.protocol().c_str(), &pvalue) &&
-      data->sequence()->ProtocolEnabled(pvalue);
-
-  if (data->ready() && CheckCandidateFilter(c) && candidate_protocol_enabled) {
+  if (data->ready() && CheckCandidateFilter(c)) {
     std::vector<Candidate> candidates;
     candidates.push_back(SanitizeRelatedAddress(c));
     SignalCandidatesReady(this, candidates);
-  } else if (!candidate_protocol_enabled) {
-    LOG(LS_INFO)
-        << "Not yet signaling candidate because protocol is not yet enabled.";
   } else {
     LOG(LS_INFO) << "Discarding candidate because it doesn't match filter.";
   }
 
   // If we have pruned any port, maybe need to signal port allocation done.
   if (pruned) {
     MaybeSignalCandidatesAllocationDone();
   }
 }
 
@@ skipping 76 matching lines @@
     return;
   }
 
   // SignalAddressError is currently sent from StunPort/TurnPort.
   // But this signal itself is generic.
   data->set_error();
   // Send candidate allocation complete signal if this was the last port.
   MaybeSignalCandidatesAllocationDone();
 }
 
-void BasicPortAllocatorSession::OnProtocolEnabled(AllocationSequence* seq,
-                                                  ProtocolType proto) {
-  std::vector<Candidate> candidates;
-  for (std::vector<PortData>::iterator it = ports_.begin();
-       it != ports_.end(); ++it) {
-    if (it->sequence() != seq)
-      continue;
-
-    const std::vector<Candidate>& potentials = it->port()->Candidates();
-    for (size_t i = 0; i < potentials.size(); ++i) {
-      if (!CheckCandidateFilter(potentials[i])) {
-        continue;
-      }
-      ProtocolType pvalue;
-      bool candidate_protocol_enabled =
-          StringToProto(potentials[i].protocol().c_str(), &pvalue) &&
-          pvalue == proto;
-      if (candidate_protocol_enabled) {
-        LOG(LS_INFO) << "Signaling candidate because protocol was enabled: "
-                     << potentials[i].ToSensitiveString();
-        candidates.push_back(potentials[i]);
-      }
-    }
-  }
-
-  if (!candidates.empty()) {
-    SignalCandidatesReady(this, candidates);
-  }
-}
-
 bool BasicPortAllocatorSession::CheckCandidateFilter(const Candidate& c) const {
   uint32_t filter = candidate_filter_;
 
   // When binding to any address, before sending packets out, the getsockname
   // returns all 0s, but after sending packets, it'll be the NIC used to
   // send. All 0s is not a valid ICE candidate address and should be filtered
   // out.
   if (c.address().IsAnyIP()) {
     return false;
   }
@@ skipping 214 matching lines @@
   if (state_ == kRunning) {
     state_ = kStopped;
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
   }
 }
 
 void AllocationSequence::OnMessage(rtc::Message* msg) {
   RTC_DCHECK(rtc::Thread::Current() == session_->network_thread());
   RTC_DCHECK(msg->message_id == MSG_ALLOCATION_PHASE);
 
-  const char* const PHASE_NAMES[kNumPhases] = {
-    "Udp", "Relay", "Tcp", "SslTcp"
-  };
+  const char* const PHASE_NAMES[kNumPhases] = {"Udp", "Relay", "Tcp"};
 
   // Perform all of the phases in the current step.
   LOG_J(LS_INFO, network_) << "Allocation Phase="
                            << PHASE_NAMES[phase_];
 
   switch (phase_) {
     case PHASE_UDP:
       CreateUDPPorts();
       CreateStunPorts();
-      EnableProtocol(PROTO_UDP);
       break;
 
     case PHASE_RELAY:
       CreateRelayPorts();
       break;
 
     case PHASE_TCP:
       CreateTCPPorts();
-      EnableProtocol(PROTO_TCP);
-      break;
-
-    case PHASE_SSLTCP:
       state_ = kCompleted;
-      EnableProtocol(PROTO_SSLTCP);
       break;
 
     default:
       RTC_NOTREACHED();
   }
 
   if (state() == kRunning) {
     ++phase_;
     session_->network_thread()->PostDelayed(RTC_FROM_HERE,
                                             session_->allocator()->step_delay(),
                                             this, MSG_ALLOCATION_PHASE);
   } else {
     // If all phases in AllocationSequence are completed, no allocation
     // steps needed further. Canceling  pending signal.
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
     SignalPortAllocationComplete(this);
   }
 }
 
-void AllocationSequence::EnableProtocol(ProtocolType proto) {
-  if (!ProtocolEnabled(proto)) {
-    protocols_.push_back(proto);
-    session_->OnProtocolEnabled(this, proto);
-  }
-}
-
-bool AllocationSequence::ProtocolEnabled(ProtocolType proto) const {
-  for (ProtocolList::const_iterator it = protocols_.begin();
-       it != protocols_.end(); ++it) {
-    if (*it == proto)
-      return true;
-  }
-  return false;
-}
-
 void AllocationSequence::CreateUDPPorts() {
   if (IsFlagSet(PORTALLOCATOR_DISABLE_UDP)) {
     LOG(LS_VERBOSE) << "AllocationSequence: UDP ports disabled, skipping.";
     return;
   }
 
   // TODO(mallinath) - Remove UDPPort creating socket after shared socket
   // is enabled completely.
   UDPPort* port = NULL;
   bool emit_local_candidate_for_anyaddress =
@@ skipping 308 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket