Refactor vtkDebugLeaks construction.

vtkDebugLeaks registers instance by class name, which worked well for
many years. However, now that we have more templated code, this is
becoming difficult. For instance, "template <typename T> vtkBuffer<T>"
would be identified as "vtkBuffer<T>" when registering with
vtkDebugLeaks, but deregistered with the compiler dependent
typeid(vtkBuffer<T>).name() string returned from GetClassName().

This patch moves vtkDebugLeaks registrations to the method
vtkObjectBase::InitializeObjectBase(), which must be called after the
vtkObjectBase is instantiated. This ensures that objects are
registered using the same string as when they are destroyed. In
general, a call to "new vtkSomeClass" must be followed by a call to
InitializeObjectBase on the new instance. The common ::New()
implementation macros in vtkObjectFactory will ensure that
registration happens correctly.

Two notable exceptions are vtkCommand and vtkInformationKey
subclasses. These do not require any specific handling for
vtkDebugLeaks registration.

See discussion at:

https://vtk.1045678.n5.nabble.com/Proposal-Simplify-vtkDebugLeaks-registration-td5740222.html

Common/Core/Testing/Cxx/TestDataArrayIterators.cxx

@@ -33,7 +33,7 @@ class MyArray : public vtkTypedDataArray<float>
  vtkFloatArray *Data;
 public:
  vtkTypeMacro(MyArray, vtkTypedDataArray<float>)
