Remove some uses of stl_util's STLDeleteContainerPointers.

base/memory/scoped_vector.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_MEMORY_SCOPED_VECTOR_H_
 #define BASE_MEMORY_SCOPED_VECTOR_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 70 matching lines @@
   void swap(ScopedVector<T>& other) { v_.swap(other.v_); }
   void release(std::vector<T*>* out) {
     out->swap(v_);
     v_.clear();
   }
 
   void reserve(size_t capacity) { v_.reserve(capacity); }
 
   // Resize, deleting elements in the disappearing range if we are shrinking.
   void resize(size_t new_size) {
-    if (v_.size() > new_size)
-      base::STLDeleteContainerPointers(v_.begin() + new_size, v_.end());
+    if (v_.size() > new_size) {
+      auto it = v_.begin() + new_size;
+      auto end = v_.end();
+      while (it != end) {
+        delete *it;
+        ++it;

[Nico, 2016/09/08 17:32:00]

how is this better than the old thing?

[Avi (use Gerrit), 2016/09/13 14:36:13]

I'm trying to remove STLDeleteContainerPointers, and my patch was getting big,
so I'm trying to commit some of it. It's better in that it doesn't use that
function.

Eventually we want to kill ScopedVector too, but until then, I want to remove
uses of the STL functions as I go.

+      }
+    }
     v_.resize(new_size);
   }
 
   template<typename InputIterator>
   void assign(InputIterator begin, InputIterator end) {
     v_.assign(begin, end);
   }
 
   void clear() { base::STLDeleteElements(&v_); }
 
@@ skipping 14 matching lines @@
   void insert(iterator position, InputIterator first, InputIterator last) {
     v_.insert(position, first, last);
   }
 
   iterator erase(iterator position) {
     delete *position;
     return v_.erase(position);
   }
 
   iterator erase(iterator first, iterator last) {
-    base::STLDeleteContainerPointers(first, last);
+    auto it = first;
+    while (it != last) {
+      delete *it;
+      ++it;
+    }
     return v_.erase(first, last);
   }
 
   // Like |erase()|, but doesn't delete the element at |position|.
   iterator weak_erase(iterator position) {
     return v_.erase(position);
   }
 
   // Like |erase()|, but doesn't delete the elements in [first, last).
   iterator weak_erase(iterator first, iterator last) {
     return v_.erase(first, last);
   }
 
  private:
   std::vector<T*> v_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedVector);
 };
 
 #endif  // BASE_MEMORY_SCOPED_VECTOR_H_