Small stl_util tidy up

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_
 #pragma once
 
-#include <assert.h>
-#include <string.h>  // for memcpy
-
 #include <string>
 #include <vector>
 
 // Clear internal memory of an STL object.
 // STL clear()/reserve(0) does not always free internal memory allocated
 // 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?).
@@ skipping 48 matching lines @@
                                          ForwardIterator end) {
   while (begin != end) {
     ForwardIterator temp = begin;
     ++begin;
     delete temp->first;
   }
 }
 
 // STLDeleteContainerPairSecondPointers()
 //  For a range within a container of pairs, calls delete
+// NOTE: Like STLDeleteContainerPointers, deleting behind the iterator.
+// Deleting the value does not always invalidate the iterator, but it may
+// do so if the key is a pointer into the value object.
 //  (non-array version) on the SECOND item in the pairs.
 template <class ForwardIterator>
 void STLDeleteContainerPairSecondPointers(ForwardIterator begin,
                                           ForwardIterator end) {
   while (begin != end) {
-    delete begin->second;
+    ForwardIterator temp = begin;
     ++begin;
+    delete temp->second;
   }
 }
 
 // To treat a possibly-empty vector as an array, use these functions.
 // If you know the array will never be empty, you can use &*v.begin()
 // directly, but that is undefined behaviour if v is empty.
 
 template<typename T>
 inline T* vector_as_array(std::vector<T>* v) {
-# ifdef NDEBUG
-  return &*v->begin();
-# else
   return v->empty() ? NULL : &*v->begin();
-# endif
 }
 
 template<typename T>
 inline const T* vector_as_array(const std::vector<T>* v) {
-# ifdef NDEBUG
-  return &*v->begin();
-# else
   return v->empty() ? NULL : &*v->begin();
-# endif
 }
 
 // Return a mutable char* pointing to a string's internal buffer,
 // which may not be null-terminated. Writing through this pointer will
 // modify the string.
 //
 // string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
 // next call to a string method that invalidates iterators.
 //
 // As of 2006-04, there is no standard-blessed way of getting a
@@ skipping 74 matching lines @@
 };
 
 // Test to see if a set, map, hash_set or hash_map contains a particular key.
 // Returns true if the key is in the collection.
 template <typename Collection, typename Key>
 bool ContainsKey(const Collection& collection, const Key& key) {
   return collection.find(key) != collection.end();
 }
 
 #endif  // BASE_STL_UTIL_H_