Change assert() to DCHECK() in scoped_ptr.h

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 62 matching lines @@
 //
 //   scoped_ptr<Foo> foo(new Foo());
 //   scoped_ptr<FooParent> parent(foo.Pass());
 
 #ifndef BASE_MEMORY_SCOPED_PTR_H_
 #define BASE_MEMORY_SCOPED_PTR_H_
 
 // This is an implementation designed to match the anticipated future TR2
 // implementation of the scoped_ptr class.
 
-#include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <algorithm>  // For std::swap().
 #include <iosfwd>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/logging.h"

[danakj, 2015/09/03 17:16:27]

This will include logging in a lot of places. Does LOG still conflict with blink
macros?

 #include "base/move.h"
 #include "base/template_util.h"
 
 namespace base {
 
 namespace subtle {
 class RefCountedBase;
 class RefCountedThreadSafeBase;
 }  // namespace subtle
 
@@ skipping 117 matching lines @@
     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 for default deleters:
     // https://crbug.com/162971
-    assert(!ShouldAbortOnSelfReset<D>::value || p == nullptr || p != data_.ptr);
+    DCHECK(!ShouldAbortOnSelfReset<D>::value || p == nullptr || p != data_.ptr);
 
     // 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 130 matching lines @@
   scoped_ptr& operator=(decltype(nullptr)) {
     reset();
     return *this;
   }
 
   // Reset.  Deletes the currently owned object, if any.
   // Then takes ownership of a new object, if given.
   void reset(element_type* p = nullptr) { impl_.reset(p); }
 
   // Accessors to get the owned object.
-  // operator* and operator-> will assert() if there is no current object.
+  // operator* and operator-> will DCHECK() if there is no current object.
   element_type& operator*() const {
-    assert(impl_.get() != nullptr);
+    DCHECK(impl_.get() != nullptr);
     return *impl_.get();
   }
   element_type* operator->() const  {
-    assert(impl_.get() != nullptr);
+    DCHECK(impl_.get() != nullptr);
     return impl_.get();
   }
   element_type* get() const { return impl_.get(); }
 
   // Access to the deleter.
   deleter_type& get_deleter() { return impl_.get_deleter(); }
   const deleter_type& get_deleter() const { return impl_.get_deleter(); }
 
   // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
   // implicitly convertible to a real bool (which is dangerous).
@@ skipping 91 matching lines @@
     reset();
     return *this;
   }
 
   // Reset.  Deletes the currently owned array, if any.
   // Then takes ownership of a new object, if given.
   void reset(element_type* array = nullptr) { impl_.reset(array); }
 
   // Accessors to get the owned array.
   element_type& operator[](size_t i) const {
-    assert(impl_.get() != nullptr);
+    DCHECK(impl_.get() != nullptr);
     return impl_.get()[i];
   }
   element_type* get() const { return impl_.get(); }
 
   // Access to the deleter.
   deleter_type& get_deleter() { return impl_.get_deleter(); }
   const deleter_type& get_deleter() const { return impl_.get_deleter(); }
 
   // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
   // implicitly convertible to a real bool (which is dangerous).
@@ skipping 76 matching lines @@
 scoped_ptr<T> make_scoped_ptr(T* ptr) {
   return scoped_ptr<T>(ptr);
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& out, const scoped_ptr<T>& p) {
   return out << p.get();
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_