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;

}

enum {

value =

!base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&

!base::is_convertible<T*,

base::subtle::RefCountedThreadSafeBase*>::value

};

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 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|.

//

// 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);

MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)

COMPILE_ASSERT(base::cef_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::cef_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::cef_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;