Remove candidates when doing continual gathering

webrtc/api/webrtcsession.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 536 matching lines @@
       metrics_observer_(NULL) {
   transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED);
   transport_controller_->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
   transport_controller_->SignalReceiving.connect(
       this, &WebRtcSession::OnTransportControllerReceiving);
   transport_controller_->SignalGatheringState.connect(
       this, &WebRtcSession::OnTransportControllerGatheringState);
   transport_controller_->SignalCandidatesGathered.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesGathered);
+  transport_controller_->SignalCandidatesRemoved.connect(
+      this, &WebRtcSession::OnTransportControllerCandidatesRemoved);
 }
 
 WebRtcSession::~WebRtcSession() {
   ASSERT(signaling_thread()->IsCurrent());
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   if (video_channel_) {
     SignalVideoChannelDestroyed();
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
@@ skipping 577 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool WebRtcSession::ProcessIceMessage(const IceCandidateInterface* candidate) {
   if (!remote_desc_) {
     LOG(LS_ERROR) << "ProcessIceMessage: ICE candidates can't be added "
                   << "without any remote session description.";
-     return false;
+    return false;
   }
 
   if (!candidate) {
     LOG(LS_ERROR) << "ProcessIceMessage: Candidate is NULL.";
     return false;
   }
 
   bool valid = false;
   bool ready = ReadyToUseRemoteCandidate(candidate, NULL, &valid);
   if (!valid) {
     return false;
   }
 
   // Add this candidate to the remote session description.
   if (!remote_desc_->AddCandidate(candidate)) {
     LOG(LS_ERROR) << "ProcessIceMessage: Candidate cannot be used.";
     return false;
   }
 
   if (ready) {
     return UseCandidate(candidate);
   } else {
     LOG(LS_INFO) << "ProcessIceMessage: Not ready to use candidate.";
     return true;
   }
 }
 
+bool WebRtcSession::RemoveRemoteIceCandidates(
+    const std::vector<IceCandidateInterfaceRefPtr>& candidates) {
+  if (!remote_desc_) {
+    LOG(LS_ERROR) << "RemoveRemoteIceCandidates: ICE candidates can't be "
+                  << "removed without any remote session description.";
+    return false;
+  }
+
+  if (candidates.empty()) {
+    LOG(LS_ERROR) << "RemoveRemoteIceCandidates: Candidates is empty.";
+    return false;
+  }
+
+  int number_removed = remote_desc_->RemoveCandidates(candidates);
+  if (number_removed != candidates.size()) {
+    LOG(LS_ERROR) << "RemoveRemoteIceCandidates: Failed to remove candidates. "
+                  << "Requested " << candidates.size() << " only "
+                  << number_removed << " are removed.";
+  }
+  return CeaseRemoteCandidates(candidates);
+}
+
 bool WebRtcSession::SetIceTransports(
     PeerConnectionInterface::IceTransportsType type) {
   return port_allocator()->set_candidate_filter(
         ConvertIceTransportTypeToCandidateFilter(type));
 }
 
 cricket::IceConfig WebRtcSession::ParseIceConfig(
     const PeerConnectionInterface::RTCConfiguration& config) const {
   cricket::IceConfig ice_config;
   ice_config.receiving_timeout_ms = config.ice_connection_receiving_timeout;
@@ skipping 390 matching lines @@
     JsepIceCandidate candidate(transport_name, sdp_mline_index, *citer);
     if (ice_observer_) {
       ice_observer_->OnIceCandidate(&candidate);
     }
     if (local_desc_) {
       local_desc_->AddCandidate(&candidate);
     }
   }
 }
 
+void WebRtcSession::OnTransportControllerCandidatesRemoved(
+    const std::string& transport_name,
+    const cricket::Candidates& candidates) {
+  ASSERT(signaling_thread()->IsCurrent());
+  int sdp_mline_index;
+  if (!GetLocalCandidateMediaIndex(transport_name, &sdp_mline_index)) {
+    LOG(LS_ERROR) << "OnTransportControllerCandidatesRemoved: content name "
+                  << transport_name << " not found";
+    return;
+  }
+
+  std::vector<IceCandidateInterfaceRefPtr> ice_candidates;
+  for (const cricket::Candidate& cand : candidates) {
+    // Use transport_name as the candidate media id.
+    JsepIceCandidate* candidate =
+        new JsepIceCandidate(transport_name, sdp_mline_index, cand);
+    ice_candidates.push_back(candidate);
+  }
+
+  if (local_desc_) {
+    local_desc_->RemoveCandidates(ice_candidates);
+  }
+  if (ice_observer_) {
+    ice_observer_->OnIceCandidatesRemoved(ice_candidates);
+  }
+}
+
 // Enabling voice and video channel.
 void WebRtcSession::EnableChannels() {
   if (voice_channel_ && !voice_channel_->enabled())
     voice_channel_->Enable(true);
 
   if (video_channel_ && !video_channel_->enabled())
     video_channel_->Enable(true);
 
   if (data_channel_ && !data_channel_->enabled())
     data_channel_->Enable(true);
@@ skipping 39 matching lines @@
       }
       ret = UseCandidate(candidate);
       if (!ret) {
         break;
       }
     }
   }
   return ret;
 }
 
