Line data    Source code

       1             : /*
       2             :  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : #ifndef WEBRTC_BASE_REFCOUNTEDOBJECT_H_
      11             : #define WEBRTC_BASE_REFCOUNTEDOBJECT_H_
      12             : 
      13             : #include <utility>
      14             : 
      15             : #include "webrtc/base/atomicops.h"
      16             : 
      17             : namespace rtc {
      18             : 
      19             : template <class T>
      20             : class RefCountedObject : public T {
      21             :  public:
      22           0 :   RefCountedObject() {}
      23             : 
      24             :   template <class P0>
      25           0 :   explicit RefCountedObject(P0&& p0) : T(std::forward<P0>(p0)) {}
      26             : 
      27             :   template <class P0, class P1, class... Args>
      28           0 :   RefCountedObject(P0&& p0, P1&& p1, Args&&... args)
      29           0 :       : T(std::forward<P0>(p0),
      30           0 :           std::forward<P1>(p1),
      31           0 :           std::forward<Args>(args)...) {}
      32             : 
      33           0 :   virtual int AddRef() const { return AtomicOps::Increment(&ref_count_); }
      34             : 
      35           0 :   virtual int Release() const {
      36           0 :     int count = AtomicOps::Decrement(&ref_count_);
      37           0 :     if (!count) {
      38           0 :       delete this;
      39             :     }
      40           0 :     return count;
      41             :   }
      42             : 
      43             :   // Return whether the reference count is one. If the reference count is used
      44             :   // in the conventional way, a reference count of 1 implies that the current
      45             :   // thread owns the reference and no other thread shares it. This call
      46             :   // performs the test for a reference count of one, and performs the memory
      47             :   // barrier needed for the owning thread to act on the object, knowing that it
      48             :   // has exclusive access to the object.
      49           0 :   virtual bool HasOneRef() const {
      50           0 :     return AtomicOps::AcquireLoad(&ref_count_) == 1;
      51             :   }
      52             : 
      53             :  protected:
      54           0 :   virtual ~RefCountedObject() {}
      55             : 
      56             :   mutable volatile int ref_count_ = 0;
      57             : };
      58             : 
      59             : }  // namespace rtc
      60             : 
      61             : #endif  // WEBRTC_BASE_REFCOUNTEDOBJECT_H_