Remove candidates when doing continual gathering

webrtc/p2p/base/transportcontroller.cc

 /*
  *  Copyright 2015 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 109 matching lines @@
 }
 
 bool TransportController::AddRemoteCandidates(const std::string& transport_name,
                                               const Candidates& candidates,
                                               std::string* err) {
   return worker_thread_->Invoke<bool>(
       rtc::Bind(&TransportController::AddRemoteCandidates_w, this,
                 transport_name, candidates, err));
 }
 
+bool TransportController::RemoveRemoteCandidates(
+    const std::string& transport_name,
+    const Candidates& candidates,
+    std::string* err) {
+  return worker_thread_->Invoke<bool>(
+      rtc::Bind(&TransportController::RemoveRemoteCandidates_w, this,
+                transport_name, candidates, err));
+}
+
 bool TransportController::ReadyForRemoteCandidates(
     const std::string& transport_name) {
   return worker_thread_->Invoke<bool>(rtc::Bind(
       &TransportController::ReadyForRemoteCandidates_w, this, transport_name));
 }
 
 bool TransportController::GetStats(const std::string& transport_name,
                                    TransportStats* stats) {
   return worker_thread_->Invoke<bool>(
       rtc::Bind(&TransportController::GetStats_w, this, transport_name, stats));
@@ skipping 15 matching lines @@
   Transport* transport = GetOrCreateTransport_w(transport_name);
   TransportChannelImpl* channel = transport->CreateChannel(component);
   channel->SignalWritableState.connect(
       this, &TransportController::OnChannelWritableState_w);
   channel->SignalReceivingState.connect(
       this, &TransportController::OnChannelReceivingState_w);
   channel->SignalGatheringState.connect(
       this, &TransportController::OnChannelGatheringState_w);
   channel->SignalCandidateGathered.connect(
       this, &TransportController::OnChannelCandidateGathered_w);
+  channel->SignalCandidatesRemoved.connect(
+      this, &TransportController::OnChannelCandidatesRemoved_w);
   channel->SignalRoleConflict.connect(
       this, &TransportController::OnChannelRoleConflict_w);
   channel->SignalConnectionRemoved.connect(
       this, &TransportController::OnChannelConnectionRemoved_w);
   channels_.insert(channels_.end(), RefCountedChannel(channel))->AddRef();
   // Adding a channel could cause aggregate state to change.
   UpdateAggregateStates_w();
   return channel;
 }
 
@@ skipping 278 matching lines @@
   Transport* transport = GetTransport_w(transport_name);
   if (!transport) {
     // If we didn't find a transport, that's not an error;
     // it could have been deleted as a result of bundling.
     return true;
   }
 
   return transport->AddRemoteCandidates(candidates, err);
 }
 
+bool TransportController::RemoveRemoteCandidates_w(
+    const std::string& transport_name,
+    const Candidates& candidates,
+    std::string* err) {
+  RTC_DCHECK(worker_thread()->IsCurrent());
+
+  Transport* transport = GetTransport_w(transport_name);
+  if (!transport) {
+    // If we didn't find a transport, that's not an error;
+    // it could have been deleted as a result of bundling.
+    return true;
+  }
+
+  return transport->RemoveRemoteCandidates(candidates, err);
+}
+
 bool TransportController::ReadyForRemoteCandidates_w(
     const std::string& transport_name) {
   RTC_DCHECK(worker_thread()->IsCurrent());
 
   Transport* transport = GetTransport_w(transport_name);
   if (!transport) {
     return false;
   }
   return transport->ready_for_remote_candidates();
 }
@@ skipping 38 matching lines @@
     RTC_DCHECK(false);
     return;
   }
   std::vector<Candidate> candidates;
   candidates.push_back(candidate);
   CandidatesData* data =
       new CandidatesData(channel->transport_name(), candidates);
   signaling_thread_->Post(this, MSG_CANDIDATESGATHERED, data);
 }
 
+void TransportController::OnChannelCandidatesRemoved_w(
+    TransportChannelImpl* channel,
+    const Candidates& candidates) {
+  invoker_.AsyncInvoke<void>(
+      signaling_thread_,
+      rtc::Bind(&TransportController::OnChannelCandidatesRemoved, this,
+                channel->transport_name(), candidates));
+}
+
+void TransportController::OnChannelCandidatesRemoved(
+    const std::string& transport_name,
+    const Candidates& candidates) {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  SignalCandidatesRemoved(transport_name, candidates);
+}
+
 void TransportController::OnChannelRoleConflict_w(
     TransportChannelImpl* channel) {
   RTC_DCHECK(worker_thread_->IsCurrent());
 
   if (ice_role_switch_) {
     LOG(LS_WARNING)
         << "Repeat of role conflict signal from TransportChannelImpl.";
     return;
   }
 
@@ skipping 69 matching lines @@
   }
   if (gathering_state_ != new_gathering_state) {
     gathering_state_ = new_gathering_state;
     signaling_thread_->Post(
         this, MSG_ICEGATHERINGSTATE,
         new rtc::TypedMessageData<IceGatheringState>(new_gathering_state));
   }
 }
 
 }  // namespace cricket