Extend scoped_ptr to be closer to unique_ptr. Support custom deleters, and deleting arrays.

base/memory/scoped_ptr_unittest.cc

 // 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.
 
+#include "base/memory/scoped_ptr.h"
+
 #include "base/basictypes.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Used to test depth subtyping.
 class ConDecLoggerParent {
  public:
   virtual ~ConDecLoggerParent() {}
 
   virtual void SetPtr(int* ptr) = 0;
@@ skipping 10 matching lines @@
   virtual void SetPtr(int* ptr) OVERRIDE { ptr_ = ptr; ++*ptr_; }
 
   virtual int SomeMeth(int x) const OVERRIDE { return x; }
 
  private:
   int* ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(ConDecLogger);
 };
 
+struct CountingDeleter {
+  explicit CountingDeleter(int* count) : count_(count) {}
+  inline void operator()(double* ptr) const {
+    (*count_)++;
+  }
+  int* count_;
+};
+
+// Used to test assignment of convertible deleters.
+struct CountingDeleterChild : public CountingDeleter {
+  explicit CountingDeleterChild(int* count) : CountingDeleter(count) {}
+};
+
+class OverloadedNewAndDelete {
+ public:
+  void* operator new(size_t size) {
+    g_new_count++;
+    return malloc(size);
+  }
+
+  void operator delete(void* ptr) {
+    g_delete_count++;
+    free(ptr);
+  }
+
+  static void ResetCounters() {
+    g_new_count = 0;
+    g_delete_count = 0;
+  }
+
+  static int new_count() { return g_new_count; }
+  static int delete_count() { return g_delete_count; }
+
+ private:
+  static int g_new_count;
+  static int g_delete_count;
+};
+
+int OverloadedNewAndDelete::g_new_count = 0;
+int OverloadedNewAndDelete::g_delete_count = 0;
+
 scoped_ptr<ConDecLogger> PassThru(scoped_ptr<ConDecLogger> logger) {
   return logger.Pass();
 }
 
 void GrabAndDrop(scoped_ptr<ConDecLogger> logger) {
 }
 
 // Do not delete this function!  It's existence is to test that you can
 // return a temporarily constructed version of the scoper.
 scoped_ptr<ConDecLogger> TestReturnOfType(int* constructed) {
   return scoped_ptr<ConDecLogger>(new ConDecLogger(constructed));
 }
 
 scoped_ptr<ConDecLoggerParent> UpcastUsingPassAs(
     scoped_ptr<ConDecLogger> object) {
   return object.PassAs<ConDecLoggerParent>();
 }
 
 }  // namespace
 
 TEST(ScopedPtrTest, ScopedPtr) {
   int constructed = 0;
 
+  // Ensure size of scoped_ptr<> doesn't increase unexpectedly.
+  COMPILE_ASSERT(sizeof(int*) == sizeof(scoped_ptr<int>),
+                 scoped_ptr_larger_than_raw_ptr);

[gromer, 2012/12/14 16:57:26]

Absurd nitpick: "larger than" doesn't match the actual assertion; maybe the
comparison should be >=?

[awong, 2012/12/15 00:19:08]

Done

+
   {
     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper.get());
 
     EXPECT_EQ(10, scoper->SomeMeth(10));
     EXPECT_EQ(10, scoper.get()->SomeMeth(10));
     EXPECT_EQ(10, (*scoper).SomeMeth(10));
   }
   EXPECT_EQ(0, constructed);
