Delete referencecountedsingletonfactory.h.

webrtc/base/referencecountedsingletonfactory.h

Index: webrtc/base/referencecountedsingletonfactory.h
diff --git a/webrtc/base/referencecountedsingletonfactory.h b/webrtc/base/referencecountedsingletonfactory.h
deleted file mode 100644
index 500150f6fd558394f1cf3b5c8d3eb69777beb0a0..0000000000000000000000000000000000000000
--- a/webrtc/base/referencecountedsingletonfactory.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
-#define WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
-
-#include <memory>
-
-#include "webrtc/base/common.h"
-#include "webrtc/base/constructormagic.h"
-#include "webrtc/base/criticalsection.h"
-#include "webrtc/base/logging.h"
-
-namespace rtc {
-
-template <typename Interface> class rcsf_ptr;
-
-// A ReferenceCountedSingletonFactory is an object which owns another object,
-// and doles out the owned object to consumers in a reference-counted manner.
-// Thus, the factory owns at most one object of the desired kind, and
-// hands consumers a special pointer to it, through which they can access it.
-// When the consumers delete the pointer, the reference count goes down,
-// and if the reference count hits zero, the factory can throw the object
-// away.  If a consumer requests the pointer and the factory has none,
-// it can create one on the fly and pass it back.
-template <typename Interface>
-class ReferenceCountedSingletonFactory {
-  friend class rcsf_ptr<Interface>;
- public:
-  ReferenceCountedSingletonFactory() : ref_count_(0) {}
-
-  virtual ~ReferenceCountedSingletonFactory() {
-    ASSERT(ref_count_ == 0);
-  }
-
- protected:
-  // Must be implemented in a sub-class. The sub-class may choose whether or not
-  // to cache the instance across lifetimes by either reset()'ing or not
-  // reset()'ing the unique_ptr in CleanupInstance().
-  virtual bool SetupInstance() = 0;
-  virtual void CleanupInstance() = 0;
-
-  std::unique_ptr<Interface> instance_;
-
- private:
-  Interface* GetInstance() {
-    rtc::CritScope cs(&crit_);
-    if (ref_count_ == 0) {
-      if (!SetupInstance()) {
-        LOG(LS_VERBOSE) << "Failed to setup instance";
-        return NULL;
-      }
-      ASSERT(instance_.get() != NULL);
-    }
-    ++ref_count_;
-
-    LOG(LS_VERBOSE) << "Number of references: " << ref_count_;
-    return instance_.get();
-  }
-
-  void ReleaseInstance() {
-    rtc::CritScope cs(&crit_);
-    ASSERT(ref_count_ > 0);
-    ASSERT(instance_.get() != NULL);
-    --ref_count_;
-    LOG(LS_VERBOSE) << "Number of references: " << ref_count_;
-    if (ref_count_ == 0) {
-      CleanupInstance();
-    }
-  }
-
-  CriticalSection crit_;
-  int ref_count_;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(ReferenceCountedSingletonFactory);
-};
-
-template <typename Interface>
-class rcsf_ptr {
- public:
-  // Create a pointer that uses the factory to get the instance.
-  // This is lazy - it won't generate the instance until it is requested.
-  explicit rcsf_ptr(ReferenceCountedSingletonFactory<Interface>* factory)
-      : instance_(NULL),
-        factory_(factory) {
-  }
-
-  ~rcsf_ptr() {
-    release();
-  }
-
-  Interface& operator*() {
-    EnsureAcquired();
-    return *instance_;
-  }
-
-  Interface* operator->() {
-    EnsureAcquired();
-    return instance_;
-  }
-
-  // Gets the pointer, creating the singleton if necessary. May return NULL if
-  // creation failed.
-  Interface* get() {
-    Acquire();
-    return instance_;
-  }
-
-  // Set instance to NULL and tell the factory we aren't using the instance
-  // anymore.
-  void release() {
-    if (instance_) {
-      instance_ = NULL;
-      factory_->ReleaseInstance();
-    }
-  }
-
-  // Lets us know whether instance is valid or not right now.
-  // Even though attempts to use the instance will automatically create it, it
-  // is advisable to check this because creation can fail.
-  bool valid() const {
-    return instance_ != NULL;
-  }
-
-  // Returns the factory that this pointer is using.
-  ReferenceCountedSingletonFactory<Interface>* factory() const {
-    return factory_;
-  }
-
- private:
-  void EnsureAcquired() {
-    Acquire();
-    ASSERT(instance_ != NULL);
-  }
-
-  void Acquire() {
-    // Since we're getting a singleton back, acquire is a noop if instance is
-    // already populated.
-    if (!instance_) {
-      instance_ = factory_->GetInstance();
-    }
-  }
-
-  Interface* instance_;
-  ReferenceCountedSingletonFactory<Interface>* factory_;
-
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(rcsf_ptr);
-};
-
-};  // namespace rtc
-
-#endif  // WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_