diff --git a/api/BUILD.gn b/api/BUILD.gn
index ca2b5cb..5c681bc 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -183,6 +183,7 @@
     "video:video_frame",
     "video:video_rtp_headers",
     "//third_party/abseil-cpp/absl/algorithm:container",
+    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
 
diff --git a/api/jsep_ice_candidate.cc b/api/jsep_ice_candidate.cc
index 3328386..e18e6e2 100644
--- a/api/jsep_ice_candidate.cc
+++ b/api/jsep_ice_candidate.cc
@@ -10,9 +10,11 @@
 
 #include "api/jsep_ice_candidate.h"
 
+#include <memory>
 #include <utility>
 
 #include "absl/algorithm/container.h"
+#include "absl/memory/memory.h"
 
 namespace webrtc {
 
@@ -42,41 +44,29 @@
 }
 
 void JsepCandidateCollection::add(JsepIceCandidate* candidate) {
-  candidates_.push_back(candidate);
+  candidates_.push_back(absl::WrapUnique(candidate));
 }
 
 const IceCandidateInterface* JsepCandidateCollection::at(size_t index) const {
-  return candidates_[index];
-}
-
-JsepCandidateCollection::~JsepCandidateCollection() {
-  for (std::vector<JsepIceCandidate*>::iterator it = candidates_.begin();
-       it != candidates_.end(); ++it) {
-    delete *it;
-  }
+  return candidates_[index].get();
 }
 
 bool JsepCandidateCollection::HasCandidate(
     const IceCandidateInterface* candidate) const {
-  bool ret = false;
-  for (std::vector<JsepIceCandidate*>::const_iterator it = candidates_.begin();
-       it != candidates_.end(); ++it) {
-    if ((*it)->sdp_mid() == candidate->sdp_mid() &&
-        (*it)->sdp_mline_index() == candidate->sdp_mline_index() &&
-        (*it)->candidate().IsEquivalent(candidate->candidate())) {
-      ret = true;
-      break;
-    }
-  }
-  return ret;
+  return absl::c_any_of(
+      candidates_, [&](const std::unique_ptr<JsepIceCandidate>& entry) {
+        return entry->sdp_mid() == candidate->sdp_mid() &&
+               entry->sdp_mline_index() == candidate->sdp_mline_index() &&
+               entry->candidate().IsEquivalent(candidate->candidate());
+      });
 }
 
 size_t JsepCandidateCollection::remove(const cricket::Candidate& candidate) {
-  auto iter = absl::c_find_if(candidates_, [&](JsepIceCandidate* c) {
-    return candidate.MatchesForRemoval(c->candidate());
-  });
+  auto iter = absl::c_find_if(
+      candidates_, [&](const std::unique_ptr<JsepIceCandidate>& c) {
+        return candidate.MatchesForRemoval(c->candidate());
+      });
   if (iter != candidates_.end()) {
-    delete *iter;
     candidates_.erase(iter);
     return 1;
   }
diff --git a/api/jsep_ice_candidate.h b/api/jsep_ice_candidate.h
index 651aa7c..4ee84cf 100644
--- a/api/jsep_ice_candidate.h
+++ b/api/jsep_ice_candidate.h
@@ -16,6 +16,7 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -63,7 +64,6 @@
   // Move constructor is defined so that a vector of JsepCandidateCollections
   // can be resized.
   JsepCandidateCollection(JsepCandidateCollection&& o);
-  ~JsepCandidateCollection() override;
   size_t count() const override;
   bool HasCandidate(const IceCandidateInterface* candidate) const override;
   // Adds and takes ownership of the JsepIceCandidate.
@@ -77,7 +77,7 @@
   size_t remove(const cricket::Candidate& candidate);
 
  private:
-  std::vector<JsepIceCandidate*> candidates_;
+  std::vector<std::unique_ptr<JsepIceCandidate>> candidates_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(JsepCandidateCollection);
 };