@@ skipping 108 matching lines @@
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper.get());
 
     scoped_ptr<const ConDecLogger> scoper_const;
     scoper_const = scoper.Pass();
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper_const.get());
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
+
+  // Test assignment to a scoped_ptr deleter of parent type.
+  {
+    // Custom deleters never touch these value.
+    double dummy_value, dummy_value2;
+    int deletes = 0;
+    int alternate_deletes = 0;
+    scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
+                                               CountingDeleter(&deletes));
+    scoped_ptr<double, CountingDeleterChild> scoper_child(
+        &dummy_value2, CountingDeleterChild(&alternate_deletes));
+
+    EXPECT_TRUE(scoper);
+    EXPECT_TRUE(scoper_child);
+    EXPECT_EQ(0, deletes);
+    EXPECT_EQ(0, alternate_deletes);
+
+    // Test this compiles and correctly overwrites the deleter state.
+    scoper = scoper_child.Pass();
+    EXPECT_TRUE(scoper);
+    EXPECT_FALSE(scoper_child);
+    EXPECT_EQ(1, deletes);
+    EXPECT_EQ(0, alternate_deletes);
+
+    scoper.reset();
+    EXPECT_FALSE(scoper);
+    EXPECT_FALSE(scoper_child);
+    EXPECT_EQ(1, deletes);
+    EXPECT_EQ(1, alternate_deletes);
+
+    scoper_child.reset(&dummy_value);
+    EXPECT_TRUE(scoper_child);
+    EXPECT_EQ(1, deletes);
+    EXPECT_EQ(1, alternate_deletes);
+    scoped_ptr<double, CountingDeleter> scoper_construct(scoper_child.Pass());
+    EXPECT_TRUE(scoper_construct);
+    EXPECT_FALSE(scoper_child);
+    EXPECT_EQ(1, deletes);
+    EXPECT_EQ(1, alternate_deletes);
+
+    scoper_construct.reset();
+    EXPECT_EQ(1, deletes);
+    EXPECT_EQ(2, alternate_deletes);
+  }
+}
+
+TEST(ScopedPtrTest, ScopedPtrWithArray) {
+  static const int kNumLoggers = 12;
+
+  int constructed = 0;
+
+  {
+    scoped_ptr<ConDecLogger[]> scoper(new ConDecLogger[kNumLoggers]);
+    EXPECT_TRUE(scoper);
+    EXPECT_EQ(&scoper[0], scoper.get());
+    for (int i = 0; i < kNumLoggers; ++i) {
+      scoper[i].SetPtr(&constructed);
+    }
+    EXPECT_EQ(12, constructed);
+
+    EXPECT_EQ(10, scoper.get()->SomeMeth(10));
+    EXPECT_EQ(10, scoper[2].SomeMeth(10));
+  }
+  EXPECT_EQ(0, constructed);
+
+  // Test reset() and release()
+  {
+    scoped_ptr<ConDecLogger[]> scoper;
+    EXPECT_FALSE(scoper.get());
+    EXPECT_FALSE(scoper.release());
+    EXPECT_FALSE(scoper.get());
+    scoper.reset();
+    EXPECT_FALSE(scoper.get());
+
+    scoper.reset(new ConDecLogger[kNumLoggers]);
+    for (int i = 0; i < kNumLoggers; ++i) {
+      scoper[i].SetPtr(&constructed);
+    }
+    EXPECT_EQ(12, constructed);
+    scoper.reset();
+    EXPECT_EQ(0, constructed);
+
+    scoper.reset(new ConDecLogger[kNumLoggers]);
+    for (int i = 0; i < kNumLoggers; ++i) {
+      scoper[i].SetPtr(&constructed);
+    }
+    EXPECT_EQ(12, constructed);
+    ConDecLogger* ptr = scoper.release();
+    EXPECT_EQ(12, constructed);
+    delete[] ptr;
+    EXPECT_EQ(0, constructed);
+  }
+  EXPECT_EQ(0, constructed);
+
+  // Test swap(), ==, !=, and type-safe Boolean.
+  {
+    scoped_ptr<ConDecLogger[]> scoper1;
+    scoped_ptr<ConDecLogger[]> scoper2;
+    EXPECT_TRUE(scoper1 == scoper2.get());
+    EXPECT_FALSE(scoper1 != scoper2.get());
+
+    ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
+    for (int i = 0; i < kNumLoggers; ++i) {
+      loggers[i].SetPtr(&constructed);
+    }
+    scoper1.reset(loggers);
+    EXPECT_TRUE(scoper1);
+    EXPECT_EQ(loggers, scoper1.get());
+    EXPECT_FALSE(scoper2);
+    EXPECT_FALSE(scoper2.get());
+    EXPECT_FALSE(scoper1 == scoper2.get());
+    EXPECT_TRUE(scoper1 != scoper2.get());
+
+    scoper2.swap(scoper1);
+    EXPECT_EQ(loggers, scoper2.get());
+    EXPECT_FALSE(scoper1.get());
+    EXPECT_FALSE(scoper1 == scoper2.get());
+    EXPECT_TRUE(scoper1 != scoper2.get());
+  }
+  EXPECT_EQ(0, constructed);
+
+  {
+    ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
+    scoped_ptr<ConDecLogger[]> scoper(loggers);
+    EXPECT_TRUE(scoper);
+    for (int i = 0; i < kNumLoggers; ++i) {
+      scoper[i].SetPtr(&constructed);
+    }
+    EXPECT_EQ(kNumLoggers, constructed);
+
+    // Test Pass() with constructor;
+    scoped_ptr<ConDecLogger[]> scoper2(scoper.Pass());
+    EXPECT_EQ(kNumLoggers, constructed);
+
+    // Test Pass() with assignment;
+    scoped_ptr<ConDecLogger[]> scoper3;
+    scoper3 = scoper2.Pass();
+    EXPECT_EQ(kNumLoggers, constructed);
+    EXPECT_FALSE(scoper);
+    EXPECT_FALSE(scoper2);
+    EXPECT_TRUE(scoper3);
+  }
+  EXPECT_EQ(0, constructed);
 }
 
 TEST(ScopedPtrTest, ScopedArray) {
   static const int kNumLoggers = 12;
 
   int constructed = 0;
 
   {
     scoped_array<ConDecLogger> scoper(new ConDecLogger[kNumLoggers]);
     EXPECT_TRUE(scoper.get());
@@ skipping 30 matching lines @@
       scoper[i].SetPtr(&constructed);
     }
     EXPECT_EQ(12, constructed);
     ConDecLogger* ptr = scoper.release();
     EXPECT_EQ(12, constructed);
     delete[] ptr;
     EXPECT_EQ(0, constructed);
   }
   EXPECT_EQ(0, constructed);
 
