| // Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the name Chromium Embedded |
| // Framework nor the names of its contributors may be used to endorse |
| // or promote products derived from this software without specific prior |
| // written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #ifndef CEF_INCLUDE_INTERNAL_CEF_PTR_H_ |
| #define CEF_INCLUDE_INTERNAL_CEF_PTR_H_ |
| #pragma once |
| |
| #include "include/base/cef_build.h" |
| #include "include/base/cef_ref_counted.h" |
| |
| #if defined(USING_CHROMIUM_INCLUDES) |
| #include <memory> // For std::unique_ptr. |
| #else |
| #include "include/base/cef_scoped_ptr.h" |
| #endif |
| |
| /// |
| // Smart pointer implementation that is an alias of scoped_refptr from |
| // include/base/cef_ref_counted.h. |
| // <p> |
| // 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: |
| // <pre> |
| // class MyFoo : public CefBaseRefCounted { |
| // ... |
| // }; |
| // |
| // 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); |
| // } |
| // </pre> |
| // The above examples show how CefRefPtr<T> acts like a pointer to T. |
| // Given two CefRefPtr<T> classes, it is also possible to exchange |
| // references between the two objects, like so: |
| // <pre> |
| // { |
| // CefRefPtr<MyFoo> a = new MyFoo(); |
| // CefRefPtr<MyFoo> b; |
| // |
| // b.swap(a); |
| // // now, |b| references the MyFoo object, and |a| references NULL. |
| // } |
| // </pre> |
| // To make both |a| and |b| in the above example reference the same MyFoo |
| // object, simply use the assignment operator: |
| // <pre> |
| // { |
| // 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. |
| // } |
| // </pre> |
| // Reference counted objects can also be passed as function parameters and |
| // used as function return values: |
| // <pre> |
| // 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. |
| // } |
| // </pre> |
| // And in standard containers: |
| // <pre> |
| // { |
| // // 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); |
| // } |
| // </pre> |
| // </p> |
| /// |
| #if defined(HAS_CPP11_TEMPLATE_ALIAS_SUPPORT) |
| template <class T> |
| using CefRefPtr = scoped_refptr<T>; |
| #else |
| // When template aliases are not supported use a define instead of subclassing |
| // because it's otherwise hard to get the constructors to behave correctly. |
| #define CefRefPtr scoped_refptr |
| #endif |
| |
| /// |
| // A CefOwnPtr<T> is like a T*, except that the destructor of CefOwnPtr<T> |
| // automatically deletes the pointer it holds (if any). That is, CefOwnPtr<T> |
| // owns the T object that it points to. Like a T*, a CefOwnPtr<T> may hold |
| // either NULL or a pointer to a T object. Also like T*, CefOwnPtr<T> is |
| // thread-compatible, and once you dereference it, you get the thread safety |
| // guarantees of T. |
| /// |
| #if defined(USING_CHROMIUM_INCLUDES) |
| // Implementation-side code uses std::unique_ptr instead of scoped_ptr. |
| template <class T, class D = std::default_delete<T>> |
| using CefOwnPtr = std::unique_ptr<T, D>; |
| #elif defined(HAS_CPP11_TEMPLATE_ALIAS_SUPPORT) |
| template <class T, class D = base::DefaultDeleter<T>> |
| using CefOwnPtr = scoped_ptr<T, D>; |
| #else |
| // When template aliases are not supported use a define instead of subclassing |
| // because it's otherwise hard to get the constructors to behave correctly. |
| #define CefOwnPtr scoped_ptr |
| #endif |
| |
| /// |
| // A CefRawPtr<T> is the same as T* |
| /// |
| #if defined(HAS_CPP11_TEMPLATE_ALIAS_SUPPORT) |
| #define CEF_RAW_PTR_GET(r) r |
| template <class T> |
| using CefRawPtr = T*; |
| #else |
| // Simple wrapper implementation that behaves as much like T* as possible. |
| // CEF_RAW_PTR_GET is required for VS2008 compatibility (Issue #2155). |
| #define CEF_RAW_PTR_GET(r) r.get() |
| template <class T> |
| class CefRawPtr { |
| public: |
| CefRawPtr() : ptr_(nullptr) {} |
| CefRawPtr(T* p) : ptr_(p) {} |
| CefRawPtr(const CefRawPtr& r) : ptr_(r.ptr_) {} |
| |
| template <typename U> |
| CefRawPtr(const CefRawPtr<U>& r) : ptr_(r.get()) {} |
| |
| T* get() const { return ptr_; } |
| |
| // Allow CefRawPtr to be used in boolean expression and comparison operations. |
| operator T*() const { return ptr_; } |
| |
| T* operator->() const { |
| assert(ptr_ != NULL); |
| return ptr_; |
| } |
| |
| CefRawPtr<T>& operator=(T* p) { |
| ptr_ = p; |
| return *this; |
| } |
| |
| CefRawPtr<T>& operator=(const CefRawPtr<T>& r) { return *this = r.ptr_; } |
| |
| template <typename U> |
| CefRawPtr<T>& operator=(const CefRawPtr<U>& r) { |
| return *this = r.get(); |
| } |
| |
| private: |
| T* ptr_; |
| }; |
| #endif |
| |
| #endif // CEF_INCLUDE_INTERNAL_CEF_PTR_H_ |