The Tor Browser: comparison security/sandbox/chromium/base/memory/scoped

--1:000000000000
+:0bfc42282b93
+// 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 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<T>):
+//   {
+//     scoped_ptr<Foo> foo(new Foo("wee"));
+//   }  // foo goes out of scope, releasing the pointer with it.
+//
+//   {
+//     scoped_ptr<Foo> foo;          // No pointer managed.
+//     foo.reset(new Foo("wee"));    // Now a pointer is managed.
+//     foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
+//     foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
+//     foo->Method();                // Foo::Method() called.
+//     foo.get()->Method();          // Foo::Method() called.
+//     SomeFunc(foo.release());      // SomeFunc takes ownership, foo no longer
+//                                   // manages a pointer.
+//     foo.reset(new Foo("wee4"));   // foo manages a pointer again.
+//     foo.reset();                  // Foo("wee4") destroyed, foo no longer
+//                                   // manages a pointer.
+//   }  // foo wasn't managing a pointer, so nothing was destroyed.
+//
+// Example usage (scoped_ptr<T[]>):
+//   {
+//     scoped_ptr<Foo[]> foo(new Foo[100]);
+//     foo.get()->Method();  // Foo::Method on the 0th element.
+//     foo[10].Method();     // Foo::Method on the 10th element.
+//   }
+//
+// These scopers also implement part of the functionality of C++11 unique_ptr
+// in that they are "movable but not copyable."  You can use the scopers in
+// the parameter and return types of functions to signify ownership transfer
+// in to and out of a function.  When calling a function that has a scoper
+// as the argument type, it must be called with the result of an analogous
+// scoper's Pass() function or another function that generates a temporary;
+// passing by copy will NOT work.  Here is an example using scoped_ptr:
+//
+//   void TakesOwnership(scoped_ptr<Foo> arg) {
+//     // Do something with arg
+//   }
+//   scoped_ptr<Foo> CreateFoo() {
+//     // No need for calling Pass() because we are constructing a temporary
+//     // for the return value.
+//     return scoped_ptr<Foo>(new Foo("new"));
+//   }
+//   scoped_ptr<Foo> PassThru(scoped_ptr<Foo> arg) {
+//     return arg.Pass();
+//   }
+//
+//   {
+//     scoped_ptr<Foo> ptr(new Foo("yay"));  // ptr manages Foo("yay").
+//     TakesOwnership(ptr.Pass());           // ptr no longer owns Foo("yay").
+//     scoped_ptr<Foo> ptr2 = CreateFoo();   // ptr2 owns the return Foo.
+//     scoped_ptr<Foo> ptr3 =                // ptr3 now owns what was in ptr2.
+//         PassThru(ptr2.Pass());            // ptr2 is correspondingly NULL.
+//   }
+//
+// Notice that if you do not call Pass() when returning from PassThru(), or
+// when invoking TakesOwnership(), the code will not compile because scopers
+// are not copyable; they only implement move semantics which require calling
+// the Pass() function to signify a destructive transfer of state. CreateFoo()
+// is different though because we are constructing a temporary on the return
+// line and thus can avoid needing to call Pass().
+//
+// Pass() properly handles upcast in assignment, i.e. you can assign
+// scoped_ptr<Child> to scoped_ptr<Parent>:
+//
+//   scoped_ptr<Foo> foo(new Foo());
+//   scoped_ptr<FooParent> parent = foo.Pass();
+//
+// PassAs<>() should be used to upcast return value in return statement:
+//
+//   scoped_ptr<Foo> CreateFoo() {
+//     scoped_ptr<FooChild> result(new FooChild());
+//     return result.PassAs<Foo>();
+//   }
+//
+// Note that PassAs<>() is implemented only for scoped_ptr<T>, but not for
+// scoped_ptr<T[]>. This is because casting array pointers may not be safe.
+#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 and scoped_ptr_malloc (deprecated).
+#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/move.h"
+#include "base/template_util.h"
+namespace base {
+namespace subtle {
+class RefCountedBase;
+class RefCountedThreadSafeBase;
+}  // namespace subtle
+// Function object which deletes its parameter, which must be a pointer.
+// If C is an array type, invokes 'delete[]' on the parameter; otherwise,
+// invokes 'delete'. The default deleter for scoped_ptr<T>.
+template <class T>
+struct DefaultDeleter {
+DefaultDeleter() {}
+template <typename U> DefaultDeleter(const DefaultDeleter<U>& other) {
+// IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
+// if U* is implicitly convertible to T* and U is not an array type.
+//
+// Correct implementation should use SFINAE to disable this
+// constructor. However, since there are no other 1-argument constructors,
+// using a COMPILE_ASSERT() based on is_convertible<> and requiring
+// complete types is simpler and will cause compile failures for equivalent
+// misuses.
+//
+// Note, the is_convertible<U*, T*> check also ensures that U is not an
+// array. T is guaranteed to be a non-array, so any U* where U is an array
+// cannot convert to T*.
+enum { T_must_be_complete = sizeof(T) };
+enum { U_must_be_complete = sizeof(U) };
+COMPILE_ASSERT((base::is_convertible<U*, T*>::value),
+U_ptr_must_implicitly_convert_to_T_ptr);
+}
+inline void operator()(T* ptr) const {
+enum { type_must_be_complete = sizeof(T) };
+delete ptr;
+}
+};
+// Specialization of DefaultDeleter for array types.
+template <class T>
+struct DefaultDeleter<T[]> {
+inline void operator()(T* ptr) const {
+enum { type_must_be_complete = sizeof(T) };
+delete[] ptr;
+}
+private:
+// Disable this operator for any U != T because it is undefined to execute
+// an array delete when the static type of the array mismatches the dynamic
+// type.
+//
+// References:
+//   C++98 [expr.delete]p3
+//   http://cplusplus.github.com/LWG/lwg-defects.html#938
+template <typename U> void operator()(U* array) const;
+};
+template <class T, int n>
+struct DefaultDeleter<T[n]> {
+// Never allow someone to declare something like scoped_ptr<int[10]>.
+COMPILE_ASSERT(sizeof(T) == -1, do_not_use_array_with_size_as_type);
+};
+// Function object which invokes 'free' on its parameter, which must be
+// a pointer. Can be used to store malloc-allocated pointers in scoped_ptr:
+//
+// scoped_ptr<int, base::FreeDeleter> foo_ptr(
+//     static_cast<int*>(malloc(sizeof(int))));
+struct FreeDeleter {
+inline void operator()(void* ptr) const {
+free(ptr);
+}
+};
+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
+};
+};
+// 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) {}
+// Templated constructor that destructively takes the value from another
+// scoped_ptr_impl.
+template <typename U, typename V>
+scoped_ptr_impl(scoped_ptr_impl<U, V>* other)
+: data_(other->release(), other->get_deleter()) {
+// We do not support move-only deleters.  We could modify our move
+// emulation to have base::subtle::move() and base::subtle::forward()
+// functions that are imperfect emulations of their C++11 equivalents,
+// but until there's a requirement, just assume deleters are copyable.
+}
+template <typename U, typename V>
+void TakeState(scoped_ptr_impl<U, V>* other) {
+// See comment in templated constructor above regarding lack of support
+// for move-only deleters.
+reset(other->release());
+get_deleter() = other->get_deleter();
+}
+~scoped_ptr_impl() {
+if (data_.ptr != NULL) {
+// 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 != NULL && p == data_.ptr)
+abort();
+// Note that running data_.ptr = p can lead to undefined behavior if
+// get_deleter()(get()) deletes this. In order to pevent 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|.
+//
+// During the transition period, set the stored pointer to NULL while
+// deleting the object. Eventually, this safety check will be removed to
+// prevent the scenario initially described from occuring and
+// http://crbug.com/176091 can be closed.
+T* old = data_.ptr;
+data_.ptr = NULL;
+if (old != NULL)
+static_cast<D&>(data_)(old);
+data_.ptr = p;
+}
+T* get() const { return data_.ptr; }
+D& get_deleter() { return data_; }
+const D& get_deleter() const { return data_; }
+void swap(scoped_ptr_impl& p2) {
+// Standard swap idiom: 'using std::swap' ensures that std::swap is
+// present in the overload set, but we call swap unqualified so that
+// any more-specific overloads can be used, if available.
+using std::swap;
+swap(static_cast<D&>(data_), static_cast<D&>(p2.data_));
+swap(data_.ptr, p2.data_.ptr);
+}
+T* release() {
+T* old_ptr = data_.ptr;
+data_.ptr = NULL;
+return old_ptr;
+}
+private:
+// Needed to allow type-converting constructor.
+template <typename U, typename V> friend class scoped_ptr_impl;
+// Use the empty base class optimization to allow us to have a D
+// member, while avoiding any space overhead for it when D is an
+// empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
+// discussion of this technique.
+struct Data : public D {
+explicit Data(T* ptr_in) : ptr(ptr_in) {}
+Data(T* ptr_in, const D& other) : D(other), ptr(ptr_in) {}
+T* ptr;
+};
+Data data_;
+DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl);
+};
+}  // namespace internal
+}  // namespace base
+// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
+// automatically deletes the pointer it holds (if any).
+// That is, scoped_ptr<T> owns the T object that it points to.
+// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
+// Also like T*, scoped_ptr<T> is thread-compatible, and once you
+// dereference it, you get the thread safety guarantees of T.
+//
+// The size of scoped_ptr is small. On most compilers, when using the
+// DefaultDeleter, sizeof(scoped_ptr<T>) == sizeof(T*). Custom deleters will
+// increase the size proportional to whatever state they need to have. See
+// comments inside scoped_ptr_impl<> for details.
+//
+// Current implementation targets having a strict subset of  C++11's
+// unique_ptr<> features. Known deficiencies include not supporting move-only
+// deleteres, function pointers as deleters, and deleters with reference
+// types.
+template <class T, class D = base::DefaultDeleter<T> >
+class scoped_ptr {
+MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+COMPILE_ASSERT(base::internal::IsNotRefCounted<T>::value,
+T_is_refcounted_type_and_needs_scoped_refptr);
+public:
+// The element and deleter types.
+typedef T element_type;
+typedef D deleter_type;
+// Constructor.  Defaults to initializing with NULL.
+scoped_ptr() : impl_(NULL) { }
+// Constructor.  Takes ownership of p.
+explicit scoped_ptr(element_type* p) : impl_(p) { }
+// Constructor.  Allows initialization of a stateful deleter.
+scoped_ptr(element_type* p, const D& d) : impl_(p, d) { }
+// Constructor.  Allows construction from a scoped_ptr rvalue for a
+// convertible type and deleter.
+//
+// IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct
+// from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor
+// has different post-conditions if D is a reference type. Since this
+// implementation does not support deleters with reference type,
+// we do not need a separate move constructor allowing us to avoid one
+// use of SFINAE. You only need to care about this if you modify the
+// implementation of scoped_ptr.
+template <typename U, typename V>
+scoped_ptr(scoped_ptr<U, V> other) : impl_(&other.impl_) {
+COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+}
+// Constructor.  Move constructor for C++03 move emulation of this type.
+scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+// operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
+// type and deleter.
+//
+// IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from
+// the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated
+// form has different requirements on for move-only Deleters. Since this
+// implementation does not support move-only Deleters, we do not need a
+// separate move assignment operator allowing us to avoid one use of SFINAE.
+// You only need to care about this if you modify the implementation of
+// scoped_ptr.
+template <typename U, typename V>
+scoped_ptr& operator=(scoped_ptr<U, V> rhs) {
+COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+impl_.TakeState(&rhs.impl_);
+return *this;
+}
+// Reset.  Deletes the currently owned object, if any.
+// Then takes ownership of a new object, if given.
+void reset(element_type* p = NULL) { impl_.reset(p); }
+// Accessors to get the owned object.
+// operator* and operator-> will assert() if there is no current object.
+element_type& operator*() const {
+assert(impl_.get() != NULL);
+return *impl_.get();
+}
+element_type* operator->() const  {
+assert(impl_.get() != NULL);
+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).
+//
+// Note that this trick is only safe when the == and != operators
+// are declared explicitly, as otherwise "scoped_ptr1 ==
+// scoped_ptr2" will compile but do the wrong thing (i.e., convert
+// to Testable and then do the comparison).
+private:
+typedef base::internal::scoped_ptr_impl<element_type, deleter_type>
+scoped_ptr::*Testable;
+public:
+operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
+// Comparison operators.
+// These return whether two scoped_ptr refer to the same object, not just to
+// two different but equal objects.
+bool operator==(const element_type* p) const { return impl_.get() == p; }
+bool operator!=(const element_type* p) const { return impl_.get() != p; }
+// Swap two scoped pointers.
+void swap(scoped_ptr& p2) {
+impl_.swap(p2.impl_);
+}
+// Release a pointer.
+// The return value is the current pointer held by this object.
+// If this object holds a NULL pointer, the return value is NULL.
+// After this operation, this object will hold a NULL pointer,
+// and will not own the object any more.
+element_type* release() WARN_UNUSED_RESULT {
+return impl_.release();
+}
+// C++98 doesn't support functions templates with default parameters which
+// makes it hard to write a PassAs() that understands converting the deleter
+// while preserving simple calling semantics.
+//
+// Until there is a use case for PassAs() with custom deleters, just ignore
+// the custom deleter.
+template <typename PassAsType>
+scoped_ptr<PassAsType> PassAs() {
+return scoped_ptr<PassAsType>(Pass());
+}
+private:
+// Needed to reach into |impl_| in the constructor.
+template <typename U, typename V> friend class scoped_ptr;
+base::internal::scoped_ptr_impl<element_type, deleter_type> impl_;
+// Forbidden for API compatibility with std::unique_ptr.
+explicit scoped_ptr(int disallow_construction_from_null);
+// Forbid comparison of scoped_ptr types.  If U != T, it totally
+// doesn't make sense, and if U == T, it still doesn't make sense
+// because you should never have the same object owned by two different
+// scoped_ptrs.
+template <class U> bool operator==(scoped_ptr<U> const& p2) const;
+template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
+};
+template <class T, class D>
+class scoped_ptr<T[], D> {
+MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
+public:
+// The element and deleter types.
+typedef T element_type;
+typedef D deleter_type;
+// Constructor.  Defaults to initializing with NULL.
+scoped_ptr() : impl_(NULL) { }
+// Constructor. Stores the given array. Note that the argument's type
+// must exactly match T*. In particular:
+// - it cannot be a pointer to a type derived from T, because it is
+//   inherently unsafe in the general case to access an array through a
+//   pointer whose dynamic type does not match its static type (eg., if
+//   T and the derived types had different sizes access would be
+//   incorrectly calculated). Deletion is also always undefined
+//   (C++98 [expr.delete]p3). If you're doing this, fix your code.
+// - it cannot be NULL, because NULL is an integral expression, not a
+//   pointer to T. Use the no-argument version instead of explicitly
+//   passing NULL.
+// - it cannot be const-qualified differently from T per unique_ptr spec
+//   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
+//   to work around this may use implicit_cast<const T*>().
+//   However, because of the first bullet in this comment, users MUST
+//   NOT use implicit_cast<Base*>() to upcast the static type of the array.
+explicit scoped_ptr(element_type* array) : impl_(array) { }
+// Constructor.  Move constructor for C++03 move emulation of this type.
+scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { }
+// operator=.  Move operator= for C++03 move emulation of this type.
+scoped_ptr& operator=(RValue rhs) {
+impl_.TakeState(&rhs.object->impl_);
+return *this;
+}
+// Reset.  Deletes the currently owned array, if any.
+// Then takes ownership of a new object, if given.
+void reset(element_type* array = NULL) { impl_.reset(array); }
+// Accessors to get the owned array.
+element_type& operator[](size_t i) const {
+assert(impl_.get() != NULL);
+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).
+private:
+typedef base::internal::scoped_ptr_impl<element_type, deleter_type>
+scoped_ptr::*Testable;
+public:
+operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
+// Comparison operators.
+// These return whether two scoped_ptr refer to the same object, not just to
+// two different but equal objects.
+bool operator==(element_type* array) const { return impl_.get() == array; }
+bool operator!=(element_type* array) const { return impl_.get() != array; }
+// Swap two scoped pointers.
+void swap(scoped_ptr& p2) {
+impl_.swap(p2.impl_);
+}
+// Release a pointer.
+// The return value is the current pointer held by this object.
+// If this object holds a NULL pointer, the return value is NULL.
+// After this operation, this object will hold a NULL pointer,
+// and will not own the object any more.
+element_type* release() WARN_UNUSED_RESULT {
+return impl_.release();
+}
+private:
+// Force element_type to be a complete type.
+enum { type_must_be_complete = sizeof(element_type) };
+// Actually hold the data.
+base::internal::scoped_ptr_impl<element_type, deleter_type> impl_;
+// Disable initialization from any type other than element_type*, by
+// providing a constructor that matches such an initialization, but is
+// private and has no definition. This is disabled because it is not safe to
+// call delete[] on an array whose static type does not match its dynamic
+// type.
+template <typename U> explicit scoped_ptr(U* array);
+explicit scoped_ptr(int disallow_construction_from_null);
+// Disable reset() from any type other than element_type*, for the same
+// reasons as the constructor above.
+template <typename U> void reset(U* array);
+void reset(int disallow_reset_from_null);
+// Forbid comparison of scoped_ptr types.  If U != T, it totally
+// doesn't make sense, and if U == T, it still doesn't make sense
+// because you should never have the same object owned by two different
+// scoped_ptrs.
+template <class U> bool operator==(scoped_ptr<U> const& p2) const;
+template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
+};
+// Free functions
+template <class T, class D>
+void swap(scoped_ptr<T, D>& p1, scoped_ptr<T, D>& p2) {
+p1.swap(p2);
+}
+template <class T, class D>
+bool operator==(T* p1, const scoped_ptr<T, D>& p2) {
+return p1 == p2.get();
+}
+template <class T, class D>
+bool operator!=(T* p1, const scoped_ptr<T, D>& p2) {
+return p1 != p2.get();
+}
+// DEPRECATED: Use scoped_ptr<C, base::FreeDeleter> instead.
+//
+// scoped_ptr_malloc<> is similar to scoped_ptr<>, but it accepts a
+// second template argument, the functor used to free the object.
+template<class C, class FreeProc = base::FreeDeleter>
+class scoped_ptr_malloc {
+MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr_malloc, RValue)
+public:
+// The element type
+typedef C element_type;
+// 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) {}
+// Constructor.  Move constructor for C++03 move emulation of this type.
+scoped_ptr_malloc(RValue rvalue)
+: ptr_(rvalue.object->release()) {
+}
+// Destructor.  If there is a C object, call the Free functor.
+~scoped_ptr_malloc() {
+reset();
+}
+// operator=.  Move operator= for C++03 move emulation of this type.
+scoped_ptr_malloc& operator=(RValue rhs) {
+reset(rhs.object->release());
+return *this;
+}
+// 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) {
+if (ptr_ != NULL) {
+FreeProc free_proc;
+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_;
+}
+C* operator->() const {
+assert(ptr_ != NULL);
+return ptr_;
+}
+C* get() const {
+return ptr_;
+}
+// Allow scoped_ptr_malloc<C> to be used in boolean expressions, but not
+// implicitly convertible to a real bool (which is dangerous).
+typedef C* scoped_ptr_malloc::*Testable;
+operator Testable() const { return ptr_ ? &scoped_ptr_malloc::ptr_ : NULL; }
+// Comparison operators.
+// These return whether a scoped_ptr_malloc and a plain pointer refer
+// to the same object, not just to two different but equal objects.
+// For compatibility with the boost-derived implementation, these
+// take non-const arguments.
+bool operator==(C* p) const {
+return ptr_ == p;
+}
+bool operator!=(C* p) const {
+return ptr_ != p;
+}
+// Swap two scoped pointers.
+void swap(scoped_ptr_malloc & b) {
+C* tmp = b.ptr_;
+b.ptr_ = ptr_;
+ptr_ = tmp;
+}
+// Release a pointer.
+// The return value is the current pointer held by this object.
+// If this object holds a NULL pointer, the return value is NULL.
+// After this operation, this object will hold a NULL pointer,
+// and will not own the object any more.
+C* release() WARN_UNUSED_RESULT {
+C* tmp = ptr_;
+ptr_ = NULL;
+return tmp;
+}
+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;
+};
+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();
+}
+// 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_

The Tor Browser / file comparison

comparison: security/sandbox/chromium/base/memory/scoped_ptr.h

security/sandbox/chromium/base/memory/scoped_ptr.h