-  // Test swap(), == and !=
+  // Test swap(), ==, !=, and type-safe Boolean.
   {
     scoped_array<ConDecLogger> scoper1;
     scoped_array<ConDecLogger> scoper2;
     EXPECT_TRUE(scoper1 == scoper2.get());
     EXPECT_FALSE(scoper1 != scoper2.get());
 
     ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
     for (int i = 0; i < kNumLoggers; ++i) {
       loggers[i].SetPtr(&constructed);
     }
     scoper1.reset(loggers);
+    EXPECT_TRUE(scoper1);
     EXPECT_EQ(loggers, scoper1.get());
+    EXPECT_FALSE(scoper2);
     EXPECT_FALSE(scoper2.get());
     EXPECT_FALSE(scoper1 == scoper2.get());
     EXPECT_TRUE(scoper1 != scoper2.get());
 
     scoper2.swap(scoper1);
     EXPECT_EQ(loggers, scoper2.get());
     EXPECT_FALSE(scoper1.get());
     EXPECT_FALSE(scoper1 == scoper2.get());
     EXPECT_TRUE(scoper1 != scoper2.get());
   }
@@ skipping 88 matching lines @@
 
     scoped_ptr<ConDecLoggerParent> scoper_parent;
     scoper_parent = UpcastUsingPassAs(scoper.Pass());
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper_parent.get());
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
 }
 
