blob: 3c0f68147e463b33afc3976af36ca87593775f7c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
* Copyright (c) 2011 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_VOICE_ENGINE_CHANNEL_MANAGER_H
#define WEBRTC_VOICE_ENGINE_CHANNEL_MANAGER_H
#include <vector>
#include "webrtc/base/constructormagic.h"
#include "webrtc/system_wrappers/interface/atomic32.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/typedefs.h"
namespace webrtc {
class Config;
namespace voe {
class Channel;
// Shared-pointer implementation for keeping track of Channels. The underlying
// shared instance will be dropped when no more ChannelOwners point to it.
//
// One common source of ChannelOwner instances are
// ChannelManager::CreateChannel() and ChannelManager::GetChannel(...).
// It has a similar use case to shared_ptr in C++11. Should this move to C++11
// in the future, this class should be replaced by exactly that.
//
// To access the underlying Channel, use .channel().
// IsValid() implements a convenience method as an alternative for checking
// whether the underlying pointer is NULL or not.
//
// Channel channel_owner = channel_manager.GetChannel(channel_id);
// if (channel_owner.IsValid())
// channel_owner.channel()->...;
//
class ChannelOwner {
public:
explicit ChannelOwner(Channel* channel);
ChannelOwner(const ChannelOwner& channel_owner);
~ChannelOwner();
ChannelOwner& operator=(const ChannelOwner& other);
Channel* channel() { return channel_ref_->channel.get(); }
bool IsValid() { return channel_ref_->channel.get() != NULL; }
private:
// Shared instance of a Channel. Copying ChannelOwners increase the reference
// count and destroying ChannelOwners decrease references. Channels are
// deleted when no references to them are held.
struct ChannelRef {
ChannelRef(Channel* channel);
const scoped_ptr<Channel> channel;
Atomic32 ref_count;
};
ChannelRef* channel_ref_;
};
class ChannelManager {
public:
ChannelManager(uint32_t instance_id, const Config& config);
// Upon construction of an Iterator it will grab a copy of the channel list of
// the ChannelManager. The iteration will then occur over this state, not the
// current one of the ChannelManager. As the Iterator holds its own references
// to the Channels, they will remain valid even if they are removed from the
// ChannelManager.
class Iterator {
public:
explicit Iterator(ChannelManager* channel_manager);
Channel* GetChannel();
bool IsValid();
void Increment();
private:
size_t iterator_pos_;
std::vector<ChannelOwner> channels_;
DISALLOW_COPY_AND_ASSIGN(Iterator);
};
// CreateChannel will always return a valid ChannelOwner instance. The channel
// is created either based on internal configuration, i.e. |config_|, by
// calling CreateChannel(), or using and external configuration
// |external_config| if the overloaded method
// CreateChannel(const Config& external_config) is called.
ChannelOwner CreateChannel();
ChannelOwner CreateChannel(const Config& external_config);
// ChannelOwner.channel() will be NULL if channel_id is invalid or no longer
// exists. This should be checked with ChannelOwner::IsValid().
ChannelOwner GetChannel(int32_t channel_id);
void GetAllChannels(std::vector<ChannelOwner>* channels);
void DestroyChannel(int32_t channel_id);
void DestroyAllChannels();
size_t NumOfChannels() const;
private:
// Create a channel given a configuration, |config|.
ChannelOwner CreateChannelInternal(const Config& config);
uint32_t instance_id_;
Atomic32 last_channel_id_;
scoped_ptr<CriticalSectionWrapper> lock_;
std::vector<ChannelOwner> channels_;
const Config& config_;
DISALLOW_COPY_AND_ASSIGN(ChannelManager);
};
} // namespace voe
} // namespace webrtc
#endif // WEBRTC_VOICE_ENGINE_CHANNEL_MANAGER_H
|
