admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete referencecountedsingletonfactory.h.

Browse Source 
Unused since cl https://codereview.webrtc.org/1715043002

BUG=webrtc:6424

Review-Url: https://codereview.webrtc.org/2368123003
Cr-Commit-Position: refs/heads/master@{#14501}
This commit is contained in:
nisse 2016-10-04 07:21:49 -07:00 committed by Commit bot
parent 085ec0e4b1
commit cacee524c1
5 changed files with 0 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/BUILD.gn
View File

@ -381,7 +381,6 @@ if (rtc_include_tests) {
"base/rate_statistics_unittest.cc",
"base/ratelimiter_unittest.cc",
"base/ratetracker_unittest.cc",
"base/referencecountedsingletonfactory_unittest.cc",
"base/rollingaccumulator_unittest.cc",
"base/rtccertificate_unittest.cc",
"base/rtccertificategenerator_unittest.cc",

1
webrtc/base/BUILD.gn
View File

@ -468,7 +468,6 @@ rtc_static_library("rtc_base") {
"profiler.h",
"proxyserver.cc",
"proxyserver.h",
"referencecountedsingletonfactory.h",
"rollingaccumulator.h",
"scopedptrcollection.h",
"sslconfig.h",

1
webrtc/base/base.gyp
View File

@ -429,7 +429,6 @@
'profiler.h',
'proxyserver.cc',
'proxyserver.h',
'referencecountedsingletonfactory.h',
'rollingaccumulator.h',
'scopedptrcollection.h',
'sslconfig.h',

159
webrtc/base/referencecountedsingletonfactory.h
View File

@ -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_

132
webrtc/base/referencecountedsingletonfactory_unittest.cc
View File

@ -1,132 +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.
*/
#include "webrtc/base/gunit.h"
#include "webrtc/base/referencecountedsingletonfactory.h"
namespace rtc {
class MyExistenceWatcher {
public:
MyExistenceWatcher() { create_called_ = true; }
~MyExistenceWatcher() { delete_called_ = true; }
static bool create_called_;
static bool delete_called_;
};
bool MyExistenceWatcher::create_called_ = false;
bool MyExistenceWatcher::delete_called_ = false;
class TestReferenceCountedSingletonFactory :
public ReferenceCountedSingletonFactory<MyExistenceWatcher> {
protected:
virtual bool SetupInstance() {
instance_.reset(new MyExistenceWatcher());
return true;
}
virtual void CleanupInstance() {
instance_.reset();
}
};
static void DoCreateAndGoOutOfScope(
ReferenceCountedSingletonFactory<MyExistenceWatcher> *factory) {
rcsf_ptr<MyExistenceWatcher> ptr(factory);
ptr.get();
// and now ptr should go out of scope.
}
TEST(ReferenceCountedSingletonFactory, ZeroReferenceCountCausesDeletion) {
TestReferenceCountedSingletonFactory factory;
MyExistenceWatcher::delete_called_ = false;
DoCreateAndGoOutOfScope(&factory);
EXPECT_TRUE(MyExistenceWatcher::delete_called_);
}
TEST(ReferenceCountedSingletonFactory, NonZeroReferenceCountDoesNotDelete) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> ptr(&factory);
ptr.get();
MyExistenceWatcher::delete_called_ = false;
DoCreateAndGoOutOfScope(&factory);
EXPECT_FALSE(MyExistenceWatcher::delete_called_);
}
TEST(ReferenceCountedSingletonFactory, ReturnedPointersReferToSameThing) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> one(&factory), two(&factory);
EXPECT_EQ(one.get(), two.get());
}
TEST(ReferenceCountedSingletonFactory, Release) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> one(&factory);
one.get();
MyExistenceWatcher::delete_called_ = false;
one.release();
EXPECT_TRUE(MyExistenceWatcher::delete_called_);
}
TEST(ReferenceCountedSingletonFactory, GetWithoutRelease) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> one(&factory);
one.get();
MyExistenceWatcher::create_called_ = false;
one.get();
EXPECT_FALSE(MyExistenceWatcher::create_called_);
}
TEST(ReferenceCountedSingletonFactory, GetAfterRelease) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> one(&factory);
MyExistenceWatcher::create_called_ = false;
one.release();
one.get();
EXPECT_TRUE(MyExistenceWatcher::create_called_);
}
TEST(ReferenceCountedSingletonFactory, MultipleReleases) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> one(&factory), two(&factory);
MyExistenceWatcher::create_called_ = false;
MyExistenceWatcher::delete_called_ = false;
one.release();
EXPECT_FALSE(MyExistenceWatcher::delete_called_);
one.release();
EXPECT_FALSE(MyExistenceWatcher::delete_called_);
one.release();
EXPECT_FALSE(MyExistenceWatcher::delete_called_);
one.get();
EXPECT_TRUE(MyExistenceWatcher::create_called_);
}
TEST(ReferenceCountedSingletonFactory, Existentialism) {
TestReferenceCountedSingletonFactory factory;
rcsf_ptr<MyExistenceWatcher> one(&factory);
MyExistenceWatcher::create_called_ = false;
MyExistenceWatcher::delete_called_ = false;
one.get();
EXPECT_TRUE(MyExistenceWatcher::create_called_);
one.release();
EXPECT_TRUE(MyExistenceWatcher::delete_called_);
}
} // namespace rtc