+TEST(ScopedPtrTest, CustomDeleter) {
+  double dummy_value;  // Custom deleter never touches this value.
+  int deletes = 0;
+  int alternate_deletes = 0;
+
+  // Normal delete support.
+  {
+    deletes = 0;
+    scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
+                                               CountingDeleter(&deletes));
+    EXPECT_EQ(0, deletes);
+    EXPECT_TRUE(scoper.get());
+  }
+  EXPECT_EQ(1, deletes);
+
+  // Test reset() and release().
+  deletes = 0;
+  {
+    scoped_ptr<double, CountingDeleter> scoper(NULL,
+                                               CountingDeleter(&deletes));
+    EXPECT_FALSE(scoper.get());
+    EXPECT_FALSE(scoper.release());
+    EXPECT_FALSE(scoper.get());
+    scoper.reset();
+    EXPECT_FALSE(scoper.get());
+    EXPECT_EQ(0, deletes);
+
+    scoper.reset(&dummy_value);
+    scoper.reset();
+    EXPECT_EQ(1, deletes);
+
+    scoper.reset(&dummy_value);
+    EXPECT_EQ(&dummy_value, scoper.release());
+  }
+  EXPECT_EQ(1, deletes);
+
+  // Test get_deleter().
+  deletes = 0;
+  alternate_deletes = 0;
+  {
+    scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
+                                               CountingDeleter(&deletes));
+    // Call deleter manually.
+    EXPECT_EQ(0, deletes);
+    scoper.get_deleter()(&dummy_value);
+    EXPECT_EQ(1, deletes);
+
+    // Deleter is still there after reset.
+    scoper.reset();
+    EXPECT_EQ(2, deletes);
+    scoper.get_deleter()(&dummy_value);
+    EXPECT_EQ(3, deletes);
+
+    // Deleter can be assigned into (matches C++11 unique_ptr<> spec).
+    scoper.get_deleter() = CountingDeleter(&alternate_deletes);
+    scoper.reset(&dummy_value);
+    EXPECT_EQ(0, alternate_deletes);
+
+  }
+  EXPECT_EQ(3, deletes);
+  EXPECT_EQ(1, alternate_deletes);
+
+  // Test operator= deleter support.
+  deletes = 0;
+  alternate_deletes = 0;
+  {
+    double dummy_value2;
+    scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
+                                               CountingDeleter(&deletes));
+    scoped_ptr<double, CountingDeleter> scoper2(
+        &dummy_value2,
+        CountingDeleter(&alternate_deletes));
+    EXPECT_EQ(0, deletes);
+    EXPECT_EQ(0, alternate_deletes);
+
+    // Pass the second deleter through a constructor and an operator=. Then
+    // reinitialize the empty scopers to ensure that each one is deleting
+    // properly.
+    scoped_ptr<double, CountingDeleter> scoper3(scoper2.Pass());
+    scoper = scoper3.Pass();
+    EXPECT_EQ(1, deletes);
+
+    scoper2.reset(&dummy_value2);
+    scoper3.reset(&dummy_value2);
+    EXPECT_EQ(0, alternate_deletes);
+
+  }
+  EXPECT_EQ(1, deletes);
+  EXPECT_EQ(3, alternate_deletes);
+
+  // Test swap(), ==, !=, and type-safe Boolean.
+  {
+    scoped_ptr<double, CountingDeleter> scoper1(NULL,
+                                                CountingDeleter(&deletes));
+    scoped_ptr<double, CountingDeleter> scoper2(NULL,
+                                                CountingDeleter(&deletes));
+    EXPECT_TRUE(scoper1 == scoper2.get());
+    EXPECT_FALSE(scoper1 != scoper2.get());
+
+    scoper1.reset(&dummy_value);
+    EXPECT_TRUE(scoper1);
+    EXPECT_EQ(&dummy_value, scoper1.get());
+    EXPECT_FALSE(scoper2);
+    EXPECT_FALSE(scoper2.get());
+    EXPECT_FALSE(scoper1 == scoper2.get());
+    EXPECT_TRUE(scoper1 != scoper2.get());
+
+    scoper2.swap(scoper1);
+    EXPECT_EQ(&dummy_value, scoper2.get());
+    EXPECT_FALSE(scoper1.get());
+    EXPECT_FALSE(scoper1 == scoper2.get());
+    EXPECT_TRUE(scoper1 != scoper2.get());
+  }
+}
+
+// Sanity check test for overloaded new and delete operators. Does not do full
+// coverage of reset/release/Pass() operations as that is redundant with the
+// above.
+TEST(ScopedPtrTest, OverloadedNewAndDelete) {
+  {
+    OverloadedNewAndDelete::ResetCounters();
+    scoped_ptr<OverloadedNewAndDelete> scoper(new OverloadedNewAndDelete());
+    EXPECT_TRUE(scoper.get());
+
+    scoped_ptr<OverloadedNewAndDelete> scoper2(scoper.Pass());
+  }
+  EXPECT_EQ(1, OverloadedNewAndDelete::delete_count());
+  EXPECT_EQ(1, OverloadedNewAndDelete::new_count());
+}
+
 // TODO scoped_ptr_malloc