Remove stl_util's STLDeleteContainerPointers.

base/stl_util.h

 // Copyright (c) 2011 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.
 
 // Derived from google3/util/gtl/stl_util.h
 
 #ifndef BASE_STL_UTIL_H_
 #define BASE_STL_UTIL_H_
 
 #include <algorithm>
@@ skipping 11 matching lines @@
 // This function uses swap/destructor to ensure the internal memory is freed.
 template<class T>
 void STLClearObject(T* obj) {
   T tmp;
   tmp.swap(*obj);
   // Sometimes "T tmp" allocates objects with memory (arena implementation?).
   // Hence using additional reserve(0) even if it doesn't always work.
   obj->reserve(0);
 }
 
-// For a range within a container of pointers, calls delete (non-array version)
-// on these pointers.
-// NOTE: for these three functions, we could just implement a DeleteObject
-// functor and then call for_each() on the range and functor, but this
-// requires us to pull in all of algorithm.h, which seems expensive.
-// For hash_[multi]set, it is important that this deletes behind the iterator
-// because the hash_set may call the hash function on the iterator when it is
-// advanced, which could result in the hash function trying to deference a
-// stale pointer.
-template <class ForwardIterator>
-void STLDeleteContainerPointers(ForwardIterator begin, ForwardIterator end) {
-  while (begin != end) {
-    ForwardIterator temp = begin;
-    ++begin;
-    delete *temp;
-  }
-}
-
 // Counts the number of instances of val in a container.
 template <typename Container, typename T>
 typename std::iterator_traits<
     typename Container::const_iterator>::difference_type
 STLCount(const Container& container, const T& val) {
   return std::count(container.begin(), container.end(), val);
 }
 
 // Return a mutable char* pointing to a string's internal buffer,
 // which may not be null-terminated. Writing through this pointer will
@@ skipping 18 matching lines @@
 // STLDeleteElements() deletes all the elements in an STL container and clears
 // the container.  This function is suitable for use with a vector, set,
 // hash_set, or any other STL container which defines sensible begin(), end(),
 // and clear() methods.
 //
 // If container is NULL, this function is a no-op.
 template <class T>
 void STLDeleteElements(T* container) {
   if (!container)
     return;
-  STLDeleteContainerPointers(container->begin(), container->end());
+
+  auto it = container->begin();
+  while (it != container->end()) {

[Mark Mentovai, 2016/10/31 19:52:02]

for would be more concise by one line.

[Avi (use Gerrit), 2016/10/31 21:17:40]

Is the issue of not being able to advance the iterator noted in the comment on
STLDeleteContainerPointers not an issue? I kept the same basic structure because
I wasn't entirely sure and because I'm getting rid of this soon, also.

+    auto temp = it;
+    ++it;
+    delete *temp;
+  }
+
   container->clear();
 }
 
 // Given an STL container consisting of (key, value) pairs, STLDeleteValues
 // deletes all the "value" components and clears the container.  Does nothing
 // in the case it's given a NULL pointer.
 template <class T>
 void STLDeleteValues(T* container) {
   if (!container)
     return;
@@ skipping 76 matching lines @@
 bool STLIncludes(const Arg1& a1, const Arg2& a2) {
   DCHECK(STLIsSorted(a1));
   DCHECK(STLIsSorted(a2));
   return std::includes(a1.begin(), a1.end(),
                        a2.begin(), a2.end());
 }
 
 }  // namespace base
 
 #endif  // BASE_STL_UTIL_H_