- static MyArray *New() { return new MyArray; }
+ static MyArray *New() { VTK_STANDARD_NEW_BODY(MyArray) }
  void Init(vtkFloatArray *array)
  {
  this->Data = array;

Common/Core/Testing/Cxx/TestGarbageCollector.cxx

@@ -24,7 +24,12 @@
 class vtkTestReferenceLoop: public vtkObject
 {
 public:
- static vtkTestReferenceLoop* New() { return new vtkTestReferenceLoop; }
+ static vtkTestReferenceLoop* New()
+ {
+ vtkTestReferenceLoop *ret = new vtkTestReferenceLoop;
+ ret->InitializeObjectBase();
+ return ret;
+ }
  vtkTypeMacro(vtkTestReferenceLoop, vtkObject);
 
  void Register(vtkObjectBase* o) VTK_OVERRIDE { this->RegisterInternal(o, 1); }
@@ -34,17 +39,12 @@ class vtkTestReferenceLoop: public vtkObject
  vtkTestReferenceLoop()
  {
  this->Other = new vtkTestReferenceLoop(this);
-#ifdef VTK_DEBUG_LEAKS
- vtkDebugLeaks::ConstructClass("vtkTestReferenceLoop");
-#endif
+ this->Other->InitializeObjectBase();
  }
  vtkTestReferenceLoop(vtkTestReferenceLoop* other)
  {
  this->Other = other;
  this->Other->Register(this);
-#ifdef VTK_DEBUG_LEAKS
- vtkDebugLeaks::ConstructClass("vtkTestReferenceLoop");
-#endif
  }
  ~vtkTestReferenceLoop() VTK_OVERRIDE
  {

Common/Core/Testing/Cxx/TestObjectFactory.cxx

@@ -33,7 +33,7 @@ class vtkTestPoints : public vtkPoints
  }
 
  vtkTypeMacro(vtkTestPoints,vtkPoints);
- static vtkTestPoints* New() { return new vtkTestPoints; }
+ static vtkTestPoints* New() { VTK_STANDARD_NEW_BODY(vtkTestPoints) }
  vtkTestPoints() { }
 private:
  vtkTestPoints(const vtkTestPoints&);
@@ -50,7 +50,7 @@ class vtkTestPoints2 : public vtkPoints
 
  // Methods from vtkObject
  vtkTypeMacro(vtkTestPoints2,vtkPoints);
- static vtkTestPoints2* New() { return new vtkTestPoints2; }
+ static vtkTestPoints2* New() { VTK_STANDARD_NEW_BODY(vtkTestPoints2) }
  vtkTestPoints2() { }
 private:
  vtkTestPoints2(const vtkTestPoints2&);
@@ -65,7 +65,12 @@ class VTK_EXPORT TestFactory : public vtkObjectFactory
 {
 public:
  TestFactory();
- static TestFactory* New() { return new TestFactory;}
+ static TestFactory* New()
+ {
+ TestFactory *f = new TestFactory;
+ f->InitializeObjectBase();
+ return f;
+ }
  const char* GetVTKSourceVersion() VTK_OVERRIDE { return VTK_SOURCE_VERSION; }
  const char* GetDescription() VTK_OVERRIDE { return "A fine Test Factory"; }
 
@@ -74,11 +79,6 @@ class VTK_EXPORT TestFactory : public vtkObjectFactory
  void operator=(const TestFactory&);
 };
 
-
-
-
-
-
 TestFactory::TestFactory()
 {
  this->RegisterOverride("vtkPoints",
@@ -97,7 +97,8 @@ void TestNewPoints(vtkPoints* v, const char* expectedClassName)
  if(strcmp(v->GetClassName(), expectedClassName) != 0)
  {
  failed = 1;
- cout << "Test Failed" << endl;
+ cout << "Test Failed:\nExpected classname: " << expectedClassName
+ << "\nCreated classname: " << v->GetClassName() << endl;
  }
 }
 

Common/Core/vtkDebugLeaks.h

@@ -13,18 +13,38 @@
 
 =========================================================================*/
 /**
- * @class vtkDebugLeaks
- * @brief identify memory leaks at program termination
+ * @class vtkDebugLeaks
+ * @brief identify memory leaks at program termination
+ * vtkDebugLeaks is used to report memory leaks at the exit of the program. It
+ * uses vtkObjectBase::InitializeObjectBase() (called via vtkObjectFactory
+ * macros) to intercept the construction of all VTK objects. It uses the
+ * UnRegisterInternal method of vtkObjectBase to intercept the destruction of
+ * all objects.
  *
- * vtkDebugLeaks is used to report memory leaks at the exit of the program.
- * It uses the vtkObjectFactory to intercept the construction of all VTK
- * objects. It uses the UnRegister method of vtkObject to intercept the
- * destruction of all objects. A table of object name to number of instances
- * is kept. At the exit of the program if there are still VTK objects around
- * it will print them out. To enable this class add the flag
- * -DVTK_DEBUG_LEAKS to the compile line, and rebuild vtkObject and
- * vtkObjectFactory.
-*/
+ * If not using the vtkObjectFactory macros to implement New(), be sure to call
+ * vtkObjectBase::InitializeObjectBase() explicitly on the constructed
+ * instance. The rule of thumb is that wherever "new [some vtkObjectBase
+ * subclass]" is called, vtkObjectBase::InitializeObjectBase() must be called
+ * as well.
+ *
+ * There are exceptions to this:
+ *
+ * - vtkCommand subclasses traditionally do not fully participate in
+ * vtkDebugLeaks registration, likely because they typically do not use
+ * vtkTypeMacro to configure GetClassName. InitializeObjectBase should not be
+ * called on vtkCommand subclasses, and all such classes will be automatically
+ * registered with vtkDebugLeaks as "vtkCommand or subclass".
+ *
+ * - vtkInformationKey subclasses are not reference counted. They are allocated
+ * statically and registered automatically with a singleton "manager" instance.
+ * The manager ensures that all keys are cleaned up before exiting, and
+ * registration/deregistration with vtkDebugLeaks is bypassed.
+ *
+ * A table of object name to number of instances is kept. At the exit of the
+ * program if there are still VTK objects around it will print them out. To
+ * enable this class add the flag -DVTK_DEBUG_LEAKS to the compile line, and
+ * rebuild vtkObject and vtkObjectFactory.
+ */
 
 #ifndef vtkDebugLeaks_h
 #define vtkDebugLeaks_h

Common/Core/vtkDenseArray.txx

@@ -22,6 +22,8 @@
 #ifndef vtkDenseArray_txx
 #define vtkDenseArray_txx
 
+#include "vtkObjectFactory.h"
+
 ///////////////////////////////////////////////////////////////////////////////
 // vtkDenseArray::MemoryBlock
 
@@ -72,12 +74,11 @@ T* vtkDenseArray<T>::StaticMemoryBlock::GetAddress()
 template<typename T>
 vtkDenseArray<T>* vtkDenseArray<T>::New()
 {
- vtkObject* ret = vtkObjectFactory::CreateInstance(typeid(ThisT).name());
- if(ret)
- {
- return static_cast<ThisT*>(ret);
- }
- return new ThisT();
+ // Don't use object factory macros on templated classes. It'll confuse the
+ // object factory.
+ vtkDenseArray<T> *ret = new vtkDenseArray<T>;
+ ret->InitializeObjectBase();
+ return ret;
 }
 
 template<typename T>

Common/Core/vtkDynamicLoader.cxx

@@ -15,15 +15,13 @@
 #include "vtkDynamicLoader.h"
 
 #include "vtkDebugLeaks.h"
+#include "vtkObjectFactory.h"
 
 
 //-----------------------------------------------------------------------------
 vtkDynamicLoader* vtkDynamicLoader::New()
 {
-#ifdef VTK_DEBUG_LEAKS
- vtkDebugLeaks::ConstructClass("vtkDynamicLoader");
-#endif
- return new vtkDynamicLoader;
+ VTK_STANDARD_NEW_BODY(vtkDynamicLoader)
 }
 
 

Common/Core/vtkIndent.cxx

@@ -18,14 +18,7 @@
 //------------------------------------------------------------------------------
 vtkIndent* vtkIndent::New()
 {
- // First try to create the object from the vtkObjectFactory
- vtkObject* ret = vtkObjectFactory::CreateInstance("vtkIndent");
- if(ret)
- {
- return reinterpret_cast<vtkIndent*>(ret);
- }
- // If the factory was unable to create the object, then create it here.
- return new vtkIndent;
+ return new vtkIndent; // not a VTK object, don't use object factory macros
 }
 
 

Common/Core/vtkInformationDoubleKey.cxx

@@ -64,7 +64,7 @@ void vtkInformationDoubleKey::Set(vtkInformation* info, double value)
  {
  // Allocate a new value.
  vtkInformationDoubleValue* v = new vtkInformationDoubleValue;
- this->ConstructClass("vtkInformationDoubleValue");
+ v->InitializeObjectBase();
  v->Value = value;
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationDoubleVectorKey.cxx

@@ -83,7 +83,7 @@ void vtkInformationDoubleVectorKey::Set(vtkInformation* info,
  }
  vtkInformationDoubleVectorValue* v =
  new vtkInformationDoubleVectorValue;
- this->ConstructClass("vtkInformationDoubleVectorValue");
+ v->InitializeObjectBase();
  v->Value.insert(v->Value.begin(), value, value+length);
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationIdTypeKey.cxx

@@ -64,7 +64,7 @@ void vtkInformationIdTypeKey::Set(vtkInformation* info, vtkIdType value)
  {
  // Allocate a new value.
  vtkInformationIdTypeValue* v = new vtkInformationIdTypeValue;
- this->ConstructClass("vtkInformationIdTypeValue");
+ v->InitializeObjectBase();
  v->Value = value;
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationIntegerKey.cxx

@@ -64,7 +64,7 @@ void vtkInformationIntegerKey::Set(vtkInformation* info, int value)
  {
  // Allocate a new value.
  vtkInformationIntegerValue* v = new vtkInformationIntegerValue;
- this->ConstructClass("vtkInformationIntegerValue");
+ v->InitializeObjectBase();
  v->Value = value;
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationIntegerPointerKey.cxx

@@ -70,7 +70,7 @@ void vtkInformationIntegerPointerKey::Set(vtkInformation* info, int* value,
  // Allocate a new value.
  vtkInformationIntegerPointerValue* v =
  new vtkInformationIntegerPointerValue;
- this->ConstructClass("vtkInformationIntegerPointerValue");
+ v->InitializeObjectBase();
  v->Value = value;
  v->Length = length;
  this->SetAsObjectBase(info, v);

Common/Core/vtkInformationIntegerVectorKey.cxx

@@ -107,7 +107,7 @@ void vtkInformationIntegerVectorKey::Set(vtkInformation* info,
  // Allocate a new value.
  vtkInformationIntegerVectorValue* v =
  new vtkInformationIntegerVectorValue;
- this->ConstructClass("vtkInformationIntegerVectorValue");
+ v->InitializeObjectBase();
  v->Value.insert(v->Value.begin(), value, value+length);
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationKey.cxx

@@ -156,13 +156,6 @@ void vtkInformationKey::ReportAsObjectBase(vtkInformation* info,
 }
 
 //----------------------------------------------------------------------------
-#ifdef VTK_DEBUG_LEAKS
-void vtkInformationKey::ConstructClass(const char* name)
-{
- vtkDebugLeaks::ConstructClass(name);
-}
-#else
 void vtkInformationKey::ConstructClass(const char*)
 {
 }
-#endif

Common/Core/vtkInformationKeyVectorKey.cxx

@@ -99,9 +99,8 @@ void vtkInformationKeyVectorKey::Set(vtkInformation* info,
 {
  if(value)
  {
- vtkInformationKeyVectorValue* v =
- new vtkInformationKeyVectorValue;
- this->ConstructClass("vtkInformationKeyVectorValue");
+ vtkInformationKeyVectorValue* v = new vtkInformationKeyVectorValue;
+ v->InitializeObjectBase();
  v->Value.insert(v->Value.begin(), value, value+length);
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationObjectBaseVectorKey.cxx

@@ -75,7 +75,7 @@ vtkInformationObjectBaseVectorValue *
  if(base==NULL)
  {
  base=new vtkInformationObjectBaseVectorValue;
- this->ConstructClass("vtkInformationObjectBaseVectorValue"); // For debug info
+ base->InitializeObjectBase();
  this->SetAsObjectBase(info, base);
  base->Delete();
  }

Common/Core/vtkInformationStringKey.cxx

@@ -68,7 +68,7 @@ void vtkInformationStringKey::Set(vtkInformation* info, const char* value)
  {
  // Allocate a new value.
  vtkInformationStringValue* v = new vtkInformationStringValue;
- this->ConstructClass("vtkInformationStringValue");
+ v->InitializeObjectBase();
  v->Value = value;
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationStringVectorKey.cxx

@@ -92,7 +92,7 @@ void vtkInformationStringVectorKey::Set(vtkInformation* info, const char* value,
  {
  vtkInformationStringVectorValue* v =
  new vtkInformationStringVectorValue;
- this->ConstructClass("vtkInformationStringVectorValue");
+ v->InitializeObjectBase();
  while(static_cast<int>(v->Value.size()) <= index)
  {
  v->Value.push_back("");

Common/Core/vtkInformationUnsignedLongKey.cxx

@@ -65,7 +65,7 @@ void vtkInformationUnsignedLongKey::Set(vtkInformation* info,
  {
  // Allocate a new value.
  vtkInformationUnsignedLongValue* v = new vtkInformationUnsignedLongValue;
- this->ConstructClass("vtkInformationUnsignedLongValue");
+ v->InitializeObjectBase();
  v->Value = value;
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationVariantKey.cxx

@@ -68,7 +68,7 @@ void vtkInformationVariantKey::Set(vtkInformation* info, const vtkVariant& value
  {
  // Allocate a new value.
  vtkInformationVariantValue* v = new vtkInformationVariantValue;
- this->ConstructClass("vtkInformationVariantValue");
+ v->InitializeObjectBase();
  v->Value = value;
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkInformationVariantVectorKey.cxx

@@ -86,7 +86,7 @@ void vtkInformationVariantVectorKey::Set(vtkInformation* info, const vtkVariant*
  }
  vtkInformationVariantVectorValue* v =
  new vtkInformationVariantVectorValue;
- this->ConstructClass("vtkInformationVariantVectorValue");
+ v->InitializeObjectBase();
  v->Value.insert(v->Value.begin(), value, value+length);
  this->SetAsObjectBase(info, v);
  v->Delete();

Common/Core/vtkMath.cxx

@@ -45,10 +45,10 @@ class vtkMathInternal : public vtkObjectBase
  vtkBaseTypeMacro(vtkMathInternal, vtkObjectBase);
  static vtkMathInternal* New()
  {
-#ifdef VTK_DEBUG_LEAKS
- vtkDebugLeaks::ConstructClass("vtkMathInternal");
-#endif
- return new vtkMathInternal();
+ // Can't use object factory macros, since they cast to vtkObject*.
+ vtkMathInternal *ret = new vtkMathInternal;
+ ret->InitializeObjectBase();
+ return ret;
  }
 
  vtkMinimalStandardRandomSequence *Uniform;

Common/Core/vtkObject.cxx

@@ -17,6 +17,7 @@
 #include "vtkCommand.h"
 #include "vtkDebugLeaks.h"
 #include "vtkGarbageCollector.h"
+#include "vtkObjectFactory.h"
 #include "vtkTimeStamp.h"
 #include "vtkWeakPointer.h"
 
@@ -126,10 +127,9 @@ class vtkSubjectHelper
 
 vtkObject *vtkObject::New()
 {
-#ifdef VTK_DEBUG_LEAKS
- vtkDebugLeaks::ConstructClass("vtkObject");
-#endif
- return new vtkObject;
+ vtkObject *ret = new vtkObject;
+ ret->InitializeObjectBase();
+ return ret;
 }
 
 

Common/Core/vtkObjectBase.cxx

@@ -94,6 +94,14 @@ vtkObjectBase::~vtkObjectBase()
  }
 }
 
+//----------------------------------------------------------------------------
+void vtkObjectBase::InitializeObjectBase()
+{
+#ifdef VTK_DEBUG_LEAKS
+ vtkDebugLeaks::ConstructClass(this->GetClassName());
+#endif // VTK_DEBUG_LEAKS
+}
+
 //----------------------------------------------------------------------------
 #ifdef VTK_WORKAROUND_WINDOWS_MANGLE
 # undef GetClassName