Allow custom deleters to opt out of self reset checks for scoped_ptr.

base/memory/scoped_ptr.h

 // 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.
 
 // Scopers help you manage ownership of a pointer, helping you easily manage 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<T>):
@@ skipping 80 matching lines @@
 // implementation of the scoped_ptr class.
 
 #include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <algorithm>  // For std::swap().
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/debug/debugger.h"
 #include "base/move.h"
 #include "base/template_util.h"
 
 namespace base {
 
 namespace subtle {
 class RefCountedBase;
 class RefCountedThreadSafeBase;
 }  // namespace subtle
 
@@ skipping 66 matching lines @@
 namespace internal {
 
 template <typename T> struct IsNotRefCounted {
   enum {
     value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
         !base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
             value
   };
 };
 
+template <typename T>
+struct ShouldAbortOnSelfReset {
+  template <typename U>
+  static NoType Test(const typename U::AllowSelfReset*);
+
+  template <typename U>
+  static YesType Test(...);
+
+  static const bool value = sizeof(Test<T>(0)) == sizeof(YesType);
+};
+
 // Minimal implementation of the core logic of scoped_ptr, suitable for
 // reuse in both scoped_ptr and its specializations.
 template <class T, class D>
 class scoped_ptr_impl {
  public:
   explicit scoped_ptr_impl(T* p) : data_(p) {}
 
   // Initializer for deleters that have data parameters.
   scoped_ptr_impl(T* p, const D& d) : data_(p, d) {}
 
@@ skipping 18 matching lines @@
 
   ~scoped_ptr_impl() {
     if (data_.ptr != nullptr) {
       // Not using get_deleter() saves one function call in non-optimized
       // builds.
       static_cast<D&>(data_)(data_.ptr);
     }
   }
 
   void reset(T* p) {
-    // This is a self-reset, which is no longer allowed: http://crbug.com/162971
-    if (p != nullptr && p == data_.ptr)
-      abort();
+    // This is a self-reset, which is no longer allowed for default deleters:
+    // https://crbug.com/162971
+    if (ShouldAbortOnSelfReset<D>::value && p != nullptr && p == data_.ptr) {
+      // TODO(dcheng): This is essentially what CHECK() does under the covers.
+      // However, that requires including base/logging.h. Since this file is
+      // included in some Blink code, and the Chromium logging defines conflict
+      // with Blink's, call base::debug::BreakDebugger() directly for now.
+      base::debug::BreakDebugger();
+    }
 
     // Note that running data_.ptr = p can lead to undefined behavior if
     // get_deleter()(get()) deletes this. In order to prevent this, reset()
     // should update the stored pointer before deleting its old value.
     //
     // However, changing reset() to use that behavior may cause current code to
     // break in unexpected ways. If the destruction of the owned object
     // dereferences the scoped_ptr when it is destroyed by a call to reset(),
     // then it will incorrectly dispatch calls to |p| rather than the original
     // value of |data_.ptr|.
@@ skipping 351 matching lines @@
 
 // A function to convert T* into scoped_ptr<T>
 // Doing e.g. make_scoped_ptr(new FooBarBaz<type>(arg)) is a shorter notation
 // for scoped_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
 template <typename T>
 scoped_ptr<T> make_scoped_ptr(T* ptr) {
   return scoped_ptr<T>(ptr);
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_