Remove candidates when doing continual gathering

webrtc/api/jsep.h

 /*
  *  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.
  */
 
 // Interfaces matching the draft-ietf-rtcweb-jsep-01.
 
 #ifndef WEBRTC_API_JSEP_H_
 #define WEBRTC_API_JSEP_H_
 
 #include <string>
 #include <vector>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 
 namespace cricket {
 class SessionDescription;
 class Candidate;
 }  // namespace cricket
 
 namespace webrtc {
 
 struct SdpParseError {
  public:
   // The sdp line that causes the error.
   std::string line;
   // Explains the error.
   std::string description;
 };
 
 // Class representation of an ICE candidate.
 // An instance of this interface is supposed to be owned by one class at
 // a time and is therefore not expected to be thread safe.
-class IceCandidateInterface {
+class IceCandidateInterface : public rtc::RefCountInterface {
  public:
   virtual ~IceCandidateInterface() {}
   /// If present, this contains the identierfier of the "media stream
   // identification" as defined in [RFC 3388] for m-line this candidate is
   // assocated with.
   virtual std::string sdp_mid() const = 0;
   // This indeicates the index (starting at zero) of m-line in the SDP this
   // candidate is assocated with.
   virtual int sdp_mline_index() const = 0;
   virtual const cricket::Candidate& candidate() const = 0;
   // Creates a SDP-ized form of this candidate.
   virtual bool ToString(std::string* out) const = 0;
 };
 
+typedef rtc::scoped_refptr<IceCandidateInterface> IceCandidateInterfaceRefPtr;
+
 // Creates a IceCandidateInterface based on SDP string.
 // Returns NULL if the sdp string can't be parsed.
 // |error| can be NULL if doesn't care about the failure reason.
 IceCandidateInterface* CreateIceCandidate(const std::string& sdp_mid,
                                           int sdp_mline_index,
                                           const std::string& sdp,
                                           SdpParseError* error);
 
 // This class represents a collection of candidates for a specific m-line.
 // This class is used in SessionDescriptionInterface to represent all known
@@ skipping 23 matching lines @@
   // Get the session id and session version, which are defined based on
   // RFC 4566 for the SDP o= line.
   virtual std::string session_id() const = 0;
   virtual std::string session_version() const = 0;
   virtual std::string type() const = 0;
   // Adds the specified candidate to the description.
   // Ownership is not transferred.
   // Returns false if the session description does not have a media section that
   // corresponds to the |candidate| label.
   virtual bool AddCandidate(const IceCandidateInterface* candidate) = 0;
+  // Removes the candidates that have a matching address and protocol.
+  // Returns the number of candidates removed.
+  virtual int RemoveCandidates(
+      const std::vector<IceCandidateInterfaceRefPtr>& candidates) = 0;

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

Why do we have to use a scoped_refptr here?  Why can't we just use a const
std::vector<IceCandidateInterface>&?  It seems like all the implementations of
this just read the values, so I don't see why we need to do refcounting.

And even if we worried about ownership, we could just copy the candidates and
pass ownership of the copy, since they are cheap to copy.

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

We cannot do vector<IceCandidateInterface>. If so, we have to provide vector of
IceCandidateInterface, not vector of its subclasses. 
By the way, peerconnection_interface does use vector of Ref-counted pointers a
few times. 

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

If this is just because we want an IceCandidateInteface so that we can have a
MockIceCandidate, then I think we should look into removing
IceCandidateInterface and just make it IceCandidate and handle mocking some
other way.  Introducing ref counting into a simple struct that's passed around
seems like too much complexity for too little gain (the MockIceCandidate).

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

It is going to be a lot more complicated to try to remove IceCandidateInterface
because it is used by Chrome and by chromoting. All the RefCount object adds is
just a counter. We could create a vector of IceCandidate objects and create
another vector of pointers pointing to the objects in the object vector,
although that would appear not as safe as the ref-counted pointers.

+
   // Returns the number of m- lines in the session description.
   virtual size_t number_of_mediasections() const = 0;
   // Returns a collection of all candidates that belong to a certain m-line
   virtual const IceCandidateCollection* candidates(
       size_t mediasection_index) const = 0;
   // Serializes the description to SDP.
   virtual bool ToString(std::string* out) const = 0;
 };
 
 // Creates a SessionDescriptionInterface based on SDP string and the type.
@@ skipping 21 matching lines @@
   virtual void OnSuccess() = 0;
   virtual void OnFailure(const std::string& error) = 0;
 
  protected:
   ~SetSessionDescriptionObserver() {}
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_JSEP_H_