(default)
Class CefRefPtr

template < class T > class CefRefPtr

Smart pointer implementation borrowed from base/ref_counted.h

A smart pointer class for reference counted objects. Use this class instead of calling AddRef and Release manually on a reference counted object to avoid common memory leaks caused by forgetting to Release an object reference. Sample usage:

  class MyFoo : public CefBase {
   ...
  };
  void some_function() {
    // The MyFoo object that |foo| represents starts with a single
    // reference.
    CefRefPtr<MyFoo> foo = new MyFoo();
    foo->Method(param);
    // |foo| is released when this function returns
  }
  void some_other_function() {
    CefRefPtr<MyFoo> foo = new MyFoo();
    ...
    foo = NULL;  // explicitly releases |foo|
    ...
    if (foo)
      foo->Method(param);
  }

  {
    CefRefPtr<MyFoo> a = new MyFoo();
    CefRefPtr<MyFoo> b;
    b.swap(a);
    // now, |b| references the MyFoo object, and |a| references NULL.
  }

  {
    CefRefPtr<MyFoo> a = new MyFoo();
    CefRefPtr<MyFoo> b;
    b = a;
    // now, |a| and |b| each own a reference to the same MyFoo object.
    // the reference count of the underlying MyFoo object will be 2.
  }

  void some_func_with_param(CefRefPtr<MyFoo> param) {
    // A reference is added to the MyFoo object that |param| represents
    // during the scope of some_func_with_param() and released when
    // some_func_with_param() goes out of scope.
  }
  CefRefPtr<MyFoo> some_func_with_retval() {
    // The MyFoo object that |foox| represents starts with a single
    // reference.
    CefRefPtr<MyFoo> foox = new MyFoo();
    // Creating the return value adds an additional reference.
    return foox;
    // When some_func_with_retval() goes out of scope the original |foox|
    // reference is released.
  }
  void and_another_function() {
    CefRefPtr<MyFoo> foo = new MyFoo();
    // pass |foo| as a parameter.
    some_function(foo);
    CefRefPtr<MyFoo> foo2 = some_func_with_retval();
    // Now, since we kept a reference to the some_func_with_retval() return
    // value, |foo2| is the only class pointing to the MyFoo object created
    in some_func_with_retval(), and it has a reference count of 1.
    some_func_with_retval();
    // Now, since we didn't keep a reference to the some_func_with_retval()
    // return value, the MyFoo object created in some_func_with_retval()
    // will automatically be released.
  }

  {
     // Create a vector that holds MyFoo objects.
     std::vector<CefRefPtr<MyFoo> > MyFooVec;
    // The MyFoo object that |foo| represents starts with a single
    // reference.
    CefRefPtr<MyFoo> foo = new MyFoo();
    // When the MyFoo object is added to |MyFooVec| the reference count
    // is increased to 2.
    MyFooVec.push_back(foo);
  }

CefRefPtr

public CefRefPtr( T* p );

CefRefPtr

public CefRefPtr( const CefRefPtr< T >& r );

CefRefPtr

public CefRefPtr();

~CefRefPtr

public ~CefRefPtr();

get

public T* get() const;

operator->

public T* operator->() const;

operator=

public CefRefPtr< T >& operator=( T* p );

operator=

public CefRefPtr< T >& operator=( const CefRefPtr< T >& r );

swap

public void swap( T** pp );

swap

public void swap( CefRefPtr< T >& r );

T*

public operator T*() const;