Remove stl_util use from domain_reliability.

components/domain_reliability/context.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/domain_reliability/context.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 79 matching lines @@
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "DomainReliability.ReportedBeaconError_HasServerIP",
         -beacon->chrome_error);
   }
   // TODO(juliatuttle): Histogram HTTP response code?
 
   // Allow beacons about reports, but don't schedule an upload for more than
   // one layer of recursion, to avoid infinite report loops.
   if (beacon->upload_depth <= kMaxUploadDepthToSchedule)
     scheduler_.OnBeaconAdded();
-  beacons_.push_back(beacon.release());
+  beacons_.push_back(std::move(beacon));
   bool should_evict = beacons_.size() > kMaxQueuedBeacons;
   if (should_evict)
     RemoveOldestBeacon();
 
   LogOnBeaconDidEvictHistogram(should_evict);
 }
 
 void DomainReliabilityContext::ClearBeacons() {
-  base::STLDeleteElements(&beacons_);
   beacons_.clear();
   uploading_beacons_size_ = 0;
 }
 
 std::unique_ptr<Value> DomainReliabilityContext::GetWebUIData() const {
   DictionaryValue* context_value = new DictionaryValue();
 
   context_value->SetString("origin", config().origin.spec());
   context_value->SetInteger("beacon_count", static_cast<int>(beacons_.size()));
   context_value->SetInteger("uploading_beacon_count",
       static_cast<int>(uploading_beacons_size_));
   context_value->Set("scheduler", scheduler_.GetWebUIData());
 
   return std::unique_ptr<Value>(context_value);
 }
 
 void DomainReliabilityContext::GetQueuedBeaconsForTesting(
     std::vector<const DomainReliabilityBeacon*>* beacons_out) const {
   DCHECK(this);
   DCHECK(beacons_out);
-  beacons_out->assign(beacons_.begin(), beacons_.end());
+  beacons_out->clear();
+  for (const auto& beacon : beacons_)
+    beacons_out->push_back(beacon.get());
 }
 
 void DomainReliabilityContext::ScheduleUpload(
     base::TimeDelta min_delay,
     base::TimeDelta max_delay) {
   dispatcher_->ScheduleTask(
       base::Bind(
           &DomainReliabilityContext::StartUpload,
           weak_factory_.GetWeakPtr()),
       min_delay,
@@ skipping 56 matching lines @@
   upload_time_ = base::TimeTicks();
 }
 
 std::unique_ptr<const Value> DomainReliabilityContext::CreateReport(
     base::TimeTicks upload_time,
     const GURL& collector_url,
     int* max_upload_depth_out) const {
   int max_upload_depth = 0;
 
   std::unique_ptr<ListValue> beacons_value(new ListValue());
-  for (const auto* beacon : beacons_) {
+  for (const auto& beacon : beacons_) {
     beacons_value->Append(beacon->ToValue(upload_time,
                                           *last_network_change_time_,
                                           collector_url,
                                           config().path_prefixes));
     if (beacon->upload_depth > max_upload_depth)
       max_upload_depth = beacon->upload_depth;
   }
 
   std::unique_ptr<DictionaryValue> report_value(new DictionaryValue());
   report_value->SetString("reporter", upload_reporter_string_);
   report_value->Set("entries", beacons_value.release());
 
   *max_upload_depth_out = max_upload_depth;
   return std::move(report_value);
 }
 
 void DomainReliabilityContext::MarkUpload() {
   DCHECK_EQ(0u, uploading_beacons_size_);
   uploading_beacons_size_ = beacons_.size();
   DCHECK_NE(0u, uploading_beacons_size_);
 }
 
 void DomainReliabilityContext::CommitUpload() {
   auto begin = beacons_.begin();
   auto end = begin + uploading_beacons_size_;
-  base::STLDeleteContainerPointers(begin, end);
   beacons_.erase(begin, end);
   DCHECK_NE(0u, uploading_beacons_size_);
   uploading_beacons_size_ = 0;
 }
 
 void DomainReliabilityContext::RollbackUpload() {
   DCHECK_NE(0u, uploading_beacons_size_);
   uploading_beacons_size_ = 0;
 }
 
 void DomainReliabilityContext::RemoveOldestBeacon() {
   DCHECK(!beacons_.empty());
 
   VLOG(1) << "Beacon queue for " << config().origin << " full; "
           << "removing oldest beacon";
 
-  delete beacons_.front();
   beacons_.pop_front();
 
   // If that just removed a beacon counted in uploading_beacons_size_, decrement
   // that.
   if (uploading_beacons_size_ > 0)
     --uploading_beacons_size_;
 }
 
 }  // namespace domain_reliability