Remove the free_ member of scoped_ptr_malloc.

base/memory/scoped_ptr.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.
 
 // Scopers help you manage ownership of a pointer, helping you easily manage the
 // a pointer within a scope, and automatically destroying the pointer at the
 // end of a scope.  There are two main classes you will use, which correspond
 // to the operators new/delete and new[]/delete[].
 //
 // Example usage (scoped_ptr):
@@ skipping 267 matching lines @@
 
   // Constructor.  Defaults to initializing with NULL.
   // There is no way to create an uninitialized scoped_ptr.
   // The input parameter must be allocated with an allocator that matches the
   // Free functor.  For the default Free functor, this is malloc, calloc, or
   // realloc.
   explicit scoped_ptr_malloc(C* p = NULL): ptr_(p) {}
 
   // Destructor.  If there is a C object, call the Free functor.
   ~scoped_ptr_malloc() {
-    free_(ptr_);
+    reset();
   }
 
   // Reset.  Calls the Free functor on the current owned object, if any.
   // Then takes ownership of a new object, if given.
   // this->reset(this->get()) works.
   void reset(C* p = NULL) {
     if (ptr_ != p) {
-      free_(ptr_);
+      FreeProc free_proc;

[darin (slow to review), 2011/08/29 23:32:10]

unrelated to this change, but since free_proc(ptr_) could have side-effects,
should we consider updating ptr_ before calling free_proc?

  C* doomed = ptr_;
  ptr_ = p;
  FreeProc free_proc;
  free_proc(doomed);

+      free_proc(ptr_);
       ptr_ = p;
     }
   }
 
   // Get the current object.
   // operator* and operator-> will cause an assert() failure if there is
   // no current object.
   C& operator*() const {
     assert(ptr_ != NULL);
     return *ptr_;
@@ skipping 41 matching lines @@
 
  private:
   C* ptr_;
 
   // no reason to use these: each scoped_ptr_malloc should have its own object
   template <class C2, class GP>
   bool operator==(scoped_ptr_malloc<C2, GP> const& p) const;
   template <class C2, class GP>
   bool operator!=(scoped_ptr_malloc<C2, GP> const& p) const;
 
-  static FreeProc const free_;
-
   // Disallow evil constructors
   scoped_ptr_malloc(const scoped_ptr_malloc&);
   void operator=(const scoped_ptr_malloc&);
 };
 
-template<class C, class FP>
-FP const scoped_ptr_malloc<C, FP>::free_ = FP();
-
 template<class C, class FP> inline
 void swap(scoped_ptr_malloc<C, FP>& a, scoped_ptr_malloc<C, FP>& b) {
   a.swap(b);
 }
 
 template<class C, class FP> inline
 bool operator==(C* p, const scoped_ptr_malloc<C, FP>& b) {
   return p == b.get();
 }
 
 template<class C, class FP> inline
 bool operator!=(C* p, const scoped_ptr_malloc<C, FP>& b) {
   return p != b.get();
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_