-bool WebRtcSession::UseCandidate(
-    const IceCandidateInterface* candidate) {
-
+const cricket::ContentInfo* WebRtcSession::GetRemoteMediaContent(
+    const IceCandidateInterface* candidate) const {
   size_t mediacontent_index = static_cast<size_t>(candidate->sdp_mline_index());
   size_t remote_content_size = remote_desc_->description()->contents().size();
   if (mediacontent_index >= remote_content_size) {
-    LOG(LS_ERROR)
-        << "UseRemoteCandidateInSession: Invalid candidate media index.";
+    return nullptr;
+  }
+  return &(remote_desc_->description()->contents()[mediacontent_index]);
+}
+
+bool WebRtcSession::UseCandidate(const IceCandidateInterface* candidate) {
+  const cricket::ContentInfo* content = GetRemoteMediaContent(candidate);
+  if (content == nullptr) {
+    LOG(LS_ERROR) << "UseCandidate: media content not found";
     return false;
   }
-
-  cricket::ContentInfo content =
-      remote_desc_->description()->contents()[mediacontent_index];
-  std::vector<cricket::Candidate> candidates;
-  candidates.push_back(candidate->candidate());
+  std::vector<cricket::Candidate> candidates(1, candidate->candidate());
   // Invoking BaseSession method to handle remote candidates.
   std::string error;
-  if (transport_controller_->AddRemoteCandidates(content.name, candidates,
+  if (transport_controller_->AddRemoteCandidates(content->name, candidates,
                                                  &error)) {
     // Candidates successfully submitted for checking.
     if (ice_connection_state_ == PeerConnectionInterface::kIceConnectionNew ||
         ice_connection_state_ ==
             PeerConnectionInterface::kIceConnectionDisconnected) {
       // If state is New, then the session has just gotten its first remote ICE
       // candidates, so go to Checking.
       // If state is Disconnected, the session is re-using old candidates or
       // receiving additional ones, so go to Checking.
       // If state is Connected, stay Connected.
       // TODO(bemasc): If state is Connected, and the new candidates are for a
       // newly added transport, then the state actually _should_ move to
       // checking.  Add a way to distinguish that case.
       SetIceConnectionState(PeerConnectionInterface::kIceConnectionChecking);
     }
     // TODO(bemasc): If state is Completed, go back to Connected.
   } else {
     if (!error.empty()) {
       LOG(LS_WARNING) << error;
     }
   }
   return true;
 }
 
+bool WebRtcSession::CeaseRemoteCandidates(

[pthatcher1, 2016/03/01 23:51:54]

Why is this a separate method from RemoveRemoteCandidates?  It seems weird to
have both Cease and Remove.  Looking at this method, it seems it should be
called RemoveRemoteCandidates, but we've already got one of those.

If you *have* to keep this separate, perhaps call it
RemoteRemoteCandidatesFromTransportController.

[honghaiz3, 2016/03/02 19:06:40]

I tried to make it symmetric to the process of adding candidates. 
CeaseRemoteCandidates is opposite to UseCandidates. 
UseCandidate means the underlying stack (TransportController,
p2ptransportchannel) starts to use the candidates to create connections. 
CeaseRemoteCandidate means that the transport channels/controllers stop using
them, while RemoveRemoteCandidates including both removing them from the
description and stop using them. 

[pthatcher1, 2016/03/02 20:37:58]

Then please call it RemoveRemoteCandidatesFromTransportController

[honghaiz3, 2016/03/03 01:17:40]

Done.

+    const std::vector<IceCandidateInterfaceRefPtr>& ice_candidates) {
+  const cricket::ContentInfo* content = nullptr;
+  cricket::Candidates candidates;
+  for (auto ice_candidate : ice_candidates) {
+    const cricket::ContentInfo* new_content =
+        GetRemoteMediaContent(ice_candidate);
+    if (!new_content) {
+      LOG(LS_ERROR) << "CeaseRemoteCandidates: media content not found";
+      return false;
+    }
+    if (!content) {
+      content = new_content;
+    } else if (content != new_content) {
+      LOG(LS_ERROR) << "CeaseRemoteCandidates: media content is different";
+      return false;
+    }
+    candidates.push_back(ice_candidate->candidate());
+  }
+  std::string error;
+  bool res = transport_controller_->RemoveRemoteCandidates(content->name,
+                                                           candidates, &error);
+  if (!res) {
+    LOG(LS_WARNING) << "Error when Removing remote candidate: " << error;
+  }
+  return res;
+}
+
 void WebRtcSession::RemoveUnusedChannels(const SessionDescription* desc) {
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   const cricket::ContentInfo* video_info =
       cricket::GetFirstVideoContent(desc);
   if ((!video_info || video_info->rejected) && video_channel_) {
     SignalVideoChannelDestroyed();
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
 
@@ skipping 440 matching lines @@
   }
 }
 
 void WebRtcSession::OnSentPacket_w(cricket::TransportChannel* channel,
                                    const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
   media_controller_->call_w()->OnSentPacket(sent_packet);
 }
 
 }  // namespace webrtc