Review URL: http://webrtc-codereview.appspot.com/315003
git-svn-id: http://libjingle.googlecode.com/svn/trunk@100 dd674b97-3498-5ee5-1854-bdd07cd0ff33
diff --git a/CHANGELOG b/CHANGELOG
index 16d7ed6..cacbc90 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,10 @@
Libjingle
+0.6.5 - Dec 12, 2011
+ - Add IPv6 support in SocketAddress.
+ - Change PeerConnectionFactory inteface.
+ - Bug fixes.
+
0.6.4 - Nov 30, 2011
- Branch app/webrtc to app/webrtcv1.
- Add more base unit tests.
diff --git a/talk/app/webrtc/peerconnectionfactory.cc b/talk/app/webrtc/peerconnectionfactory.cc
index 1b40c14..a3dac39 100644
--- a/talk/app/webrtc/peerconnectionfactory.cc
+++ b/talk/app/webrtc/peerconnectionfactory.cc
@@ -35,22 +35,18 @@
namespace webrtc {
PeerConnectionFactory::PeerConnectionFactory(
- cricket::PortAllocator* port_allocator,
cricket::MediaEngineInterface* media_engine,
cricket::DeviceManagerInterface* device_manager,
talk_base::Thread* worker_thread)
: initialized_(false),
- port_allocator_(port_allocator),
channel_manager_(new cricket::ChannelManager(media_engine,
device_manager,
worker_thread)) {
}
PeerConnectionFactory::PeerConnectionFactory(
- cricket::PortAllocator* port_allocator,
talk_base::Thread* worker_thread)
: initialized_(false),
- port_allocator_(port_allocator),
channel_manager_(new cricket::ChannelManager(worker_thread)) {
}
@@ -64,11 +60,12 @@
}
PeerConnection* PeerConnectionFactory::CreatePeerConnection(
+ cricket::PortAllocator* port_allocator,
talk_base::Thread* signaling_thread) {
PeerConnectionProxy* pc = NULL;
if (initialized_) {
pc = new PeerConnectionProxy(
- port_allocator_.get(), channel_manager_.get(), signaling_thread);
+ port_allocator, channel_manager_.get(), signaling_thread);
if (!pc->Init()) {
LOG(LERROR) << "Error in initializing PeerConnection";
delete pc;
diff --git a/talk/app/webrtc/peerconnectionfactory.h b/talk/app/webrtc/peerconnectionfactory.h
index 7c65e05..ea509d6 100644
--- a/talk/app/webrtc/peerconnectionfactory.h
+++ b/talk/app/webrtc/peerconnectionfactory.h
@@ -51,21 +51,20 @@
class PeerConnectionFactory {
public:
- PeerConnectionFactory(cricket::PortAllocator* port_allocator,
- cricket::MediaEngineInterface* media_engine,
+ PeerConnectionFactory(cricket::MediaEngineInterface* media_engine,
cricket::DeviceManagerInterface* device_manager,
talk_base::Thread* worker_thread);
- PeerConnectionFactory(cricket::PortAllocator* port_allocator,
- talk_base::Thread* worker_thread);
+ PeerConnectionFactory(talk_base::Thread* worker_thread);
virtual ~PeerConnectionFactory();
bool Initialize();
- PeerConnection* CreatePeerConnection(talk_base::Thread* signaling_thread);
+ PeerConnection* CreatePeerConnection(
+ cricket::PortAllocator* port_allocator,
+ talk_base::Thread* signaling_thread);
private:
bool initialized_;
- talk_base::scoped_ptr<cricket::PortAllocator> port_allocator_;
talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
};
diff --git a/talk/app/webrtc/webrtcsession_unittest.cc b/talk/app/webrtc/webrtcsession_unittest.cc
index 7a07614..85339c0 100644
--- a/talk/app/webrtc/webrtcsession_unittest.cc
+++ b/talk/app/webrtc/webrtcsession_unittest.cc
@@ -36,10 +36,10 @@
#include "talk/base/fakenetwork.h"
#include "talk/base/scoped_ptr.h"
#include "talk/base/thread.h"
+#include "talk/p2p/base/fakesession.h"
#include "talk/p2p/base/portallocator.h"
#include "talk/p2p/base/sessiondescription.h"
#include "talk/p2p/client/fakeportallocator.h"
-#include "talk/session/phone/fakesession.h"
#include "talk/session/phone/mediasessionclient.h"
class WebRtcSessionTest
diff --git a/talk/app/webrtcv1/peerconnectionfactory.cc b/talk/app/webrtcv1/peerconnectionfactory.cc
index ab2e0d5..7bf2f89 100644
--- a/talk/app/webrtcv1/peerconnectionfactory.cc
+++ b/talk/app/webrtcv1/peerconnectionfactory.cc
@@ -35,22 +35,18 @@
namespace webrtc {
PeerConnectionFactory::PeerConnectionFactory(
- cricket::PortAllocator* port_allocator,
cricket::MediaEngineInterface* media_engine,
cricket::DeviceManagerInterface* device_manager,
talk_base::Thread* worker_thread)
: initialized_(false),
- port_allocator_(port_allocator),
channel_manager_(new cricket::ChannelManager(media_engine,
device_manager,
worker_thread)) {
}
PeerConnectionFactory::PeerConnectionFactory(
- cricket::PortAllocator* port_allocator,
talk_base::Thread* worker_thread)
: initialized_(false),
- port_allocator_(port_allocator),
channel_manager_(new cricket::ChannelManager(worker_thread)) {
}
@@ -64,11 +60,12 @@
}
PeerConnection* PeerConnectionFactory::CreatePeerConnection(
+ cricket::PortAllocator* port_allocator,
talk_base::Thread* signaling_thread) {
PeerConnectionProxy* pc = NULL;
if (initialized_) {
pc = new PeerConnectionProxy(
- port_allocator_.get(), channel_manager_.get(), signaling_thread);
+ port_allocator, channel_manager_.get(), signaling_thread);
if (!pc->Init()) {
LOG(LERROR) << "Error in initializing PeerConnection";
delete pc;
diff --git a/talk/app/webrtcv1/peerconnectionfactory.h b/talk/app/webrtcv1/peerconnectionfactory.h
index 7c65e05..ea509d6 100644
--- a/talk/app/webrtcv1/peerconnectionfactory.h
+++ b/talk/app/webrtcv1/peerconnectionfactory.h
@@ -51,21 +51,20 @@
class PeerConnectionFactory {
public:
- PeerConnectionFactory(cricket::PortAllocator* port_allocator,
- cricket::MediaEngineInterface* media_engine,
+ PeerConnectionFactory(cricket::MediaEngineInterface* media_engine,
cricket::DeviceManagerInterface* device_manager,
talk_base::Thread* worker_thread);
- PeerConnectionFactory(cricket::PortAllocator* port_allocator,
- talk_base::Thread* worker_thread);
+ PeerConnectionFactory(talk_base::Thread* worker_thread);
virtual ~PeerConnectionFactory();
bool Initialize();
- PeerConnection* CreatePeerConnection(talk_base::Thread* signaling_thread);
+ PeerConnection* CreatePeerConnection(
+ cricket::PortAllocator* port_allocator,
+ talk_base::Thread* signaling_thread);
private:
bool initialized_;
- talk_base::scoped_ptr<cricket::PortAllocator> port_allocator_;
talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
};
diff --git a/talk/app/webrtcv1/webrtcsession_unittest.cc b/talk/app/webrtcv1/webrtcsession_unittest.cc
index c8940d6..2c23d6a 100644
--- a/talk/app/webrtcv1/webrtcsession_unittest.cc
+++ b/talk/app/webrtcv1/webrtcsession_unittest.cc
@@ -36,10 +36,10 @@
#include "talk/base/fakenetwork.h"
#include "talk/base/scoped_ptr.h"
#include "talk/base/thread.h"
+#include "talk/p2p/base/fakesession.h"
#include "talk/p2p/base/portallocator.h"
#include "talk/p2p/base/sessiondescription.h"
#include "talk/p2p/client/fakeportallocator.h"
-#include "talk/session/phone/fakesession.h"
#include "talk/session/phone/mediasessionclient.h"
class WebRtcSessionTest
diff --git a/talk/base/autodetectproxy.cc b/talk/base/autodetectproxy.cc
index f79926d..37faa4d 100644
--- a/talk/base/autodetectproxy.cc
+++ b/talk/base/autodetectproxy.cc
@@ -107,7 +107,7 @@
proxy().address.hostname(),
sizeof address_hostname);
- uint32 address_ip = proxy().address.ip();
+ IPAddress address_ip = proxy().address.ipaddr();
uint16 address_port = proxy().address.port();
diff --git a/talk/base/basicpacketsocketfactory.cc b/talk/base/basicpacketsocketfactory.cc
index 42721ba..d1da08e 100644
--- a/talk/base/basicpacketsocketfactory.cc
+++ b/talk/base/basicpacketsocketfactory.cc
@@ -157,7 +157,8 @@
} else {
// Otherwise, try to find a port in the provided range.
for (int port = min_port; ret < 0 && port <= max_port; ++port) {
- ret = socket->Bind(talk_base::SocketAddress(local_address.ip(), port));
+ ret = socket->Bind(talk_base::SocketAddress(local_address.ipaddr(),
+ port));
}
}
return ret;
diff --git a/talk/base/fakenetwork.h b/talk/base/fakenetwork.h
index 67df88a..c5ae4b6 100644
--- a/talk/base/fakenetwork.h
+++ b/talk/base/fakenetwork.h
@@ -52,7 +52,7 @@
void AddInterface(const SocketAddress& iface) {
// ensure a unique name for the interface
SocketAddress address("test" + talk_base::ToString(next_index_++), 0);
- address.SetResolvedIP(iface.ip());
+ address.SetResolvedIP(iface.ipaddr());
ifaces_.push_back(address);
DoUpdateNetworks();
}
@@ -89,7 +89,8 @@
std::vector<Network*> networks;
for (std::vector<SocketAddress>::iterator it = ifaces_.begin();
it != ifaces_.end(); ++it) {
- networks.push_back(new Network(it->hostname(), it->hostname(), it->ip()));
+ networks.push_back(new Network(it->hostname(), it->hostname(),
+ it->ipaddr()));
}
MergeNetworkList(networks, true);
}
diff --git a/talk/base/fileutils.cc b/talk/base/fileutils.cc
index 4504d29..7b0d348 100644
--- a/talk/base/fileutils.cc
+++ b/talk/base/fileutils.cc
@@ -154,15 +154,17 @@
#endif
}
-scoped_ptr<FilesystemInterface> Filesystem::default_filesystem_;
+FilesystemInterface* Filesystem::default_filesystem_ = NULL;
+
FilesystemInterface *Filesystem::EnsureDefaultFilesystem() {
- if (!default_filesystem_.get())
+ if (!default_filesystem_) {
#ifdef WIN32
- default_filesystem_.reset(new Win32Filesystem());
+ default_filesystem_ = new Win32Filesystem();
#else
- default_filesystem_.reset(new UnixFilesystem());
+ default_filesystem_ = new UnixFilesystem();
#endif
- return default_filesystem_.get();
+ }
+ return default_filesystem_;
}
bool FilesystemInterface::CopyFolder(const Pathname &old_path,
diff --git a/talk/base/fileutils.h b/talk/base/fileutils.h
index 644516d..186c963 100644
--- a/talk/base/fileutils.h
+++ b/talk/base/fileutils.h
@@ -285,18 +285,18 @@
class Filesystem {
public:
static FilesystemInterface *default_filesystem() {
- ASSERT(default_filesystem_.get() != NULL);
- return default_filesystem_.get();
+ ASSERT(default_filesystem_ != NULL);
+ return default_filesystem_;
}
static void set_default_filesystem(FilesystemInterface *filesystem) {
- default_filesystem_.reset(filesystem);
+ default_filesystem_ = filesystem;
}
static FilesystemInterface *swap_default_filesystem(
FilesystemInterface *filesystem) {
- FilesystemInterface *cur = default_filesystem_.release();
- default_filesystem_.reset(filesystem);
+ FilesystemInterface *cur = default_filesystem_;
+ default_filesystem_ = filesystem;
return cur;
}
@@ -425,7 +425,7 @@
}
private:
- static scoped_ptr<FilesystemInterface> default_filesystem_;
+ static FilesystemInterface* default_filesystem_;
static FilesystemInterface *EnsureDefaultFilesystem();
DISALLOW_IMPLICIT_CONSTRUCTORS(Filesystem);
@@ -455,4 +455,3 @@
} // namespace talk_base
#endif // TALK_BASE_FILEUTILS_H_
-
diff --git a/talk/base/firewallsocketserver.cc b/talk/base/firewallsocketserver.cc
index a99c72e..71385f8 100644
--- a/talk/base/firewallsocketserver.cc
+++ b/talk/base/firewallsocketserver.cc
@@ -177,11 +177,11 @@
const Rule& r = rules_[i];
if ((r.p != p) && (r.p != FP_ANY))
continue;
- if ((r.src.ip() != src.ip()) && !r.src.IsAny())
+ if ((r.src.ipaddr() != src.ipaddr()) && !r.src.IsAny())
continue;
if ((r.src.port() != src.port()) && (r.src.port() != 0))
continue;
- if ((r.dst.ip() != dst.ip()) && !r.dst.IsAny())
+ if ((r.dst.ipaddr() != dst.ipaddr()) && !r.dst.IsAny())
continue;
if ((r.dst.port() != dst.port()) && (r.dst.port() != 0))
continue;
diff --git a/talk/base/helpers.cc b/talk/base/helpers.cc
index 1abaa2d..855305e 100644
--- a/talk/base/helpers.cc
+++ b/talk/base/helpers.cc
@@ -205,8 +205,8 @@
// This round about way of creating a global RNG is to safe-guard against
// indeterminant static initialization order.
-scoped_ptr<RandomGenerator>& GetGlobalRng() {
- static scoped_ptr<RandomGenerator> g_rng(new SecureRandomGenerator());
+RandomGenerator*& GetGlobalRng() {
+ static RandomGenerator* g_rng = new SecureRandomGenerator();
return g_rng;
}
@@ -218,9 +218,9 @@
void SetRandomTestMode(bool test) {
if (!test) {
- GetGlobalRng().reset(new SecureRandomGenerator());
+ GetGlobalRng() = new SecureRandomGenerator();
} else {
- GetGlobalRng().reset(new TestRandomGenerator());
+ GetGlobalRng() = new TestRandomGenerator();
}
}
diff --git a/talk/base/macasyncsocket.cc b/talk/base/macasyncsocket.cc
index e31be57..4924333 100644
--- a/talk/base/macasyncsocket.cc
+++ b/talk/base/macasyncsocket.cc
@@ -328,9 +328,11 @@
}
if (res) {
- // Add this socket to the run loop
- source_ = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket_, 0);
+ // Add this socket to the run loop, at priority 1 so that it will be
+ // queued behind any pending signals.
+ source_ = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket_, 1);
res = (source_ != NULL);
+ if (!res) errno = EINVAL;
}
if (res) {
diff --git a/talk/base/macsocketserver.cc b/talk/base/macsocketserver.cc
index 154b83d..5b2ec03 100644
--- a/talk/base/macsocketserver.cc
+++ b/talk/base/macsocketserver.cc
@@ -41,6 +41,47 @@
ASSERT(found == 1);
}
+bool MacBaseSocketServer::SetPosixSignalHandler(int signum,
+ void (*handler)(int)) {
+ Dispatcher* dispatcher = signal_dispatcher();
+ if (!PhysicalSocketServer::SetPosixSignalHandler(signum, handler)) {
+ return false;
+ }
+
+ // Only register the FD once, when the first custom handler is installed.
+ if (!dispatcher && (dispatcher = signal_dispatcher())) {
+ CFFileDescriptorContext ctx = { 0 };
+ ctx.info = this;
+
+ CFFileDescriptorRef desc = CFFileDescriptorCreate(
+ kCFAllocatorDefault,
+ dispatcher->GetDescriptor(),
+ false,
+ &MacBaseSocketServer::FileDescriptorCallback,
+ &ctx);
+ if (!desc) {
+ return false;
+ }
+
+ CFFileDescriptorEnableCallBacks(desc, kCFFileDescriptorReadCallBack);
+ CFRunLoopSourceRef ref =
+ CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, desc, 0);
+
+ if (!ref) {
+ CFRelease(desc);
+ return false;
+ }
+
+ CFRunLoopAddSource(CFRunLoopGetCurrent(), ref, kCFRunLoopCommonModes);
+ CFRelease(desc);
+ CFRelease(ref);
+ }
+
+ return true;
+}
+
+// Used to disable socket events from waking our message queue when
+// process_io is false. Does not disable signal event handling though.
void MacBaseSocketServer::EnableSocketCallbacks(bool enable) {
for (std::set<MacAsyncSocket*>::iterator it = sockets().begin();
it != sockets().end(); ++it) {
@@ -52,6 +93,21 @@
}
}
+void MacBaseSocketServer::FileDescriptorCallback(CFFileDescriptorRef fd,
+ CFOptionFlags flags,
+ void* context) {
+ MacBaseSocketServer* this_ss =
+ reinterpret_cast<MacBaseSocketServer*>(context);
+ ASSERT(this_ss);
+ Dispatcher* signal_dispatcher = this_ss->signal_dispatcher();
+ ASSERT(signal_dispatcher);
+
+ signal_dispatcher->OnPreEvent(DE_READ);
+ signal_dispatcher->OnEvent(DE_READ, 0);
+ CFFileDescriptorEnableCallBacks(fd, kCFFileDescriptorReadCallBack);
+}
+
+
///////////////////////////////////////////////////////////////////////////////
// MacCFSocketServer
///////////////////////////////////////////////////////////////////////////////
@@ -225,6 +281,9 @@
// MacCarbonAppSocketServer
///////////////////////////////////////////////////////////////////////////////
+// Carbon is deprecated for x64. Switch to Cocoa
+#if !defined(__x86_64__)
+
MacCarbonAppSocketServer::MacCarbonAppSocketServer()
: event_queue_(GetCurrentEventQueue()) {
// Install event handler
@@ -296,6 +355,7 @@
}
ReleaseEvent(wake_up);
}
+#endif
///////////////////////////////////////////////////////////////////////////////
// MacNotificationsSocketServer
diff --git a/talk/base/macsocketserver.h b/talk/base/macsocketserver.h
index 6a4a729..53118b8 100644
--- a/talk/base/macsocketserver.h
+++ b/talk/base/macsocketserver.h
@@ -31,6 +31,9 @@
void RegisterSocket(MacAsyncSocket* socket);
void UnregisterSocket(MacAsyncSocket* socket);
+ // PhysicalSocketServer Overrides
+ virtual bool SetPosixSignalHandler(int signum, void (*handler)(int));
+
protected:
void EnableSocketCallbacks(bool enable);
const std::set<MacAsyncSocket*>& sockets() {
@@ -38,6 +41,10 @@
}
private:
+ static void FileDescriptorCallback(CFFileDescriptorRef ref,
+ CFOptionFlags flags,
+ void* context);
+
std::set<MacAsyncSocket*> sockets_;
};
diff --git a/talk/base/nat_unittest.cc b/talk/base/nat_unittest.cc
index 3a2c778..a7fc3b1 100644
--- a/talk/base/nat_unittest.cc
+++ b/talk/base/nat_unittest.cc
@@ -195,7 +195,9 @@
SocketAddress int_addr("127.0.0.1", 0);
std::string ext_ip1 = "127.0.0.1";
- std::string ext_ip2 = SocketAddress::IPToString(networks[0]->ip());
+ std::string ext_ip2 = networks[0]->ip().ToString();
+
+ LOG(LS_INFO) << "selected ip " << ext_ip2;
SocketAddress ext_addrs[4] = {
SocketAddress(ext_ip1, 0),
@@ -226,11 +228,11 @@
new PhysicalSocketServer());
SocketAddress int_addr, ext_addrs[4];
- int_addr.SetIP(int_vss->GetNextIP());
- ext_addrs[0].SetIP(ext_vss->GetNextIP());
- ext_addrs[1].SetIP(ext_vss->GetNextIP());
- ext_addrs[2].SetIP(ext_addrs[0].ip());
- ext_addrs[3].SetIP(ext_addrs[1].ip());
+ int_addr.SetIP(IPAddress(int_vss->GetNextIP()));
+ ext_addrs[0].SetIP(IPAddress(ext_vss->GetNextIP()));
+ ext_addrs[1].SetIP(IPAddress(ext_vss->GetNextIP()));
+ ext_addrs[2].SetIP(ext_addrs[0].ipaddr());
+ ext_addrs[3].SetIP(ext_addrs[1].ipaddr());
TestBindings(int_vss, int_addr, ext_vss, ext_addrs);
TestFilters(int_vss, int_addr, ext_vss, ext_addrs);
diff --git a/talk/base/network.cc b/talk/base/network.cc
index d6ecbbf..9d1a83d 100644
--- a/talk/base/network.cc
+++ b/talk/base/network.cc
@@ -166,7 +166,7 @@
struct sockaddr_in* inaddr =
reinterpret_cast<struct sockaddr_in*>(&ptr->ifr_ifru.ifru_addr);
if (inaddr->sin_family == AF_INET) {
- uint32 ip = ntohl(inaddr->sin_addr.s_addr);
+ IPAddress ip(inaddr->sin_addr);
scoped_ptr<Network> network(
new Network(ptr->ifr_name, ptr->ifr_name, ip));
network->set_ignored(IsIgnoredNetwork(*network));
@@ -201,6 +201,8 @@
scoped_array<char> buf(new char[len]);
IP_ADAPTER_INFO *infos = reinterpret_cast<IP_ADAPTER_INFO *>(buf.get());
+ // TODO: GetAdaptersInfo is IPv4 only. Replace with GetAddressesInfo when
+ // IPv6 support is needed in Network.
DWORD ret = GetAdaptersInfo(infos, &len);
if (ret != NO_ERROR) {
LOG_ERR_EX(LS_ERROR, ret) << "GetAdaptersInfo failed";
@@ -225,12 +227,13 @@
name = ost.str();
count++;
#endif // !_DEBUG
-
- scoped_ptr<Network> network(new Network(name, info->Description,
- SocketAddress::StringToIP(info->IpAddressList.IpAddress.String)));
- network->set_ignored(IsIgnoredNetwork(*network));
- if (include_ignored || !network->ignored()) {
- networks->push_back(network.release());
+ IPAddress ip;
+ if (IPFromString(info->IpAddressList.IpAddress.String, &ip)) {
+ scoped_ptr<Network> network(new Network(name, info->Description, ip));
+ network->set_ignored(IsIgnoredNetwork(*network));
+ if (include_ignored || !network->ignored()) {
+ networks->push_back(network.release());
+ }
}
}
@@ -257,7 +260,10 @@
#endif
// Ignore any networks with a 0.x.y.z IP
- return (network.ip() < 0x01000000);
+ if (network.ip().family() == AF_INET) {
+ return (network.ip().v4AddressAsHostOrderInteger() < 0x01000000);
+ }
+ return false;
}
void BasicNetworkManager::StartUpdating() {
@@ -312,7 +318,8 @@
}
}
-Network::Network(const std::string& name, const std::string& desc, uint32 ip)
+Network::Network(const std::string& name, const std::string& desc,
+ const IPAddress& ip)
: name_(name), description_(desc), ip_(ip), ignored_(false),
uniform_numerator_(0), uniform_denominator_(0),
exponential_numerator_(0), exponential_denominator_(0) {
@@ -323,7 +330,7 @@
// Print out the first space-terminated token of the network desc, plus
// the IP address.
ss << "Net[" << description_.substr(0, description_.find(' '))
- << ":" << SocketAddress::IPToString(ip_) << "]";
+ << ":" << ip_ << "]";
return ss.str();
}
diff --git a/talk/base/network.h b/talk/base/network.h
index 10b4bec..bb5f15d 100644
--- a/talk/base/network.h
+++ b/talk/base/network.h
@@ -34,6 +34,7 @@
#include <vector>
#include "talk/base/basictypes.h"
+#include "talk/base/ipaddress.h"
#include "talk/base/messagehandler.h"
#include "talk/base/sigslot.h"
@@ -135,7 +136,10 @@
// Represents a Unix-type network interface, with a name and single address.
class Network {
public:
- Network(const std::string& name, const std::string& description, uint32 ip);
+ Network() : ip_(INADDR_ANY) {}
+
+ Network(const std::string& name, const std::string& description,
+ const IPAddress& ip);
// Returns the index of this network. This is considered the primary key
// that identifies each network.
@@ -146,8 +150,8 @@
const std::string& description() const { return description_; }
// Identifies the current IP address used by this network.
- uint32 ip() const { return ip_; }
- void set_ip(uint32 ip) { ip_ = ip; }
+ const IPAddress& ip() const { return ip_; }
+ void set_ip(const IPAddress& ip) { ip_ = ip; }
// Indicates whether this network should be ignored, perhaps because
// the IP is 0, or the interface is one we know is invalid.
@@ -162,7 +166,7 @@
std::string name_;
std::string description_;
- uint32 ip_;
+ IPAddress ip_;
bool ignored_;
SessionList sessions_;
double uniform_numerator_;
diff --git a/talk/base/network_unittest.cc b/talk/base/network_unittest.cc
index 4bec4a3..d48abbb 100644
--- a/talk/base/network_unittest.cc
+++ b/talk/base/network_unittest.cc
@@ -32,9 +32,11 @@
namespace talk_base {
// A network that should not be ignored.
-static const Network kNetwork1("test1", "Test Network Adapter 1", 0x12345678);
+static const Network kNetwork1("test1", "Test Network Adapter 1",
+ IPAddress(0x12345678));
// A network that should be ignored (IP is 0.1.0.4).
-static const Network kNetwork2("test2", "Test Network Adapter 2", 0x00010004);
+static const Network kNetwork2("test2", "Test Network Adapter 2",
+ IPAddress(0x00010004));
class NetworkTest : public testing::Test, public sigslot::has_slots<> {
public:
@@ -56,6 +58,13 @@
return BasicNetworkManager::IsIgnoredNetwork(network);
}
+ NetworkManager::NetworkList GetNetworks(
+ const BasicNetworkManager& network_manager, bool include_ignored) {
+ NetworkManager::NetworkList list;
+ network_manager.CreateNetworks(include_ignored, &list);
+ return list;
+ }
+
protected:
bool callback_called_;
};
@@ -64,7 +73,7 @@
TEST_F(NetworkTest, TestNetworkConstruct) {
EXPECT_EQ("test1", kNetwork1.name());
EXPECT_EQ("Test Network Adapter 1", kNetwork1.description());
- EXPECT_EQ(0x12345678U, kNetwork1.ip());
+ EXPECT_EQ(IPAddress(0x12345678U), kNetwork1.ip());
EXPECT_FALSE(kNetwork1.ignored());
}
@@ -74,6 +83,41 @@
EXPECT_TRUE(IsIgnoredNetwork(kNetwork2));
}
+TEST_F(NetworkTest, TestCreateNetworks) {
+ BasicNetworkManager manager;
+ NetworkManager::NetworkList result = GetNetworks(manager, true);
+ // We should be able to bind to any addresses we find.
+ // (Excluding IPv6 link-local for now, as we don't (yet) record scope ids.)
+ NetworkManager::NetworkList::iterator it;
+ for (it = result.begin();
+ it != result.end();
+ ++it) {
+ sockaddr_storage storage;
+ memset(&storage, 0, sizeof(storage));
+ IPAddress ip = (*it)->ip();
+ // This condition excludes FE80::/16, i.e. IPv6 link-local addresses. These
+ // require their scope id to be known. Remove when scope ids are supported.
+ if (!(ip.family() == AF_INET6 && IPIsPrivate(ip) && !IPIsLoopback(ip))) {
+ SocketAddress bindaddress(ip, 0);
+ // TODO: Make this use talk_base::AsyncSocket once it supports IPv6.
+ int fd = socket(ip.family(), SOCK_STREAM, IPPROTO_TCP);
+ if (fd > 0) {
+ size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
+ EXPECT_GE(ipsize, 0U);
+ int success = ::bind(fd,
+ reinterpret_cast<sockaddr*>(&storage),
+ ipsize);
+ EXPECT_EQ(0, success);
+#ifdef WIN32
+ closesocket(fd);
+#else
+ close(fd);
+#endif
+ }
+ }
+ }
+}
+
// Test that UpdateNetworks succeeds.
TEST_F(NetworkTest, TestUpdateNetworks) {
BasicNetworkManager manager;
diff --git a/talk/base/physicalsocketserver.cc b/talk/base/physicalsocketserver.cc
index f18e4ae..10d534f 100644
--- a/talk/base/physicalsocketserver.cc
+++ b/talk/base/physicalsocketserver.cc
@@ -1409,6 +1409,10 @@
return true;
}
+Dispatcher* PhysicalSocketServer::signal_dispatcher() {
+ return signal_dispatcher_.get();
+}
+
bool PhysicalSocketServer::InstallSignal(int signum, void (*handler)(int)) {
struct sigaction act;
// It doesn't really matter what we set this mask to.
diff --git a/talk/base/physicalsocketserver.h b/talk/base/physicalsocketserver.h
index aeb8348..1b7a298 100644
--- a/talk/base/physicalsocketserver.h
+++ b/talk/base/physicalsocketserver.h
@@ -2,26 +2,26 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
- * 1. Redistributions of source code must retain the above copyright notice,
+ * 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. 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.
- * 3. The name of the author may not be used to endorse or promote products
+ * 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL THE AUTHOR 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
+ * 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.
*/
@@ -73,7 +73,7 @@
// A socket server that provides the real sockets of the underlying OS.
class PhysicalSocketServer : public SocketServer {
-public:
+ public:
PhysicalSocketServer();
virtual ~PhysicalSocketServer();
@@ -104,10 +104,13 @@
// Dispatching signals on multiple PhysicalSocketServers is not reliable.
// The signal mask is not modified. It is the caller's responsibily to
// maintain it as desired.
- bool SetPosixSignalHandler(int signum, void (*handler)(int));
+ virtual bool SetPosixSignalHandler(int signum, void (*handler)(int));
+
+ protected:
+ Dispatcher* signal_dispatcher();
#endif
-private:
+ private:
typedef std::vector<Dispatcher*> DispatcherList;
typedef std::vector<size_t*> IteratorList;
diff --git a/talk/base/proxydetect.cc b/talk/base/proxydetect.cc
index 66213ee..4bfae29 100644
--- a/talk/base/proxydetect.cc
+++ b/talk/base/proxydetect.cc
@@ -233,7 +233,9 @@
m = 0;
uint32 mask = (m == 0) ? 0 : (~0UL) << (32 - m);
SocketAddress addr(url.host(), 0);
- return !addr.IsUnresolved() && ((addr.ip() & mask) == (ip & mask));
+ // TODO: Support IPv6 proxyitems. This code block is IPv4 only anyway.
+ return !addr.IsUnresolved() &&
+ ((addr.ipaddr().v4AddressAsHostOrderInteger() & mask) == (ip & mask));
}
// .foo.com
diff --git a/talk/base/proxyserver.cc b/talk/base/proxyserver.cc
index 3cdf598..d764fd7 100644
--- a/talk/base/proxyserver.cc
+++ b/talk/base/proxyserver.cc
@@ -36,7 +36,7 @@
ProxyServer::ProxyServer(
SocketFactory* int_factory, const SocketAddress& int_addr,
SocketFactory* ext_factory, const SocketAddress& ext_ip)
- : ext_factory_(ext_factory), ext_ip_(ext_ip.ip(), 0), // strip off any port
+ : ext_factory_(ext_factory), ext_ip_(ext_ip.ipaddr(), 0), // strip off port
server_socket_(int_factory->CreateAsyncSocket(SOCK_STREAM)) {
server_socket_->Bind(int_addr);
server_socket_->Listen(5);
diff --git a/talk/base/socket_unittest.cc b/talk/base/socket_unittest.cc
index d5c4a3b..8d5b3c5 100644
--- a/talk/base/socket_unittest.cc
+++ b/talk/base/socket_unittest.cc
@@ -37,7 +37,7 @@
namespace talk_base {
static const SocketAddress kEmptyAddr;
-static const SocketAddress kLoopbackAddr(INADDR_LOOPBACK, 0);
+static const SocketAddress kLoopbackAddr(IPAddress(INADDR_LOOPBACK), 0);
void SocketTest::TestConnect() {
testing::StreamSink sink;
@@ -153,7 +153,7 @@
// Attempt connect to a non-existent socket.
// We don't connect to the server socket created above, since on
// MacOS it takes about 75 seconds to get back an error!
- SocketAddress bogus_addr(INADDR_LOOPBACK, 65535);
+ SocketAddress bogus_addr(IPAddress(INADDR_LOOPBACK), 65535);
EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED).
@@ -664,7 +664,7 @@
SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
- EXPECT_EQ(addr4.ip(), addr2.ip());
+ EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
SocketAddress addr5;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
diff --git a/talk/base/socketaddress.cc b/talk/base/socketaddress.cc
index 71ed674..42143f5 100644
--- a/talk/base/socketaddress.cc
+++ b/talk/base/socketaddress.cc
@@ -362,7 +362,7 @@
return true;
}
-static void ToSockAddrStorageHelper(sockaddr_storage* addr,
+static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
IPAddress ip, int port) {
memset(addr, 0, sizeof(sockaddr_storage));
addr->ss_family = ip.family();
@@ -370,19 +370,22 @@
sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
saddr->sin6_addr = ip.ipv6_address();
saddr->sin6_port = HostToNetwork16(port);
- } else {
+ return sizeof(sockaddr_in6);
+ } else if (addr->ss_family == AF_INET) {
sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
saddr->sin_addr = ip.ipv4_address();
saddr->sin_port = HostToNetwork16(port);
+ return sizeof(sockaddr_in);
}
+ return 0;
}
-void SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
- ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_);
+size_t SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
+ return ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_);
}
-void SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
- ToSockAddrStorageHelper(addr, ip_, port_);
+size_t SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
+ return ToSockAddrStorageHelper(addr, ip_, port_);
}
std::string SocketAddress::IPToString(uint32 ip_as_host_order_integer) {
@@ -437,27 +440,6 @@
return "";
}
-bool SocketAddress::GetLocalIPs(std::vector<uint32>& ips) {
- ips.clear();
-
- const std::string hostname = GetHostname();
- if (hostname.empty())
- return false;
-
- int errcode;
- if (hostent* pHost = SafeGetHostByName(hostname.c_str(), &errcode)) {
- for (size_t i = 0; pHost->h_addr_list[i]; ++i) {
- uint32 ip =
- NetworkToHost32(*reinterpret_cast<uint32 *>(pHost->h_addr_list[i]));
- ips.push_back(ip);
- }
- FreeHostEnt(pHost);
- return !ips.empty();
- }
- LOG(LS_ERROR) << "gethostbyname err: " << errcode;
- return false;
-}
-
bool SocketAddress::GetLocalIPs(std::vector<IPAddress>* ips) {
if (!ips) {
return false;
diff --git a/talk/base/socketaddress.h b/talk/base/socketaddress.h
index 2272b53..3ebf556 100644
--- a/talk/base/socketaddress.h
+++ b/talk/base/socketaddress.h
@@ -191,8 +191,10 @@
// Dual stack version always sets family to AF_INET6, and maps v4 addresses.
// The other version doesn't map, and outputs an AF_INET address for
// v4 or mapped addresses, and AF_INET6 addresses for others.
- void ToDualStackSockAddrStorage(sockaddr_storage* saddr) const;
- void ToSockAddrStorage(sockaddr_storage* saddr) const;
+ // Returns the size of the sockaddr_in or sockaddr_in6 structure that is
+ // written to the sockaddr_storage, or zero on failure.
+ size_t ToDualStackSockAddrStorage(sockaddr_storage* saddr) const;
+ size_t ToSockAddrStorage(sockaddr_storage* saddr) const;
// Converts the IP address given in 'compact form' into dotted form.
// IP is given as an integer in host byte order. V4 only, to be deprecated.
@@ -210,16 +212,12 @@
static bool StringToIP(const std::string& str, IPAddress* ip);
// Get a list of the local machine's ip addresses.
- // TODO: Deprecate this function.
- static bool GetLocalIPs(std::vector<uint32>& ips);
+ // TODO: Move to nethelpers or similar (doesn't belong in socketaddress).
+ static bool GetLocalIPs(std::vector<IPAddress>* ips);
private:
// Get local machine's hostname.
static std::string GetHostname();
- // Get a list of the local machine's ip addresses.
- // TODO: Remove this (and the other GetLocalIPs method).
- static bool GetLocalIPs(std::vector<IPAddress>* ips);
-
std::string hostname_;
IPAddress ip_;
uint16 port_;
diff --git a/talk/base/socketaddress_unittest.cc b/talk/base/socketaddress_unittest.cc
index d19c723..fcfd89c 100644
--- a/talk/base/socketaddress_unittest.cc
+++ b/talk/base/socketaddress_unittest.cc
@@ -50,16 +50,16 @@
TEST(SocketAddressTest, TestDefaultCtor) {
SocketAddress addr;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(0, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("0.0.0.0:0", addr.ToString());
}
TEST(SocketAddressTest, TestIPPortCtor) {
- SocketAddress addr(0x01020304, 5678);
+ SocketAddress addr(IPAddress(0x01020304), 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -68,7 +68,7 @@
TEST(SocketAddressTest, TestIPv4StringPortCtor) {
SocketAddress addr("1.2.3.4", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -89,7 +89,7 @@
// inet_addr doesn't handle this address properly.
SocketAddress addr("255.255.255.255", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0xFFFFFFFFU, addr.ip());
+ EXPECT_EQ(IPAddress(0xFFFFFFFFU), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("255.255.255.255", addr.hostname());
EXPECT_EQ("255.255.255.255:5678", addr.ToString());
@@ -98,7 +98,7 @@
TEST(SocketAddressTest, TestHostnamePortCtor) {
SocketAddress addr("a.b.com", 5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -108,7 +108,7 @@
SocketAddress from("1.2.3.4", 5678);
SocketAddress addr(from);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -116,49 +116,49 @@
TEST(SocketAddressTest, TestAssign) {
SocketAddress from("1.2.3.4", 5678);
- SocketAddress addr(0x88888888, 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr = from;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPPort) {
- SocketAddress addr(0x88888888, 9999);
- addr.SetIP(0x01020304);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
+ addr.SetIP(IPAddress(0x01020304));
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromString) {
- SocketAddress addr(0x88888888, 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("1.2.3.4");
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromHostname) {
- SocketAddress addr(0x88888888, 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("a.b.com");
addr.SetPort(5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
- addr.SetResolvedIP(0x01020304);
+ addr.SetResolvedIP(IPAddress(0x01020304));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
}
@@ -167,7 +167,7 @@
SocketAddress addr;
EXPECT_TRUE(addr.FromString("1.2.3.4:5678"));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -186,7 +186,7 @@
SocketAddress addr;
EXPECT_TRUE(addr.FromString("a.b.com:5678"));
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(0U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_ANY), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -198,7 +198,7 @@
from.ToSockAddr(&addr_in);
EXPECT_TRUE(addr.FromSockAddr(addr_in));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -210,7 +210,7 @@
from.ToSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -239,7 +239,7 @@
EXPECT_TRUE(addr.Read_(buf, sizeof(buf)));
EXPECT_FALSE(addr.IsUnresolvedIP());
EXPECT_EQ(AF_INET, addr.ipaddr().family());
- EXPECT_EQ(0x01020304U, addr.ip());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -266,7 +266,7 @@
EXPECT_EQ(0, error);
EXPECT_FALSE(addr.IsUnresolvedIP());
EXPECT_TRUE(addr.IsLoopbackIP());
- EXPECT_EQ(0x7F000001U, addr.ip());
+ EXPECT_EQ(IPAddress(INADDR_LOOPBACK), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("localhost", addr.hostname());
EXPECT_EQ("localhost:5678", addr.ToString());
diff --git a/talk/base/task.cc b/talk/base/task.cc
index ad17438..c37797c 100644
--- a/talk/base/task.cc
+++ b/talk/base/task.cc
@@ -197,22 +197,15 @@
}
std::string Task::GetStateName(int state) const {
- static const std::string STR_BLOCKED("BLOCKED");
- static const std::string STR_INIT("INIT");
- static const std::string STR_START("START");
- static const std::string STR_DONE("DONE");
- static const std::string STR_ERROR("ERROR");
- static const std::string STR_RESPONSE("RESPONSE");
- static const std::string STR_HUH("??");
switch (state) {
- case STATE_BLOCKED: return STR_BLOCKED;
- case STATE_INIT: return STR_INIT;
- case STATE_START: return STR_START;
- case STATE_DONE: return STR_DONE;
- case STATE_ERROR: return STR_ERROR;
- case STATE_RESPONSE: return STR_RESPONSE;
+ case STATE_BLOCKED: return "BLOCKED";
+ case STATE_INIT: return "INIT";
+ case STATE_START: return "START";
+ case STATE_DONE: return "DONE";
+ case STATE_ERROR: return "ERROR";
+ case STATE_RESPONSE: return "RESPONSE";
}
- return STR_HUH;
+ return "??";
}
int Task::Process(int state) {
diff --git a/talk/base/virtualsocket_unittest.cc b/talk/base/virtualsocket_unittest.cc
index 6b2ae99..1c44fe7 100644
--- a/talk/base/virtualsocket_unittest.cc
+++ b/talk/base/virtualsocket_unittest.cc
@@ -56,7 +56,7 @@
};
TEST_F(VirtualSocketServerTest, basic) {
- SocketAddress addr1(0, 5000);
+ SocketAddress addr1(IPAddress(INADDR_ANY), 5000);
AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
socket->Bind(addr1);
addr1 = socket->GetLocalAddress();
@@ -80,7 +80,8 @@
SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
- EXPECT_EQ(addr4.ip(), addr2.ip() + 1);
+ EXPECT_EQ(addr4.ipaddr().v4AddressAsHostOrderInteger(),
+ addr2.ipaddr().v4AddressAsHostOrderInteger() + 1);
EXPECT_EQ(addr4.port(), addr2.port() + 1);
SocketAddress addr5;
@@ -618,8 +619,8 @@
TEST_F(VirtualSocketServerTest, bandwidth) {
AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
- ASSERT_EQ(0, send_socket->Bind(SocketAddress(0, 1000)));
- ASSERT_EQ(0, recv_socket->Bind(SocketAddress(0, 1000)));
+ ASSERT_EQ(0, send_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
+ ASSERT_EQ(0, recv_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
uint32 bandwidth = 64 * 1024;
@@ -653,8 +654,8 @@
AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
- ASSERT_EQ(0, send_socket->Bind(SocketAddress(0, 1000)));
- ASSERT_EQ(0, recv_socket->Bind(SocketAddress(0, 1000)));
+ ASSERT_EQ(0, send_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
+ ASSERT_EQ(0, recv_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
Thread* pthMain = Thread::Current();
diff --git a/talk/base/virtualsocketserver.cc b/talk/base/virtualsocketserver.cc
index 77614b2..c9c9f0b 100644
--- a/talk/base/virtualsocketserver.cc
+++ b/talk/base/virtualsocketserver.cc
@@ -608,7 +608,7 @@
const SocketAddress& addr) {
ASSERT(NULL != socket);
// Address must be completely specified at this point
- ASSERT(addr.ip() != 0);
+ ASSERT(!IPIsAny(addr.ipaddr()));
ASSERT(addr.port() != 0);
AddressMap::value_type entry(addr, socket);
@@ -618,8 +618,9 @@
int VirtualSocketServer::Bind(VirtualSocket* socket, SocketAddress* addr) {
ASSERT(NULL != socket);
- if (addr->ip() == 0) {
- addr->SetIP(GetNextIP());
+ if (IPIsAny(addr->ipaddr())) {
+ // TODO: An IPv6-ish version of this?
+ addr->SetIP(IPAddress(GetNextIP()));
}
if (addr->port() == 0) {
diff --git a/talk/examples/call/call_main.cc b/talk/examples/call/call_main.cc
index 748936b..077869c 100644
--- a/talk/examples/call/call_main.cc
+++ b/talk/examples/call/call_main.cc
@@ -216,6 +216,7 @@
"Disable or enable encryption: disable, enable, require.");
DEFINE_string(tls, "enable",
"Disable or enable tls: disable, enable, require.");
+ DEFINE_bool(allowplain, false, "Allow plain authentication");
DEFINE_bool(testserver, false, "Use test server");
DEFINE_int(portallocator, 0, "Filter out unwanted connection types.");
DEFINE_string(filterhost, NULL, "Filter out the host from all candidates.");
@@ -240,6 +241,7 @@
bool debug = FLAG_d;
std::string protocol = FLAG_protocol;
bool test_server = FLAG_testserver;
+ bool allow_plain = FLAG_allowplain;
std::string tls = FLAG_tls;
int32 portallocator_flags = FLAG_portallocator;
std::string pmuc_domain = FLAG_pmuc;
@@ -314,11 +316,9 @@
xcs.set_user(jid.node());
xcs.set_resource("call");
xcs.set_host(jid.domain());
-
- bool allow_plain = (test_server) ? true : false;
xcs.set_allow_plain(allow_plain);
- if(test_server || tls == "disable") {
+ if(tls == "disable") {
xcs.set_use_tls(buzz::TLS_DISABLED);
} else if (tls == "enable") {
xcs.set_use_tls(buzz::TLS_ENABLED);
@@ -332,6 +332,7 @@
if (test_server) {
pass.password() = jid.node();
xcs.set_allow_plain(true);
+ xcs.set_use_tls(buzz::TLS_DISABLED);
xcs.set_test_server_domain("google.com");
}
xcs.set_pass(talk_base::CryptString(pass));
diff --git a/talk/libjingle.scons b/talk/libjingle.scons
index 3d0463a..0ec1f59 100644
--- a/talk/libjingle.scons
+++ b/talk/libjingle.scons
@@ -233,6 +233,7 @@
"session/phone/mediaengine.cc",
"session/phone/mediamessages.cc",
"session/phone/mediamonitor.cc",
+ "session/phone/mediarecorder.cc",
"session/phone/mediasession.cc",
"session/phone/mediasessionclient.cc",
"session/phone/rtpdump.cc",
@@ -534,15 +535,23 @@
"srtp",
],
srcs = [
+ "session/phone/channel_unittest.cc",
+ "session/phone/channelmanager_unittest.cc",
"session/phone/codec_unittest.cc",
"session/phone/currentspeakermonitor_unittest.cc",
+ "session/phone/devicemanager_unittest.cc",
+ "session/phone/dummydevicemanager_unittest.cc",
"session/phone/filemediaengine_unittest.cc",
"session/phone/filevideocapturer_unittest.cc",
+ "session/phone/mediarecorder_unittest.cc",
"session/phone/mediamessages_unittest.cc",
"session/phone/mediasession_unittest.cc",
+ "session/phone/mediasessionclient_unittest.cc",
+ "session/phone/rtcpmuxfilter_unittest.cc",
"session/phone/rtpdump_unittest.cc",
"session/phone/rtputils_unittest.cc",
"session/phone/srtpfilter_unittest.cc",
+ "session/phone/ssrcmuxfilter_unittest.cc",
"session/phone/testutils.cc",
"session/phone/videocapturer_unittest.cc",
"session/phone/videocommon_unittest.cc",
diff --git a/talk/p2p/base/constants.cc b/talk/p2p/base/constants.cc
index 6123fc1..4d65f5b 100644
--- a/talk/p2p/base/constants.cc
+++ b/talk/p2p/base/constants.cc
@@ -104,7 +104,7 @@
const char NS_JINGLE_RTP[] = "urn:xmpp:jingle:apps:rtp:1";
const buzz::StaticQName QN_JINGLE_RTP_CONTENT =
{ NS_JINGLE_RTP, LN_DESCRIPTION };
-const buzz::StaticQName QN_JINGLE_SSRC = { NS_EMPTY, "ssrc" };
+const buzz::StaticQName QN_SSRC = { NS_EMPTY, "ssrc" };
const buzz::StaticQName QN_JINGLE_RTP_PAYLOADTYPE =
{ NS_JINGLE_RTP, LN_PAYLOADTYPE };
const buzz::StaticQName QN_JINGLE_RTP_BANDWIDTH =
@@ -202,40 +202,24 @@
const char STR_TERMINATE_UNKNOWN_ERROR[] = "unknown-error";
// Draft view and notify messages.
-const buzz::StaticQName QN_JINGLE_DRAFT_CONTENT_NAME =
- { cricket::NS_EMPTY, "name" };
const char STR_JINGLE_DRAFT_CONTENT_NAME_VIDEO[] = "video";
const char STR_JINGLE_DRAFT_CONTENT_NAME_AUDIO[] = "audio";
-const buzz::StaticQName QN_JINGLE_DRAFT_NOTIFY = { NS_JINGLE_DRAFT, "notify" };
-const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE = { NS_JINGLE_DRAFT, "source" };
-const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_NICK =
- { cricket::NS_EMPTY, "nick" };
-const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_NAME =
- { cricket::NS_EMPTY, "name" };
-const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_USAGE =
- { cricket::NS_EMPTY, "usage" };
-const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_STATE =
- { cricket::NS_EMPTY, "state" };
-const char STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED[] = "removed";
-const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_SSRC =
- { NS_JINGLE_DRAFT, "ssrc" };
+const buzz::StaticQName QN_NICK = { cricket::NS_EMPTY, "nick" };
+const buzz::StaticQName QN_TYPE = { cricket::NS_EMPTY, "type" };
const buzz::StaticQName QN_JINGLE_DRAFT_VIEW = { NS_JINGLE_DRAFT, "view" };
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_TYPE =
- { cricket::NS_EMPTY, "type" };
const char STR_JINGLE_DRAFT_VIEW_TYPE_NONE[] = "none";
const char STR_JINGLE_DRAFT_VIEW_TYPE_STATIC[] = "static";
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_SSRC =
- { cricket::NS_EMPTY, "ssrc" };
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS =
- { NS_JINGLE_DRAFT, "params" };
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH =
- { cricket::NS_EMPTY, "width" };
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT =
- { cricket::NS_EMPTY, "height" };
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE =
- { cricket::NS_EMPTY, "framerate" };
-const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE =
- { cricket::NS_EMPTY, "preference" };
+const buzz::StaticQName QN_JINGLE_DRAFT_PARAMS = { NS_JINGLE_DRAFT, "params" };
+const buzz::StaticQName QN_JINGLE_DRAFT_STREAMS = { NS_JINGLE_DRAFT, "streams" };
+const buzz::StaticQName QN_JINGLE_DRAFT_STREAM = { NS_JINGLE_DRAFT, "stream" };
+const buzz::StaticQName QN_DISPLAY = { cricket::NS_EMPTY, "display" };
+const buzz::StaticQName QN_CNAME = { cricket::NS_EMPTY, "cname" };
+const buzz::StaticQName QN_JINGLE_DRAFT_SSRC = { NS_JINGLE_DRAFT, "ssrc" };
+const buzz::StaticQName QN_JINGLE_DRAFT_SSRC_GROUP =
+ { NS_JINGLE_DRAFT, "ssrc-group" };
+const buzz::StaticQName QN_SEMANTICS = { cricket::NS_EMPTY, "semantics" };
+const buzz::StaticQName QN_JINGLE_LEGACY_NOTIFY = { NS_JINGLE_DRAFT, "notify" };
+const buzz::StaticQName QN_JINGLE_LEGACY_SOURCE = { NS_JINGLE_DRAFT, "source" };
// old stuff
#ifdef FEATURE_ENABLE_VOICEMAIL
diff --git a/talk/p2p/base/constants.h b/talk/p2p/base/constants.h
index 0a53345..0c84dd6 100644
--- a/talk/p2p/base/constants.h
+++ b/talk/p2p/base/constants.h
@@ -97,9 +97,6 @@
extern const buzz::StaticQName QN_CLOCKRATE;
extern const buzz::StaticQName QN_BITRATE;
extern const buzz::StaticQName QN_CHANNELS;
-extern const buzz::StaticQName QN_WIDTH;
-extern const buzz::StaticQName QN_HEIGHT;
-extern const buzz::StaticQName QN_FRAMERATE;
extern const buzz::StaticQName QN_PARAMETER;
extern const char LN_NAME[];
extern const char LN_VALUE[];
@@ -125,7 +122,7 @@
extern const char NS_JINGLE_RTP[];
extern const buzz::StaticQName QN_JINGLE_RTP_CONTENT;
-extern const buzz::StaticQName QN_JINGLE_SSRC;
+extern const buzz::StaticQName QN_SSRC;
extern const buzz::StaticQName QN_JINGLE_RTP_PAYLOADTYPE;
extern const buzz::StaticQName QN_JINGLE_RTP_BANDWIDTH;
extern const buzz::StaticQName QN_JINGLE_RTCP_MUX;
@@ -213,28 +210,26 @@
extern const char STR_TERMINATE_UNKNOWN_ERROR[];
// Draft view and notify messages.
-extern const buzz::StaticQName QN_JINGLE_DRAFT_CONTENT_NAME;
extern const char STR_JINGLE_DRAFT_CONTENT_NAME_VIDEO[];
extern const char STR_JINGLE_DRAFT_CONTENT_NAME_AUDIO[];
-extern const buzz::StaticQName QN_JINGLE_DRAFT_NOTIFY;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_NICK;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_NAME;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_USAGE;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_STATE;
-extern const char STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED[];
-extern const buzz::StaticQName QN_JINGLE_DRAFT_SOURCE_SSRC;
+extern const buzz::StaticQName QN_NICK;
+extern const buzz::StaticQName QN_TYPE;
extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_NAME;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_TYPE;
extern const char STR_JINGLE_DRAFT_VIEW_TYPE_NONE[];
extern const char STR_JINGLE_DRAFT_VIEW_TYPE_STATIC[];
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_SSRC;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE;
-extern const buzz::StaticQName QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_PARAMS;
+extern const buzz::StaticQName QN_WIDTH;
+extern const buzz::StaticQName QN_HEIGHT;
+extern const buzz::StaticQName QN_FRAMERATE;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_STREAM;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_STREAMS;
+extern const buzz::StaticQName QN_DISPLAY;
+extern const buzz::StaticQName QN_CNAME;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_SSRC;
+extern const buzz::StaticQName QN_JINGLE_DRAFT_SSRC_GROUP;
+extern const buzz::StaticQName QN_SEMANTICS;
+extern const buzz::StaticQName QN_JINGLE_LEGACY_NOTIFY;
+extern const buzz::StaticQName QN_JINGLE_LEGACY_SOURCE;
// old stuff
#ifdef FEATURE_ENABLE_VOICEMAIL
diff --git a/talk/p2p/base/p2ptransportchannel_unittest.cc b/talk/p2p/base/p2ptransportchannel_unittest.cc
index 109b04f..ae5ab62 100644
--- a/talk/p2p/base/p2ptransportchannel_unittest.cc
+++ b/talk/p2p/base/p2ptransportchannel_unittest.cc
@@ -384,9 +384,9 @@
} else if (config == BLOCK_ALL_BUT_OUTGOING_HTTP) {
// Block all TCP to/from the endpoint except 80/443 out
fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
- SocketAddress(0, 80));
+ SocketAddress(talk_base::IPAddress(INADDR_ANY), 80));
fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
- SocketAddress(0, 443));
+ SocketAddress(talk_base::IPAddress(INADDR_ANY), 443));
fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
kPublicAddrs[endpoint]);
} else if (config == PROXY_HTTPS) {
diff --git a/talk/p2p/base/parsing.cc b/talk/p2p/base/parsing.cc
index a54d379..f302956 100644
--- a/talk/p2p/base/parsing.cc
+++ b/talk/p2p/base/parsing.cc
@@ -91,6 +91,18 @@
return NULL;
}
+const buzz::XmlElement* GetXmlElement(const XmlElements& elems,
+ const buzz::QName& name) {
+ for (XmlElements::const_iterator iter = elems.begin();
+ iter != elems.end(); ++iter) {
+ const buzz::XmlElement* elem = *iter;
+ if (elem->Name() == name) {
+ return elem;
+ }
+ }
+ return NULL;
+}
+
bool RequireXmlChild(const buzz::XmlElement* parent,
const std::string& name,
const buzz::XmlElement** child,
@@ -120,6 +132,14 @@
}
}
+void AddXmlAttrIfNonEmpty(buzz::XmlElement* elem,
+ const buzz::QName name,
+ const std::string& value) {
+ if (!value.empty()) {
+ elem->AddAttr(name, value);
+ }
+}
+
void AddXmlChildren(buzz::XmlElement* parent,
const std::vector<buzz::XmlElement*>& children) {
for (std::vector<buzz::XmlElement*>::const_iterator iter = children.begin();
diff --git a/talk/p2p/base/parsing.h b/talk/p2p/base/parsing.h
index 7931431..589d9d7 100644
--- a/talk/p2p/base/parsing.h
+++ b/talk/p2p/base/parsing.h
@@ -112,6 +112,9 @@
const buzz::XmlElement* GetXmlChild(const buzz::XmlElement* parent,
const std::string& name);
+const buzz::XmlElement* GetXmlElement(const XmlElements& elems,
+ const buzz::QName& name);
+
bool RequireXmlChild(const buzz::XmlElement* parent,
const std::string& name,
const buzz::XmlElement** child,
@@ -120,6 +123,9 @@
const buzz::QName& name,
std::string* value,
ParseError* error);
+void AddXmlAttrIfNonEmpty(buzz::XmlElement* elem,
+ const buzz::QName name,
+ const std::string& value);
void AddXmlChildren(buzz::XmlElement* parent,
const std::vector<buzz::XmlElement*>& children);
void CopyXmlChildren(const buzz::XmlElement* source, buzz::XmlElement* dest);
diff --git a/talk/p2p/base/port.cc b/talk/p2p/base/port.cc
index bb4ab26..a016f63 100644
--- a/talk/p2p/base/port.cc
+++ b/talk/p2p/base/port.cc
@@ -126,7 +126,7 @@
Port::Port(talk_base::Thread* thread, const std::string& type,
talk_base::PacketSocketFactory* factory, talk_base::Network* network,
- uint32 ip, int min_port, int max_port)
+ const talk_base::IPAddress& ip, int min_port, int max_port)
: thread_(thread),
factory_(factory),
type_(type),
@@ -351,7 +351,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
addr_attr->SetPort(addr.port());
- addr_attr->SetIP(addr.ip());
+ addr_attr->SetIP(addr.ipaddr());
response.AddAttribute(addr_attr);
// Send the response message.
@@ -528,11 +528,8 @@
}
const Candidate& Connection::local_candidate() const {
- if (local_candidate_index_ < port_->candidates().size())
- return port_->candidates()[local_candidate_index_];
- ASSERT(false);
- static Candidate foo;
- return foo;
+ ASSERT(local_candidate_index_ < port_->candidates().size());
+ return port_->candidates()[local_candidate_index_];
}
void Connection::set_read_state(ReadState value) {
diff --git a/talk/p2p/base/port.h b/talk/p2p/base/port.h
index 8304146..396fce0 100644
--- a/talk/p2p/base/port.h
+++ b/talk/p2p/base/port.h
@@ -77,7 +77,7 @@
public:
Port(talk_base::Thread* thread, const std::string& type,
talk_base::PacketSocketFactory* factory, talk_base::Network* network,
- uint32 ip, int min_port, int max_port);
+ const talk_base::IPAddress& ip, int min_port, int max_port);
virtual ~Port();
// The thread on which this port performs its I/O.
@@ -241,7 +241,7 @@
talk_base::PacketSocketFactory* factory_;
std::string type_;
talk_base::Network* network_;
- uint32 ip_;
+ talk_base::IPAddress ip_;
int min_port_;
int max_port_;
uint32 generation_;
diff --git a/talk/p2p/base/port_unittest.cc b/talk/p2p/base/port_unittest.cc
index 4bb7fd3..1bdac3d 100644
--- a/talk/p2p/base/port_unittest.cc
+++ b/talk/p2p/base/port_unittest.cc
@@ -157,7 +157,8 @@
: main_(talk_base::Thread::Current()),
pss_(new talk_base::PhysicalSocketServer),
ss_(new talk_base::VirtualSocketServer(pss_.get())),
- ss_scope_(ss_.get()), network_("unittest", "unittest", 0),
+ ss_scope_(ss_.get()),
+ network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
socket_factory_(talk_base::Thread::Current()),
nat_factory1_(ss_.get(), kNatAddr1),
nat_factory2_(ss_.get(), kNatAddr2),
@@ -241,7 +242,8 @@
}
UDPPort* CreateUdpPort(const SocketAddress& addr,
PacketSocketFactory* socket_factory) {
- return UDPPort::Create(main_, socket_factory, &network_, addr.ip(), 0, 0);
+ return UDPPort::Create(main_, socket_factory, &network_,
+ addr.ipaddr(), 0, 0);
}
TCPPort* CreateTcpPort(const SocketAddress& addr) {
return CreateTcpPort(addr, &socket_factory_);
@@ -249,19 +251,19 @@
TCPPort* CreateTcpPort(const SocketAddress& addr,
PacketSocketFactory* socket_factory) {
return TCPPort::Create(main_, socket_factory, &network_,
- addr.ip(), 0, 0, true);
+ addr.ipaddr(), 0, 0, true);
}
StunPort* CreateStunPort(const SocketAddress& addr,
talk_base::PacketSocketFactory* factory) {
return StunPort::Create(main_, factory, &network_,
- addr.ip(), 0, 0, kStunAddr);
+ addr.ipaddr(), 0, 0, kStunAddr);
}
RelayPort* CreateRelayPort(const SocketAddress& addr,
ProtocolType int_proto, ProtocolType ext_proto) {
std::string user = talk_base::CreateRandomString(16);
std::string pass = talk_base::CreateRandomString(16);
RelayPort* port = RelayPort::Create(main_, &socket_factory_, &network_,
- addr.ip(), 0, 0, user, pass, "");
+ addr.ipaddr(), 0, 0, user, pass, "");
SocketAddress addrs[] =
{ kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr };
port->AddServerAddress(ProtocolAddress(addrs[int_proto], int_proto));
diff --git a/talk/p2p/base/relayport.cc b/talk/p2p/base/relayport.cc
index 76bd5ff..c6c066a 100644
--- a/talk/p2p/base/relayport.cc
+++ b/talk/p2p/base/relayport.cc
@@ -187,9 +187,9 @@
RelayPort::RelayPort(
talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
- const std::string& username, const std::string& password,
- const std::string& magic_cookie)
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port, const std::string& username,
+ const std::string& password, const std::string& magic_cookie)
: Port(thread, RELAY_PORT_TYPE, factory, network, ip, min_port, max_port),
ready_(false),
magic_cookie_(magic_cookie),
@@ -554,7 +554,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
- addr_attr->SetIP(addr.ip());
+ addr_attr->SetIP(addr.ipaddr());
addr_attr->SetPort(addr.port());
request.AddAttribute(addr_attr);
@@ -702,7 +702,7 @@
return;
}
- talk_base::SocketAddress remote_addr2(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress remote_addr2(addr_attr->ipaddr(), addr_attr->port());
const StunByteStringAttribute* data_attr = msg.GetByteString(STUN_ATTR_DATA);
if (!data_attr) {
@@ -764,7 +764,7 @@
} else if (addr_attr->family() != 1) {
LOG(INFO) << "Mapped address has bad family";
} else {
- talk_base::SocketAddress addr(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
entry_->OnConnect(addr, connection_);
}
diff --git a/talk/p2p/base/relayport.h b/talk/p2p/base/relayport.h
index 62bb758..2137606 100644
--- a/talk/p2p/base/relayport.h
+++ b/talk/p2p/base/relayport.h
@@ -55,9 +55,9 @@
// RelayPort doesn't yet do anything fancy in the ctor.
static RelayPort* Create(
talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
- const std::string& username, const std::string& password,
- const std::string& magic_cookie) {
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port, const std::string& username,
+ const std::string& password, const std::string& magic_cookie) {
return new RelayPort(thread, factory, network, ip, min_port, max_port,
username, password, magic_cookie);
}
@@ -85,9 +85,9 @@
protected:
RelayPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network*, uint32 ip, int min_port, int max_port,
- const std::string& username, const std::string& password,
- const std::string& magic_cookie);
+ talk_base::Network*, const talk_base::IPAddress& ip,
+ int min_port, int max_port, const std::string& username,
+ const std::string& password, const std::string& magic_cookie);
bool Init();
void SetReady();
diff --git a/talk/p2p/base/relayport_unittest.cc b/talk/p2p/base/relayport_unittest.cc
index 67fb238..688e635 100644
--- a/talk/p2p/base/relayport_unittest.cc
+++ b/talk/p2p/base/relayport_unittest.cc
@@ -65,12 +65,13 @@
virtual_socket_server_(new talk_base::VirtualSocketServer(
physical_socket_server_.get())),
ss_scope_(virtual_socket_server_.get()),
- network_("unittest", "unittest", 0),
+ network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
socket_factory_(talk_base::Thread::Current()),
username_(talk_base::CreateRandomString(16)),
password_(talk_base::CreateRandomString(16)),
relay_port_(cricket::RelayPort::Create(main_, &socket_factory_,
- &network_, kLocalAddress.ip(),
+ &network_,
+ kLocalAddress.ipaddr(),
0, 0, username_, password_, "")),
relay_server_(new cricket::RelayServer(main_)) {
}
diff --git a/talk/p2p/base/relayserver.cc b/talk/p2p/base/relayserver.cc
index 554337f..b17da5b 100644
--- a/talk/p2p/base/relayserver.cc
+++ b/talk/p2p/base/relayserver.cc
@@ -444,7 +444,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- addr_attr->SetIP(ext_addr.ip());
+ addr_attr->SetIP(ext_addr.ipaddr());
addr_attr->SetPort(ext_addr.port());
response.AddAttribute(addr_attr);
@@ -478,7 +478,7 @@
return;
}
- talk_base::SocketAddress ext_addr(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress ext_addr(addr_attr->ipaddr(), addr_attr->port());
RelayServerConnection* ext_conn =
int_conn->binding()->GetExternalConnection(ext_addr);
if (!ext_conn) {
@@ -620,7 +620,7 @@
StunAddressAttribute* addr_attr =
StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
- addr_attr->SetIP(from_addr.ip());
+ addr_attr->SetIP(from_addr.ipaddr());
addr_attr->SetPort(from_addr.port());
msg.AddAttribute(addr_attr);
diff --git a/talk/p2p/base/relayserver_unittest.cc b/talk/p2p/base/relayserver_unittest.cc
index 1528eb4..0f96e27 100644
--- a/talk/p2p/base/relayserver_unittest.cc
+++ b/talk/p2p/base/relayserver_unittest.cc
@@ -174,7 +174,7 @@
static void AddDestinationAttr(StunMessage* msg, const SocketAddress& addr) {
StunAddressAttribute* attr =
StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
- attr->SetIP(addr.ip());
+ attr->SetIP(addr.ipaddr());
attr->SetPort(addr.port());
msg->AddAttribute(attr);
}
@@ -263,7 +263,7 @@
ASSERT_TRUE(mapped_addr != NULL);
EXPECT_EQ(1, mapped_addr->family());
EXPECT_EQ(server_ext_addr.port(), mapped_addr->port());
- EXPECT_EQ(server_ext_addr.ip(), mapped_addr->ip());
+ EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr());
const StunUInt32Attribute* res_lifetime_attr =
res->GetUInt32(STUN_ATTR_LIFETIME);
@@ -293,7 +293,7 @@
ASSERT_TRUE(mapped_addr != NULL);
EXPECT_EQ(1, mapped_addr->family());
EXPECT_EQ(server_ext_addr.port(), mapped_addr->port());
- EXPECT_EQ(server_ext_addr.ip(), mapped_addr->ip());
+ EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr());
const StunUInt32Attribute* lifetime_attr =
res->GetUInt32(STUN_ATTR_LIFETIME);
@@ -330,7 +330,7 @@
res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
ASSERT_TRUE(src_addr != NULL);
EXPECT_EQ(1, src_addr->family());
- EXPECT_EQ(client2_addr.ip(), src_addr->ip());
+ EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr());
EXPECT_EQ(client2_addr.port(), src_addr->port());
EXPECT_TRUE(Receive2() == NULL);
@@ -498,7 +498,7 @@
res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
ASSERT_TRUE(src_addr != NULL);
EXPECT_EQ(1, src_addr->family());
- EXPECT_EQ(client2_addr.ip(), src_addr->ip());
+ EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr());
EXPECT_EQ(client2_addr.port(), src_addr->port());
const StunByteStringAttribute* recv_data =
diff --git a/talk/p2p/base/session.cc b/talk/p2p/base/session.cc
index ab4d83f..9891ee2 100644
--- a/talk/p2p/base/session.cc
+++ b/talk/p2p/base/session.cc
@@ -737,8 +737,8 @@
case ACTION_TRANSPORT_ACCEPT:
valid = OnTransportAcceptMessage(msg, &error);
break;
- case ACTION_UPDATE:
- valid = OnUpdateMessage(msg, &error);
+ case ACTION_DESCRIPTION_INFO:
+ valid = OnDescriptionInfoMessage(msg, &error);
break;
default:
valid = BadMessage(buzz::QN_STANZA_BAD_REQUEST,
@@ -946,7 +946,7 @@
return true;
}
-bool Session::OnUpdateMessage(const SessionMessage& msg,
+bool Session::OnDescriptionInfoMessage(const SessionMessage& msg,
MessageError* error) {
if (!CheckState(STATE_INPROGRESS, error))
return false;
@@ -972,12 +972,14 @@
}
// Merge the updates into the remote description.
+ // TODO: Merge streams instead of overwriting.
for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
LOG(LS_INFO) << "Updating content " << it->name;
remote_description()->RemoveContentByName(it->name);
remote_description()->AddContent(it->name, it->type, it->description);
}
+ // TODO: Add an argument that shows what streams were changed.
SignalRemoteDescriptionUpdate(this);
return true;
diff --git a/talk/p2p/base/session.h b/talk/p2p/base/session.h
index c968f5d..f3b6f25 100644
--- a/talk/p2p/base/session.h
+++ b/talk/p2p/base/session.h
@@ -562,7 +562,7 @@
bool OnTerminateMessage(const SessionMessage& msg, MessageError* error);
bool OnTransportInfoMessage(const SessionMessage& msg, MessageError* error);
bool OnTransportAcceptMessage(const SessionMessage& msg, MessageError* error);
- bool OnUpdateMessage(const SessionMessage& msg, MessageError* error);
+ bool OnDescriptionInfoMessage(const SessionMessage& msg, MessageError* error);
bool OnRedirectError(const SessionRedirect& redirect, SessionError* error);
// Verifies that we are in the appropriate state to receive this message.
diff --git a/talk/p2p/base/session_unittest.cc b/talk/p2p/base/session_unittest.cc
index e6f0d43..e663113 100644
--- a/talk/p2p/base/session_unittest.cc
+++ b/talk/p2p/base/session_unittest.cc
@@ -567,7 +567,7 @@
port_offset_(port_offset),
ports_(kNumPorts),
address_("127.0.0.1", 0),
- network_("network", "unittest", address_.ip()),
+ network_("network", "unittest", address_.ipaddr()),
socket_factory_(talk_base::Thread::Current()),
running_(false),
port_(28653) {
@@ -583,7 +583,7 @@
int index = port_offset_ + i;
ports_[i] = cricket::UDPPort::Create(
talk_base::Thread::Current(), &socket_factory_,
- &network_, address_.ip(), GetPort(index), GetPort(index));
+ &network_, address_.ipaddr(), GetPort(index), GetPort(index));
ports_[i]->set_username_fragment(GetUsername(index));
ports_[i]->set_password(GetPassword(index));
AddPort(ports_[i]);
@@ -1027,7 +1027,7 @@
session->CreateChannel(content_name_a, channel_name_a));
chan_b = new ChannelHandler(
session->CreateChannel(content_name_b, channel_name_b));
- if (chan_aa == NULL && chan_bb == NULL) {
+ if (!channel_name_aa.empty() && !channel_name_bb.empty()) {
chan_aa = new ChannelHandler(
session->CreateChannel(content_name_a, channel_name_aa));
chan_bb = new ChannelHandler(
@@ -2065,14 +2065,12 @@
// initiates to a client with protocol Y, they end up speaking protocol Z.
// Gingle => Gingle = Gingle (with other content)
-// Disabled due to flakey pulse builds
-TEST_F(SessionTest, DISABLED_GingleToGingleOtherContent) {
+TEST_F(SessionTest, GingleToGingleOtherContent) {
TestOtherContent(PROTOCOL_GINGLE, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
}
// Gingle => Gingle = Gingle (with audio content)
-// Disabled due to flakey pulse builds
-TEST_F(SessionTest, DISABLED_GingleToGingleAudioContent) {
+TEST_F(SessionTest, GingleToGingleAudioContent) {
TestAudioContent(PROTOCOL_GINGLE, PROTOCOL_GINGLE, PROTOCOL_GINGLE);
}
@@ -2199,8 +2197,7 @@
TestRejection(PROTOCOL_JINGLE);
}
-// Disabled due to flakey pulse builds
-TEST_F(SessionTest, DISABLED_GingleGoodRedirect) {
+TEST_F(SessionTest, GingleGoodRedirect) {
TestGoodRedirect(PROTOCOL_GINGLE);
}
diff --git a/talk/p2p/base/sessionmessages.cc b/talk/p2p/base/sessionmessages.cc
index 840d1a6..96f91d1 100644
--- a/talk/p2p/base/sessionmessages.cc
+++ b/talk/p2p/base/sessionmessages.cc
@@ -73,9 +73,9 @@
if (type == JINGLE_ACTION_TRANSPORT_ACCEPT)
return ACTION_TRANSPORT_ACCEPT;
if (type == JINGLE_ACTION_DESCRIPTION_INFO)
- return ACTION_UPDATE;
+ return ACTION_DESCRIPTION_INFO;
if (type == GINGLE_ACTION_UPDATE)
- return ACTION_UPDATE;
+ return ACTION_DESCRIPTION_INFO;
return ACTION_UNKNOWN;
}
diff --git a/talk/p2p/base/sessionmessages.h b/talk/p2p/base/sessionmessages.h
index 214fa8c..1486f0c 100644
--- a/talk/p2p/base/sessionmessages.h
+++ b/talk/p2p/base/sessionmessages.h
@@ -62,7 +62,7 @@
ACTION_TRANSPORT_INFO,
ACTION_TRANSPORT_ACCEPT,
- ACTION_UPDATE,
+ ACTION_DESCRIPTION_INFO,
};
// Abstraction of a <jingle> element within an <iq> stanza, per XMPP
diff --git a/talk/p2p/base/stun.cc b/talk/p2p/base/stun.cc
index fab14af..3b3fad4 100644
--- a/talk/p2p/base/stun.cc
+++ b/talk/p2p/base/stun.cc
@@ -347,6 +347,7 @@
uint8 family;
// We don't expect IPv6 address here because IPv6 addresses would
// not pass the attribute size check in StunAttribute::Create().
+ // TODO: Support IPv6 addresses.
if (!buf->ReadUInt8(&family) || family != STUN_ADDRESS_IPV4) {
return false;
}
@@ -354,9 +355,10 @@
if (!buf->ReadUInt16(&port_))
return false;
-
- if (!buf->ReadUInt32(&ip_))
+ uint32 ip;
+ if (!buf->ReadUInt32(&ip))
return false;
+ SetIP(talk_base::IPAddress(ip));
return true;
}
@@ -368,7 +370,7 @@
buf->WriteUInt8(0);
buf->WriteUInt8(family_);
buf->WriteUInt16(port_);
- buf->WriteUInt32(ip_);
+ buf->WriteUInt32(ip_.v4AddressAsHostOrderInteger());
}
StunXorAddressAttribute::StunXorAddressAttribute(uint16 type)
@@ -380,7 +382,8 @@
return false;
SetPort(port() ^ (kStunMagicCookie >> 16));
- SetIP(ip() ^ kStunMagicCookie);
+ uint32 ip = ipaddr().v4AddressAsHostOrderInteger();
+ SetIP(talk_base::IPAddress(ip ^ kStunMagicCookie));
return true;
}
@@ -392,7 +395,7 @@
buf->WriteUInt8(0);
buf->WriteUInt8(family());
buf->WriteUInt16(port() ^ (kStunMagicCookie >> 16));
- buf->WriteUInt32(ip() ^ kStunMagicCookie);
+ buf->WriteUInt32(ipaddr().v4AddressAsHostOrderInteger() ^ kStunMagicCookie);
}
StunUInt32Attribute::StunUInt32Attribute(uint16 type)
diff --git a/talk/p2p/base/stun.h b/talk/p2p/base/stun.h
index efc5f2c..87687b1 100644
--- a/talk/p2p/base/stun.h
+++ b/talk/p2p/base/stun.h
@@ -36,6 +36,7 @@
#include "talk/base/basictypes.h"
#include "talk/base/bytebuffer.h"
+#include "talk/base/ipaddress.h"
namespace cricket {
@@ -206,6 +207,7 @@
};
// Implements STUN/TURN attributes that record an Internet address.
+// TODO: IPv6 support, and use the SocketAddress class.
class StunAddressAttribute : public StunAttribute {
public:
explicit StunAddressAttribute(uint16 type);
@@ -214,10 +216,10 @@
StunAddressFamily family() const { return family_; }
uint16 port() const { return port_; }
- uint32 ip() const { return ip_; }
+ talk_base::IPAddress ipaddr() const { return ip_; }
void SetFamily(StunAddressFamily family);
- void SetIP(uint32 ip) { ip_ = ip; }
+ void SetIP(const talk_base::IPAddress& ip) { ip_ = ip; }
void SetPort(uint16 port) { port_ = port; }
virtual bool Read(talk_base::ByteBuffer* buf);
@@ -226,7 +228,7 @@
private:
StunAddressFamily family_;
uint16 port_;
- uint32 ip_;
+ talk_base::IPAddress ip_;
};
// Implements STUN/TURN attributes that record an Internet address.
diff --git a/talk/p2p/base/stun_unittest.cc b/talk/p2p/base/stun_unittest.cc
index 16dc26c..34b6059 100644
--- a/talk/p2p/base/stun_unittest.cc
+++ b/talk/p2p/base/stun_unittest.cc
@@ -158,12 +158,12 @@
EXPECT_TRUE(addr != NULL);
EXPECT_EQ(1, addr->family());
EXPECT_EQ(13, addr->port());
- EXPECT_EQ(17U, addr->ip());
+ EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
StunAddressAttribute* addr2 =
StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
addr2->SetPort(13);
- addr2->SetIP(17);
+ addr2->SetIP(talk_base::IPAddress(17U));
msg2.AddAttribute(addr2);
const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
@@ -239,22 +239,22 @@
EXPECT_TRUE(addr != NULL);
EXPECT_EQ(1, addr->family());
EXPECT_EQ(13, addr->port());
- EXPECT_EQ(17U, addr->ip());
+ EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
addr2->SetPort(13);
- addr2->SetIP(17);
+ addr2->SetIP(talk_base::IPAddress(17U));
msg2.AddAttribute(addr2);
addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
EXPECT_TRUE(addr != NULL);
EXPECT_EQ(1, addr->family());
EXPECT_EQ(13, addr->port());
- EXPECT_EQ(17U, addr->ip());
+ EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
addr2->SetPort(13);
- addr2->SetIP(17);
+ addr2->SetIP(talk_base::IPAddress(17U));
msg2.AddAttribute(addr2);
bytes = msg.GetByteString(STUN_ATTR_DATA);
@@ -306,7 +306,7 @@
EXPECT_TRUE(addr != NULL);
EXPECT_EQ(1, addr->family());
EXPECT_EQ(13, addr->port());
- EXPECT_EQ(17U, addr->ip());
+ EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
EXPECT_TRUE(uval != NULL);
@@ -324,11 +324,11 @@
EXPECT_TRUE(addr != NULL);
EXPECT_EQ(1, addr->family());
EXPECT_EQ(13, addr->port());
- EXPECT_EQ(17U, addr->ip());
+ EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
addr = msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
EXPECT_TRUE(addr != NULL);
EXPECT_EQ(1, addr->family());
EXPECT_EQ(13, addr->port());
- EXPECT_EQ(17U, addr->ip());
+ EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
}
diff --git a/talk/p2p/base/stunport.cc b/talk/p2p/base/stunport.cc
index ba797ff..7328b99 100644
--- a/talk/p2p/base/stunport.cc
+++ b/talk/p2p/base/stunport.cc
@@ -66,7 +66,7 @@
} else if (addr_attr->family() != 1) {
LOG(LS_ERROR) << "Binding address has bad family";
} else {
- talk_base::SocketAddress addr(addr_attr->ip(), addr_attr->port());
+ talk_base::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
port_->AddAddress(addr, "udp", true);
}
@@ -127,7 +127,7 @@
StunPort::StunPort(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port,
+ const talk_base::IPAddress& ip, int min_port, int max_port,
const talk_base::SocketAddress& server_addr)
: Port(thread, STUN_PORT_TYPE, factory, network, ip, min_port, max_port),
server_addr_(server_addr),
diff --git a/talk/p2p/base/stunport.h b/talk/p2p/base/stunport.h
index 26f46a5..c74ad4d 100644
--- a/talk/p2p/base/stunport.h
+++ b/talk/p2p/base/stunport.h
@@ -49,7 +49,8 @@
static StunPort* Create(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port,
+ const talk_base::IPAddress& ip,
+ int min_port, int max_port,
const talk_base::SocketAddress& server_addr) {
StunPort* port = new StunPort(thread, factory, network,
ip, min_port, max_port, server_addr);
@@ -88,7 +89,8 @@
protected:
StunPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port,
const talk_base::SocketAddress& server_addr);
bool Init();
diff --git a/talk/p2p/base/stunport_unittest.cc b/talk/p2p/base/stunport_unittest.cc
index 6dd1ee4..3d830ba 100644
--- a/talk/p2p/base/stunport_unittest.cc
+++ b/talk/p2p/base/stunport_unittest.cc
@@ -48,7 +48,7 @@
public sigslot::has_slots<> {
public:
StunPortTest()
- : network_("unittest", "unittest", 0),
+ : network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
socket_factory_(talk_base::Thread::Current()),
stun_server_(new cricket::TestStunServer(
talk_base::Thread::Current(), kStunAddr)),
@@ -62,7 +62,7 @@
void CreateStunPort(const talk_base::SocketAddress& server_addr) {
stun_port_.reset(cricket::StunPort::Create(
talk_base::Thread::Current(), &socket_factory_, &network_,
- kLocalAddr.ip(), 0, 0, server_addr));
+ kLocalAddr.ipaddr(), 0, 0, server_addr));
stun_port_->SignalAddressReady.connect(this,
&StunPortTest::OnAddressReady);
stun_port_->SignalAddressError.connect(this,
diff --git a/talk/p2p/base/stunserver.cc b/talk/p2p/base/stunserver.cc
index f34fd2d..8a5d447 100644
--- a/talk/p2p/base/stunserver.cc
+++ b/talk/p2p/base/stunserver.cc
@@ -96,7 +96,7 @@
mapped_addr = StunAttribute::CreateAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
}
mapped_addr->SetPort(remote_addr.port());
- mapped_addr->SetIP(remote_addr.ip());
+ mapped_addr->SetIP(remote_addr.ipaddr());
response.AddAttribute(mapped_addr);
// TODO: Add username and message-integrity.
diff --git a/talk/p2p/base/stunserver_unittest.cc b/talk/p2p/base/stunserver_unittest.cc
index a475101..b7f2f00 100644
--- a/talk/p2p/base/stunserver_unittest.cc
+++ b/talk/p2p/base/stunserver_unittest.cc
@@ -99,11 +99,10 @@
EXPECT_TRUE(mapped_addr != NULL);
EXPECT_EQ(1, mapped_addr->family());
EXPECT_EQ(client_addr.port(), mapped_addr->port());
- if (mapped_addr->ip() != client_addr.ip()) {
+ if (mapped_addr->ipaddr() != client_addr.ipaddr()) {
LOG(LS_WARNING) << "Warning: mapped IP ("
- << talk_base::SocketAddress::IPToString(
- mapped_addr->ip()).c_str()
- << ") != local IP (" << client_addr.IPAsString().c_str()
+ << mapped_addr->ipaddr()
+ << ") != local IP (" << client_addr.ipaddr()
<< ")";
}
diff --git a/talk/p2p/base/tcpport.cc b/talk/p2p/base/tcpport.cc
index 555ba73..4db4761 100644
--- a/talk/p2p/base/tcpport.cc
+++ b/talk/p2p/base/tcpport.cc
@@ -35,7 +35,7 @@
TCPPort::TCPPort(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip,
+ talk_base::Network* network, const talk_base::IPAddress& ip,
int min_port, int max_port, bool allow_listen)
: Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port),
incoming_only_(false),
@@ -218,7 +218,7 @@
}
} else {
// Incoming connections should match the network address.
- ASSERT(socket_->GetLocalAddress().ip() == port->ip_);
+ ASSERT(socket_->GetLocalAddress().ipaddr() == port->ip_);
}
if (socket_) {
diff --git a/talk/p2p/base/tcpport.h b/talk/p2p/base/tcpport.h
index 8345b12..5ce917d 100644
--- a/talk/p2p/base/tcpport.h
+++ b/talk/p2p/base/tcpport.h
@@ -50,7 +50,8 @@
static TCPPort* Create(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port,
+ const talk_base::IPAddress& ip,
+ int min_port, int max_port,
bool allow_listen) {
TCPPort* port = new TCPPort(thread, factory, network,
ip, min_port, max_port, allow_listen);
@@ -73,8 +74,8 @@
protected:
TCPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port,
- bool allow_listen);
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port, bool allow_listen);
bool Init();
// Handles sending using the local TCP socket.
diff --git a/talk/p2p/base/udpport.cc b/talk/p2p/base/udpport.cc
index 8355b00..311fb45 100644
--- a/talk/p2p/base/udpport.cc
+++ b/talk/p2p/base/udpport.cc
@@ -38,7 +38,7 @@
UDPPort::UDPPort(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port)
+ const talk_base::IPAddress& ip, int min_port, int max_port)
: Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port),
socket_(NULL),
error_(0) {
diff --git a/talk/p2p/base/udpport.h b/talk/p2p/base/udpport.h
index d74d4a3..5d767bb 100644
--- a/talk/p2p/base/udpport.h
+++ b/talk/p2p/base/udpport.h
@@ -48,7 +48,8 @@
static UDPPort* Create(talk_base::Thread* thread,
talk_base::PacketSocketFactory* factory,
talk_base::Network* network,
- uint32 ip, int min_port, int max_port) {
+ const talk_base::IPAddress& ip,
+ int min_port, int max_port) {
UDPPort* port = new UDPPort(thread, factory, network,
ip, min_port, max_port);
if (!port->Init()) {
@@ -68,7 +69,8 @@
protected:
UDPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
- talk_base::Network* network, uint32 ip, int min_port, int max_port);
+ talk_base::Network* network, const talk_base::IPAddress& ip,
+ int min_port, int max_port);
bool Init();
// Handles sending using the local UDP socket.
diff --git a/talk/p2p/client/basicportallocator.cc b/talk/p2p/client/basicportallocator.cc
index 51d069e..ec13b86 100644
--- a/talk/p2p/client/basicportallocator.cc
+++ b/talk/p2p/client/basicportallocator.cc
@@ -154,7 +154,7 @@
BasicPortAllocatorSession* session_;
talk_base::Network* network_;
- uint32 ip_;
+ talk_base::IPAddress ip_;
PortConfiguration* config_;
bool running_;
int step_;
diff --git a/talk/p2p/client/portallocator_unittest.cc b/talk/p2p/client/portallocator_unittest.cc
index 9c7db4d..be3a4e1 100644
--- a/talk/p2p/client/portallocator_unittest.cc
+++ b/talk/p2p/client/portallocator_unittest.cc
@@ -104,7 +104,7 @@
const std::string& proto,
const SocketAddress& addr) {
return (c.name() == name && c.type() == type &&
- c.protocol() == proto && c.address().ip() == addr.ip() &&
+ c.protocol() == proto && c.address().ipaddr() == addr.ipaddr() &&
(addr.port() == 0 || (c.address().port() == addr.port())));
}
static bool CheckPort(const talk_base::SocketAddress& addr,
diff --git a/talk/session/phone/call.cc b/talk/session/phone/call.cc
index e01e937..4b2e229 100644
--- a/talk/session/phone/call.cc
+++ b/talk/session/phone/call.cc
@@ -151,7 +151,7 @@
XmlElements elems;
WriteError error;
- if (!WriteViewRequest(CN_VIDEO, view_request, &elems, &error)) {
+ if (!WriteJingleViewRequest(CN_VIDEO, view_request, &elems, &error)) {
LOG(LS_ERROR) << "Couldn't write out view request: " << error.text;
return false;
}
diff --git a/talk/session/phone/channel.cc b/talk/session/phone/channel.cc
index 42506dd..90d917d 100644
--- a/talk/session/phone/channel.cc
+++ b/talk/session/phone/channel.cc
@@ -559,6 +559,8 @@
return ret;
}
+// TODO: Check all of the ssrcs in all of the streams in
+// the content, and not just the first one.
bool BaseChannel::SetSsrcMux_w(bool enable,
const MediaContentDescription* content,
ContentAction action,
@@ -567,12 +569,12 @@
if (action == CA_OFFER) {
ret = ssrc_filter_.SetOffer(enable, src);
if (ret && src == CS_REMOTE) { // if received offer with ssrc
- ret = ssrc_filter_.AddStream(content->ssrc());
+ ret = ssrc_filter_.AddStream(content->first_ssrc());
}
} else if (action == CA_ANSWER) {
ret = ssrc_filter_.SetAnswer(enable, src);
if (ret && src == CS_REMOTE && ssrc_filter_.IsActive()) {
- ret = ssrc_filter_.AddStream(content->ssrc());
+ ret = ssrc_filter_.AddStream(content->first_ssrc());
}
}
return ret;
@@ -838,9 +840,10 @@
ASSERT(audio != NULL);
bool ret;
- if (audio->ssrc_set()) {
- media_channel()->SetSendSsrc(audio->ssrc());
- LOG(LS_INFO) << "Set send ssrc for audio: " << audio->ssrc();
+ if (audio->has_ssrcs()) {
+ // TODO: Handle multiple streams and ssrcs here.
+ media_channel()->SetSendSsrc(audio->first_ssrc());
+ LOG(LS_INFO) << "Set send ssrc for audio: " << audio->first_ssrc();
}
// Set local SRTP parameters (what we will encrypt with).
ret = SetSrtp_w(audio->cryptos(), action, CS_LOCAL);
@@ -850,7 +853,7 @@
}
// Set SSRC mux filter
if (ret) {
- ret = SetSsrcMux_w(audio->ssrc_set(), content, action, CS_LOCAL);
+ ret = SetSsrcMux_w(audio->has_ssrcs(), content, action, CS_LOCAL);
}
// Set local audio codecs (what we want to receive).
if (ret) {
@@ -889,7 +892,7 @@
}
// Set SSRC mux filter
if (ret) {
- ret = SetSsrcMux_w(audio->ssrc_set(), content, action, CS_REMOTE);
+ ret = SetSsrcMux_w(audio->has_ssrcs(), content, action, CS_REMOTE);
}
// Set remote video codecs (what the other side wants to receive).
@@ -1201,9 +1204,10 @@
ASSERT(video != NULL);
bool ret;
- if (video->ssrc_set()) {
- media_channel()->SetSendSsrc(video->ssrc());
- LOG(LS_INFO) << "Set send ssrc for video: " << video->ssrc();
+ if (video->has_ssrcs()) {
+ // TODO: Handle multiple streams and ssrcs here.
+ media_channel()->SetSendSsrc(video->first_ssrc());
+ LOG(LS_INFO) << "Set send ssrc for video: " << video->first_ssrc();
}
// Set local SRTP parameters (what we will encrypt with).
ret = SetSrtp_w(video->cryptos(), action, CS_LOCAL);
@@ -1213,7 +1217,7 @@
}
// Set SSRC mux filter
if (ret) {
- ret = SetSsrcMux_w(video->ssrc_set(), content, action, CS_LOCAL);
+ ret = SetSsrcMux_w(video->has_ssrcs(), content, action, CS_LOCAL);
}
// Set local video codecs (what we want to receive).
@@ -1253,7 +1257,7 @@
}
// Set SSRC mux filter
if (ret) {
- ret = SetSsrcMux_w(video->ssrc_set(), content, action, CS_REMOTE);
+ ret = SetSsrcMux_w(video->has_ssrcs(), content, action, CS_REMOTE);
}
// Set remote video codecs (what the other side wants to receive).
if (ret) {
diff --git a/talk/session/phone/devicemanager_unittest.cc b/talk/session/phone/devicemanager_unittest.cc
index 91afdc8..a64eab9 100644
--- a/talk/session/phone/devicemanager_unittest.cc
+++ b/talk/session/phone/devicemanager_unittest.cc
@@ -29,11 +29,12 @@
#include "talk/base/win32.h"
#include <objbase.h>
#endif
+#include "talk/base/fileutils.h"
#include "talk/base/gunit.h"
#include "talk/base/logging.h"
-#include "talk/base/stream.h"
-#include "talk/base/fileutils.h"
#include "talk/base/pathutils.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stream.h"
#include "talk/session/phone/devicemanager.h"
#include "talk/session/phone/v4llookup.h"
@@ -42,50 +43,47 @@
#include "talk/base/fileutils_mock.h"
#endif // LINUX
+#include "talk/session/phone/devicemanager.h"
+
using talk_base::Pathname;
using talk_base::FileTimeType;
+using talk_base::scoped_ptr;
using cricket::Device;
+using cricket::DeviceManager;
+using cricket::DeviceManagerFactory;
+using cricket::DeviceManagerInterface;
// Test that we startup/shutdown properly.
TEST(DeviceManagerTest, StartupShutdown) {
- cricket::DeviceManager dm;
- EXPECT_FALSE(dm.initialized());
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.initialized());
- dm.Terminate();
- EXPECT_FALSE(dm.initialized());
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
+ EXPECT_TRUE(dm->Init());
+ dm->Terminate();
}
// Test CoInitEx behavior
#ifdef WIN32
TEST(DeviceManagerTest, CoInitialize) {
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
std::vector<Device> devices;
// Ensure that calls to video device work if COM is not yet initialized.
- EXPECT_FALSE(dm.initialized());
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.initialized());
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&devices));
- dm.Terminate();
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&devices));
+ dm->Terminate();
// Ensure that the ref count is correct.
EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
CoUninitialize();
// Ensure that Init works in COINIT_APARTMENTTHREADED setting.
- EXPECT_FALSE(dm.initialized());
EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.initialized());
- dm.Terminate();
+ EXPECT_TRUE(dm->Init());
+ dm->Terminate();
CoUninitialize();
// Ensure that the ref count is correct.
EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
CoUninitialize();
// Ensure that Init works in COINIT_MULTITHREADED setting.
- EXPECT_FALSE(dm.initialized());
EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.initialized());
- dm.Terminate();
+ EXPECT_TRUE(dm->Init());
+ dm->Terminate();
CoUninitialize();
// Ensure that the ref count is correct.
EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
@@ -95,52 +93,52 @@
// Test enumerating devices (although we may not find any).
TEST(DeviceManagerTest, GetDevices) {
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
std::vector<Device> audio_ins, audio_outs, video_ins;
std::vector<cricket::Device> video_in_devs;
cricket::Device def_video;
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.GetAudioInputDevices(&audio_ins));
- EXPECT_TRUE(dm.GetAudioOutputDevices(&audio_outs));
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_in_devs));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetAudioInputDevices(&audio_ins));
+ EXPECT_TRUE(dm->GetAudioOutputDevices(&audio_outs));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_in_devs));
EXPECT_EQ(video_ins.size(), video_in_devs.size());
// If we have any video devices, we should be able to pick a default.
- EXPECT_TRUE(dm.GetVideoCaptureDevice(
+ EXPECT_TRUE(dm->GetVideoCaptureDevice(
cricket::DeviceManagerInterface::kDefaultDeviceName, &def_video)
!= video_ins.empty());
}
// Test that we return correct ids for default and bogus devices.
TEST(DeviceManagerTest, GetAudioDeviceIds) {
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
Device device;
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.GetAudioInputDevice(
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetAudioInputDevice(
cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
EXPECT_EQ("-1", device.id);
- EXPECT_TRUE(dm.GetAudioOutputDevice(
+ EXPECT_TRUE(dm->GetAudioOutputDevice(
cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
EXPECT_EQ("-1", device.id);
- EXPECT_FALSE(dm.GetAudioInputDevice("_NOT A REAL DEVICE_", &device));
- EXPECT_FALSE(dm.GetAudioOutputDevice("_NOT A REAL DEVICE_", &device));
+ EXPECT_FALSE(dm->GetAudioInputDevice("_NOT A REAL DEVICE_", &device));
+ EXPECT_FALSE(dm->GetAudioOutputDevice("_NOT A REAL DEVICE_", &device));
}
// Test that we get the video capture device by name properly.
TEST(DeviceManagerTest, GetVideoDeviceIds) {
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
Device device;
- EXPECT_TRUE(dm.Init());
- EXPECT_FALSE(dm.GetVideoCaptureDevice("_NOT A REAL DEVICE_", &device));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_FALSE(dm->GetVideoCaptureDevice("_NOT A REAL DEVICE_", &device));
std::vector<Device> video_ins;
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
if (!video_ins.empty()) {
// Get the default device with the parameter kDefaultDeviceName.
- EXPECT_TRUE(dm.GetVideoCaptureDevice(
+ EXPECT_TRUE(dm->GetVideoCaptureDevice(
cricket::DeviceManagerInterface::kDefaultDeviceName, &device));
// Get the first device with the parameter video_ins[0].name.
- EXPECT_TRUE(dm.GetVideoCaptureDevice(video_ins[0].name, &device));
+ EXPECT_TRUE(dm->GetVideoCaptureDevice(video_ins[0].name, &device));
EXPECT_EQ(device.name, video_ins[0].name);
EXPECT_EQ(device.id, video_ins[0].id);
}
@@ -148,15 +146,15 @@
TEST(DeviceManagerTest, VerifyDevicesListsAreCleared) {
const std::string imaginary("_NOT A REAL DEVICE_");
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
std::vector<Device> audio_ins, audio_outs, video_ins;
audio_ins.push_back(Device(imaginary, imaginary));
audio_outs.push_back(Device(imaginary, imaginary));
video_ins.push_back(Device(imaginary, imaginary));
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.GetAudioInputDevices(&audio_ins));
- EXPECT_TRUE(dm.GetAudioOutputDevices(&audio_outs));
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetAudioInputDevices(&audio_ins));
+ EXPECT_TRUE(dm->GetAudioOutputDevices(&audio_outs));
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
for (size_t i = 0; i < audio_ins.size(); ++i) {
EXPECT_NE(imaginary, audio_ins[i].name);
}
@@ -168,6 +166,57 @@
}
}
+static bool CompareDeviceList(std::vector<Device>& devices,
+ const char* const device_list[], int list_size) {
+ if (list_size != static_cast<int>(devices.size())) {
+ return false;
+ }
+ for (int i = 0; i < list_size; ++i) {
+ if (devices[i].name.compare(device_list[i]) != 0) {
+ return false;
+ }
+ }
+ return true;
+}
+
+TEST(DeviceManagerTest, VerifyFilterDevices) {
+ static const char* const kTotalDevicesName[] = {
+ "Google Camera Adapters are tons of fun.",
+ "device1",
+ "device2",
+ "device3",
+ "device4",
+ "device5",
+ "Google Camera Adapter 0",
+ "Google Camera Adapter 1",
+ };
+ static const char* const kFilteredDevicesName[] = {
+ "device2",
+ "device4",
+ "Google Camera Adapter",
+ NULL,
+ };
+ static const char* const kDevicesName[] = {
+ "device1",
+ "device3",
+ "device5",
+ };
+ std::vector<Device> devices;
+ for (int i = 0; i < ARRAY_SIZE(kTotalDevicesName); ++i) {
+ devices.push_back(Device(kTotalDevicesName[i], i));
+ }
+ EXPECT_TRUE(CompareDeviceList(devices, kTotalDevicesName,
+ ARRAY_SIZE(kTotalDevicesName)));
+ // Return false if given NULL as the exclusion list.
+ EXPECT_TRUE(DeviceManager::FilterDevices(&devices, NULL));
+ // The devices should not change.
+ EXPECT_TRUE(CompareDeviceList(devices, kTotalDevicesName,
+ ARRAY_SIZE(kTotalDevicesName)));
+ EXPECT_TRUE(DeviceManager::FilterDevices(&devices, kFilteredDevicesName));
+ EXPECT_TRUE(CompareDeviceList(devices, kDevicesName,
+ ARRAY_SIZE(kDevicesName)));
+}
+
#ifdef LINUX
class FakeV4LLookup : public cricket::V4LLookup {
public:
@@ -202,10 +251,10 @@
"Video Device 2"));
talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
std::vector<Device> video_ins;
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
EXPECT_EQ(2u, video_ins.size());
EXPECT_EQ("Video Device 1", video_ins.at(0).name);
EXPECT_EQ("Video Device 2", video_ins.at(1).name);
@@ -231,10 +280,10 @@
"param1: value1\nname: Video Device 2\n param2: value2\n"));
talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
std::vector<Device> video_ins;
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
EXPECT_EQ(2u, video_ins.size());
EXPECT_EQ("Video Device 1", video_ins.at(0).name);
EXPECT_EQ("Video Device 2", video_ins.at(1).name);
@@ -252,10 +301,10 @@
files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
- cricket::DeviceManager dm;
+ scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
std::vector<Device> video_ins;
- EXPECT_TRUE(dm.Init());
- EXPECT_TRUE(dm.GetVideoCaptureDevices(&video_ins));
+ EXPECT_TRUE(dm->Init());
+ EXPECT_TRUE(dm->GetVideoCaptureDevices(&video_ins));
EXPECT_EQ(2u, video_ins.size());
EXPECT_EQ("/dev/video0", video_ins.at(0).name);
EXPECT_EQ("/dev/video5", video_ins.at(1).name);
diff --git a/talk/session/phone/linuxdevicemanager.cc b/talk/session/phone/linuxdevicemanager.cc
index 5ebf9e3..6bad677 100644
--- a/talk/session/phone/linuxdevicemanager.cc
+++ b/talk/session/phone/linuxdevicemanager.cc
@@ -83,7 +83,7 @@
"surround50:",
"surround51:",
"surround71:",
- "iec958:" // S/PDIF
+ "iec958:", // S/PDIF
#endif
NULL,
};
diff --git a/talk/session/phone/mediamessages.cc b/talk/session/phone/mediamessages.cc
index 9031351..c40b03f 100644
--- a/talk/session/phone/mediamessages.cc
+++ b/talk/session/phone/mediamessages.cc
@@ -31,9 +31,12 @@
#include "talk/session/phone/mediamessages.h"
+#include "talk/base/logging.h"
#include "talk/base/stringencode.h"
#include "talk/p2p/base/constants.h"
+#include "talk/p2p/base/parsing.h"
#include "talk/session/phone/mediasessionclient.h"
+#include "talk/session/phone/streamparams.h"
#include "talk/xmllite/xmlelement.h"
namespace cricket {
@@ -96,19 +99,15 @@
bool ParseNamedSource(const buzz::XmlElement* source_elem,
NamedSource* named_source,
ParseError* error) {
- named_source->nick = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NICK);
+ named_source->nick = source_elem->Attr(QN_NICK);
if (named_source->nick.empty()) {
return BadParse("Missing or invalid nick.", error);
}
- named_source->name = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_NAME);
- named_source->usage = source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_USAGE);
- named_source->removed =
- STR_JINGLE_DRAFT_SOURCE_STATE_REMOVED ==
- source_elem->Attr(QN_JINGLE_DRAFT_SOURCE_STATE);
+ named_source->name = source_elem->Attr(QN_NAME);
const buzz::XmlElement* ssrc_elem =
- source_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE_SSRC);
+ source_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC);
if (ssrc_elem != NULL && !ssrc_elem->BodyText().empty()) {
uint32 ssrc;
if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
@@ -126,8 +125,8 @@
const std::string& type) {
buzz::XmlElement* view_elem =
new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
- view_elem->AddAttr(QN_JINGLE_DRAFT_CONTENT_NAME, name);
- view_elem->SetAttr(QN_JINGLE_DRAFT_VIEW_TYPE, type);
+ view_elem->AddAttr(QN_NAME, name);
+ view_elem->SetAttr(QN_TYPE, type);
return view_elem;
}
@@ -144,16 +143,13 @@
const StaticVideoView& view) {
buzz::XmlElement* view_elem =
CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
- AddXmlAttr(view_elem, QN_JINGLE_DRAFT_VIEW_SSRC, view.ssrc);
+ AddXmlAttr(view_elem, QN_SSRC, view.ssrc);
- buzz::XmlElement* params_elem = new buzz::XmlElement(
- QN_JINGLE_DRAFT_VIEW_PARAMS);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_WIDTH, view.width);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_HEIGHT, view.height);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_FRAMERATE,
- view.framerate);
- AddXmlAttr(params_elem, QN_JINGLE_DRAFT_VIEW_PARAMS_PREFERENCE,
- view.preference);
+ buzz::XmlElement* params_elem = new buzz::XmlElement(QN_JINGLE_DRAFT_PARAMS);
+ AddXmlAttr(params_elem, QN_WIDTH, view.width);
+ AddXmlAttr(params_elem, QN_HEIGHT, view.height);
+ AddXmlAttr(params_elem, QN_FRAMERATE, view.framerate);
+ AddXmlAttr(params_elem, QN_PREFERENCE, view.preference);
view_elem->AddElement(params_elem);
return view_elem;
@@ -200,10 +196,60 @@
RemoveSourceBySsrc(ssrc, &video_);
}
-bool WriteViewRequest(const std::string& content_name,
- const ViewRequest& request,
- XmlElements* elems,
- WriteError* error) {
+bool IsJingleViewRequest(const XmlElements& action_elems) {
+ return GetXmlElement(action_elems, QN_JINGLE_DRAFT_VIEW) != NULL;
+}
+
+bool ParseStaticVideoView(const buzz::XmlElement* view_elem,
+ StaticVideoView* view,
+ ParseError* error) {
+ if (!ParseSsrc(view_elem->Attr(QN_SSRC), &(view->ssrc))) {
+ return BadParse("Invalid or missing view ssrc.", error);
+ }
+
+ const buzz::XmlElement* params_elem =
+ view_elem->FirstNamed(QN_JINGLE_DRAFT_PARAMS);
+ if (params_elem) {
+ view->width = GetXmlAttr(params_elem, QN_WIDTH, 0);
+ view->height = GetXmlAttr(params_elem, QN_HEIGHT, 0);
+ view->framerate = GetXmlAttr(params_elem, QN_FRAMERATE, 0);
+ view->preference = GetXmlAttr(params_elem, QN_PREFERENCE, 0);
+ } else {
+ return BadParse("Missing view params.", error);
+ }
+
+ return true;
+}
+
+bool ParseJingleViewRequest(const XmlElements& action_elems,
+ ViewRequest* view_request,
+ ParseError* error) {
+ for (XmlElements::const_iterator iter = action_elems.begin();
+ iter != action_elems.end(); ++iter) {
+ const buzz::XmlElement* view_elem = *iter;
+ if (view_elem->Name() == QN_JINGLE_DRAFT_VIEW) {
+ std::string type = view_elem->Attr(QN_TYPE);
+ if (STR_JINGLE_DRAFT_VIEW_TYPE_NONE == type) {
+ view_request->static_video_views.clear();
+ return true;
+ } else if (STR_JINGLE_DRAFT_VIEW_TYPE_STATIC == type) {
+ StaticVideoView static_video_view(0, 0, 0, 0);
+ if (!ParseStaticVideoView(view_elem, &static_video_view, error)) {
+ return false;
+ }
+ view_request->static_video_views.push_back(static_video_view);
+ } else {
+ LOG(LS_INFO) << "Ingnoring unknown view type: " << type;
+ }
+ }
+ }
+ return true;
+}
+
+bool WriteJingleViewRequest(const std::string& content_name,
+ const ViewRequest& request,
+ XmlElements* elems,
+ WriteError* error) {
if (request.static_video_views.empty()) {
elems->push_back(CreateNoneVideoViewElem(content_name));
} else {
@@ -217,7 +263,7 @@
}
bool IsSourcesNotify(const buzz::XmlElement* action_elem) {
- return action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY) != NULL;
+ return action_elem->FirstNamed(QN_JINGLE_LEGACY_NOTIFY) != NULL;
}
bool ParseSourcesNotify(const buzz::XmlElement* action_elem,
@@ -225,14 +271,14 @@
MediaSources* sources,
ParseError* error) {
for (const buzz::XmlElement* notify_elem =
- action_elem->FirstNamed(QN_JINGLE_DRAFT_NOTIFY);
+ action_elem->FirstNamed(QN_JINGLE_LEGACY_NOTIFY);
notify_elem != NULL;
- notify_elem = notify_elem->NextNamed(QN_JINGLE_DRAFT_NOTIFY)) {
- std::string content_name = notify_elem->Attr(QN_JINGLE_DRAFT_CONTENT_NAME);
+ notify_elem = notify_elem->NextNamed(QN_JINGLE_LEGACY_NOTIFY)) {
+ std::string content_name = notify_elem->Attr(QN_NAME);
for (const buzz::XmlElement* source_elem =
- notify_elem->FirstNamed(QN_JINGLE_DRAFT_SOURCE);
+ notify_elem->FirstNamed(QN_JINGLE_LEGACY_SOURCE);
source_elem != NULL;
- source_elem = source_elem->NextNamed(QN_JINGLE_DRAFT_SOURCE)) {
+ source_elem = source_elem->NextNamed(QN_JINGLE_LEGACY_SOURCE)) {
NamedSource named_source;
if (!ParseNamedSource(source_elem, &named_source, error)) {
return false;
@@ -258,4 +304,150 @@
return true;
}
+bool ParseSsrcAsLegacyStream(const buzz::XmlElement* desc_elem,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
+ if (!ssrc_str.empty()) {
+ uint32 ssrc;
+ if (!ParseSsrc(ssrc_str, &ssrc)) {
+ return BadParse("Missing or invalid ssrc.", error);
+ }
+
+ streams->push_back(StreamParams::CreateLegacy(ssrc));
+ }
+ return true;
+}
+
+bool ParseSsrcs(const buzz::XmlElement* parent_elem,
+ std::vector<uint32>* ssrcs,
+ ParseError* error) {
+ for (const buzz::XmlElement* ssrc_elem =
+ parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC);
+ ssrc_elem != NULL;
+ ssrc_elem = ssrc_elem->NextNamed(QN_JINGLE_DRAFT_SSRC)) {
+ uint32 ssrc;
+ if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
+ return BadParse("Missing or invalid ssrc.", error);
+ }
+
+ ssrcs->push_back(ssrc);
+ }
+ return true;
+}
+
+bool ParseSsrcGroups(const buzz::XmlElement* parent_elem,
+ std::vector<SsrcGroup>* ssrc_groups,
+ ParseError* error) {
+ for (const buzz::XmlElement* group_elem =
+ parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC_GROUP);
+ group_elem != NULL;
+ group_elem = group_elem->NextNamed(QN_JINGLE_DRAFT_SSRC_GROUP)) {
+ std::string semantics = group_elem->Attr(QN_SEMANTICS);
+ std::vector<uint32> ssrcs;
+ if (!ParseSsrcs(group_elem, &ssrcs, error)) {
+ return false;
+ }
+ ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
+ }
+ return true;
+}
+
+bool ParseJingleStream(const buzz::XmlElement* stream_elem,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ StreamParams stream;
+ stream.nick = stream_elem->Attr(QN_NICK);
+ stream.name = stream_elem->Attr(QN_NAME);
+ stream.type = stream_elem->Attr(QN_TYPE);
+ stream.display = stream_elem->Attr(QN_DISPLAY);
+ stream.cname = stream_elem->Attr(QN_CNAME);
+ if (!ParseSsrcs(stream_elem, &(stream.ssrcs), error)) {
+ return false;
+ }
+ std::vector<SsrcGroup> ssrc_groups;
+ if (!ParseSsrcGroups(stream_elem, &(stream.ssrc_groups), error)) {
+ return false;
+ }
+ streams->push_back(stream);
+ return true;
+}
+
+bool HasJingleStreams(const buzz::XmlElement* desc_elem) {
+ const buzz::XmlElement* streams_elem =
+ desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
+ return (streams_elem != NULL);
+}
+
+bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ const buzz::XmlElement* streams_elem =
+ desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
+ if (streams_elem == NULL) {
+ return BadParse("Missing streams element.", error);
+ }
+ for (const buzz::XmlElement* stream_elem =
+ streams_elem->FirstNamed(QN_JINGLE_DRAFT_STREAM);
+ stream_elem != NULL;
+ stream_elem = stream_elem->NextNamed(QN_JINGLE_DRAFT_STREAM)) {
+ if (!ParseJingleStream(stream_elem, streams, error)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+void WriteSsrcs(const std::vector<uint32>& ssrcs,
+ buzz::XmlElement* parent_elem) {
+ for (std::vector<uint32>::const_iterator ssrc = ssrcs.begin();
+ ssrc != ssrcs.end(); ++ssrc) {
+ buzz::XmlElement* ssrc_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC, false);
+ SetXmlBody(ssrc_elem, *ssrc);
+
+ parent_elem->AddElement(ssrc_elem);
+ }
+}
+
+void WriteSsrcGroups(const std::vector<SsrcGroup>& groups,
+ buzz::XmlElement* parent_elem) {
+ for (std::vector<SsrcGroup>::const_iterator group = groups.begin();
+ group != groups.end(); ++group) {
+ buzz::XmlElement* group_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC_GROUP, false);
+ AddXmlAttrIfNonEmpty(group_elem, QN_SEMANTICS, group->semantics);
+ WriteSsrcs(group->ssrcs, group_elem);
+
+ parent_elem->AddElement(group_elem);
+ }
+}
+
+void WriteJingleStream(const StreamParams& stream,
+ buzz::XmlElement* parent_elem) {
+ buzz::XmlElement* stream_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_STREAM, false);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_NICK, stream.nick);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_NAME, stream.name);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_TYPE, stream.type);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_DISPLAY, stream.display);
+ AddXmlAttrIfNonEmpty(stream_elem, QN_CNAME, stream.cname);
+ WriteSsrcs(stream.ssrcs, stream_elem);
+ WriteSsrcGroups(stream.ssrc_groups, stream_elem);
+
+ parent_elem->AddElement(stream_elem);
+}
+
+void WriteJingleStreams(const std::vector<StreamParams>& streams,
+ buzz::XmlElement* parent_elem) {
+ buzz::XmlElement* streams_elem =
+ new buzz::XmlElement(QN_JINGLE_DRAFT_STREAMS, true);
+ for (std::vector<StreamParams>::const_iterator stream = streams.begin();
+ stream != streams.end(); ++stream) {
+ WriteJingleStream(*stream, streams_elem);
+ }
+
+ parent_elem->AddElement(streams_elem);
+}
+
} // namespace cricket
diff --git a/talk/session/phone/mediamessages.h b/talk/session/phone/mediamessages.h
index 541572f..11b9e89 100644
--- a/talk/session/phone/mediamessages.h
+++ b/talk/session/phone/mediamessages.h
@@ -45,6 +45,8 @@
namespace cricket {
+struct StreamParams;
+
// In a <notify> message, there are number of sources with names.
// This represents one such named source.
struct NamedSource {
@@ -57,7 +59,6 @@
std::string nick;
std::string name;
- std::string usage;
uint32 ssrc;
bool ssrc_set;
bool removed;
@@ -123,18 +124,29 @@
typedef std::vector<StaticVideoView> StaticVideoViews;
-// Represents a whole <view> message, which contains many views.
+// Represents a whole view request message, which contains many views.
struct ViewRequest {
StaticVideoViews static_video_views;
};
+// If the elems of a parent (usually <jingle>) constitute a view request.
+bool IsJingleViewRequest(const XmlElements& elems);
+
+// Parses a view request from jingle contents (<view>s). If it
+// fails, returns false and fills an error message.
+bool ParseJingleViewRequest(const XmlElements& elems,
+ ViewRequest* view_request,
+ ParseError* error);
+
// Serializes a view request to XML. If it fails, returns false and
// fills in an error message.
-bool WriteViewRequest(const std::string& content_name,
- const ViewRequest& view,
- XmlElements* elems,
- WriteError* error);
+bool WriteJingleViewRequest(const std::string& content_name,
+ const ViewRequest& view,
+ XmlElements* elems,
+ WriteError* error);
+// TODO: Get rid of legacy source notify and replace with
+// description-info as soon as reflector is capable of sending it.
bool IsSourcesNotify(const buzz::XmlElement* action_elem);
// Parses a notify message from XML. If it fails, returns false and
@@ -145,6 +157,19 @@
MediaSources* sources,
ParseError* error);
+// If the given elem has <streams>.
+bool HasJingleStreams(const buzz::XmlElement* desc_elem);
+
+// Parses streams from a jingle <description>. If it fails, returns
+// false and fills an error message.
+bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
+ std::vector<StreamParams>* streams,
+ ParseError* error);
+
+// Write a <streams> element to the parent_elem.
+void WriteJingleStreams(const std::vector<StreamParams>& streams,
+ buzz::XmlElement* parent_elem);
+
} // namespace cricket
#endif // TALK_SESSION_PHONE_MEDIAMESSAGES_H_
diff --git a/talk/session/phone/mediamessages_unittest.cc b/talk/session/phone/mediamessages_unittest.cc
index e5ae12f..0290c02 100644
--- a/talk/session/phone/mediamessages_unittest.cc
+++ b/talk/session/phone/mediamessages_unittest.cc
@@ -81,7 +81,6 @@
static std::string NotifyAddXml(const std::string& content_name,
const std::string& nick,
const std::string& name,
- const std::string& usage,
const std::string& ssrc) {
return "<notify xmlns='google:jingle'"
" name='" + content_name + "'"
@@ -89,7 +88,6 @@
" <source"
" nick='" + nick + "'"
" name='" + name + "'"
- " usage='" + usage + "'"
" >"
" <ssrc>" + ssrc + "</ssrc>"
" </source>"
@@ -129,19 +127,56 @@
"</notify>";
}
- static std::string NotifyExplicitRemoveXml(const std::string& content_name,
- const std::string& nick,
- const std::string& ssrc) {
- return "<notify xmlns='google:jingle'"
- " name='" + content_name + "'"
+ static cricket::StreamParams CreateStream(const std::string& nick,
+ const std::string& name,
+ uint32 ssrc1,
+ uint32 ssrc2,
+ const std::string& semantics,
+ const std::string& type,
+ const std::string& display) {
+ StreamParams stream;
+ stream.nick = nick;
+ stream.name = name;
+ stream.ssrcs.push_back(ssrc1);
+ stream.ssrcs.push_back(ssrc2);
+ stream.ssrc_groups.push_back(
+ cricket::SsrcGroup(semantics, stream.ssrcs));
+ stream.type = type;
+ stream.display = display;
+ return stream;
+ }
+
+ static std::string StreamsXml(const std::string& stream1,
+ const std::string& stream2) {
+ return "<streams xmlns='google:jingle'>"
+ + stream1
+ + stream2 +
+ "</streams>";
+ }
+
+
+ static std::string StreamXml(const std::string& nick,
+ const std::string& name,
+ const std::string& ssrc1,
+ const std::string& ssrc2,
+ const std::string& semantics,
+ const std::string& type,
+ const std::string& display) {
+ return "<stream"
+ " nick='" + nick + "'"
+ " name='" + name + "'"
+ " type='" + type + "'"
+ " display='" + display + "'"
">"
- " <source"
- " nick='" + nick + "'"
- " state='removed'"
- " >"
- " <ssrc>" + ssrc + "</ssrc>"
- " </source>"
- "</notify>";
+ "<ssrc>" + ssrc1 + "</ssrc>"
+ "<ssrc>" + ssrc2 + "</ssrc>"
+ "<ssrc-group"
+ " semantics='" + semantics + "'"
+ ">"
+ "<ssrc>" + ssrc1 + "</ssrc>"
+ "<ssrc>" + ssrc2 + "</ssrc>"
+ "</ssrc-group>"
+ "</stream>";
}
static cricket::SessionDescription* CreateMediaSessionDescription(
@@ -161,7 +196,7 @@
} // anonymous namespace
// Test serializing/deserializing an empty <view> message.
-TEST_F(MediaMessagesTest, ViewNoneToXml) {
+TEST_F(MediaMessagesTest, ViewNoneToFromXml) {
talk_base::scoped_ptr<buzz::XmlElement> expected_view_elem(
buzz::XmlElement::ForStr(kViewVideoNoneXml));
@@ -169,15 +204,22 @@
cricket::XmlElements actual_view_elems;
cricket::WriteError error;
- ASSERT_TRUE(cricket::WriteViewRequest(
+ EXPECT_FALSE(cricket::IsJingleViewRequest(actual_view_elems));
+ ASSERT_TRUE(cricket::WriteJingleViewRequest(
"video1", view_request, &actual_view_elems, &error));
ASSERT_EQ(1U, actual_view_elems.size());
EXPECT_EQ(expected_view_elem->Str(), actual_view_elems[0]->Str());
+
+ cricket::ParseError parse_error;
+ EXPECT_TRUE(cricket::IsJingleViewRequest(actual_view_elems));
+ ASSERT_TRUE(cricket::ParseJingleViewRequest(
+ actual_view_elems, &view_request, &parse_error));
+ EXPECT_EQ(0U, view_request.static_video_views.size());
}
// Test serializing/deserializing an a simple vga <view> message.
-TEST_F(MediaMessagesTest, ViewVgaToXml) {
+TEST_F(MediaMessagesTest, ViewVgaToFromXml) {
talk_base::scoped_ptr<buzz::XmlElement> expected_view_elem1(
buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("1234")));
talk_base::scoped_ptr<buzz::XmlElement> expected_view_elem2(
@@ -192,12 +234,37 @@
view_request.static_video_views.push_back(
cricket::StaticVideoView(2468, 640, 480, 30));
- ASSERT_TRUE(cricket::WriteViewRequest(
+ ASSERT_TRUE(cricket::WriteJingleViewRequest(
"video1", view_request, &actual_view_elems, &error));
ASSERT_EQ(2U, actual_view_elems.size());
EXPECT_EQ(expected_view_elem1->Str(), actual_view_elems[0]->Str());
EXPECT_EQ(expected_view_elem2->Str(), actual_view_elems[1]->Str());
+
+ view_request.static_video_views.clear();
+ cricket::ParseError parse_error;
+ EXPECT_TRUE(cricket::IsJingleViewRequest(actual_view_elems));
+ ASSERT_TRUE(cricket::ParseJingleViewRequest(
+ actual_view_elems, &view_request, &parse_error));
+ EXPECT_EQ(2U, view_request.static_video_views.size());
+ EXPECT_EQ(1234U, view_request.static_video_views[0].ssrc);
+ EXPECT_EQ(640, view_request.static_video_views[0].width);
+ EXPECT_EQ(480, view_request.static_video_views[0].height);
+ EXPECT_EQ(30, view_request.static_video_views[0].framerate);
+ EXPECT_EQ(2468U, view_request.static_video_views[1].ssrc);
+}
+
+// Test deserializing bad view XML.
+TEST_F(MediaMessagesTest, ParseBadViewXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> view_elem(
+ buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("not-an-ssrc")));
+ XmlElements view_elems;
+ view_elems.push_back(view_elem.get());
+
+ cricket::ViewRequest view_request;
+ cricket::ParseError parse_error;
+ ASSERT_FALSE(cricket::ParseJingleViewRequest(
+ view_elems, &view_request, &parse_error));
}
// Test serializing/deserializing an empty session-info message.
@@ -232,22 +299,19 @@
new buzz::XmlElement(cricket::QN_JINGLE));
action_elem->AddElement(
buzz::XmlElement::ForStr(NotifyAddXml(
- "video1", "Joe", "Facetime", "", "1234")));
+ "video1", "Joe", "Facetime", "1234")));
action_elem->AddElement(
buzz::XmlElement::ForStr(NotifyAddXml(
- "video1", "Bob", "Microsoft Word", "screencast", "2468")));
+ "video1", "Bob", "Microsoft Word", "2468")));
action_elem->AddElement(
buzz::XmlElement::ForStr(NotifyAddXml(
- "video1", "Bob", "", "", "3692")));
+ "video1", "Bob", "", "3692")));
action_elem->AddElement(
buzz::XmlElement::ForStr(NotifyImplicitRemoveXml(
"audio1", "Joe")));
action_elem->AddElement(
- buzz::XmlElement::ForStr(NotifyExplicitRemoveXml(
- "audio1", "Joe", "1234")));
- action_elem->AddElement(
buzz::XmlElement::ForStr(NotifyAddXml(
- "audio1", "Bob", "", "", "3692")));
+ "audio1", "Bob", "", "3692")));
action_elem->AddElement(
buzz::XmlElement::ForStr(NotifyTwoSourceXml(
"video1", "Joe", "1234", "Bob", "2468")));
@@ -261,18 +325,16 @@
&sources, &error));
ASSERT_EQ(5U, sources.video().size());
- ASSERT_EQ(3U, sources.audio().size());
+ ASSERT_EQ(2U, sources.audio().size());
EXPECT_EQ("Joe", sources.video()[0].nick);
EXPECT_EQ("Facetime", sources.video()[0].name);
- EXPECT_EQ("", sources.video()[0].usage);
EXPECT_EQ(1234U, sources.video()[0].ssrc);
EXPECT_TRUE(sources.video()[0].ssrc_set);
EXPECT_FALSE(sources.video()[0].removed);
EXPECT_EQ("Bob", sources.video()[1].nick);
EXPECT_EQ("Microsoft Word", sources.video()[1].name);
- EXPECT_EQ("screencast", sources.video()[1].usage);
EXPECT_EQ(2468U, sources.video()[1].ssrc);
EXPECT_TRUE(sources.video()[1].ssrc_set);
EXPECT_FALSE(sources.video()[0].removed);
@@ -281,7 +343,6 @@
EXPECT_EQ(3692U, sources.video()[2].ssrc);
EXPECT_TRUE(sources.video()[2].ssrc_set);
EXPECT_EQ("", sources.video()[2].name);
- EXPECT_EQ("", sources.video()[2].usage);
EXPECT_FALSE(sources.video()[0].removed);
EXPECT_EQ("Joe", sources.video()[3].nick);
@@ -293,16 +354,6 @@
EXPECT_EQ("Joe", sources.audio()[0].nick);
EXPECT_FALSE(sources.audio()[0].ssrc_set);
EXPECT_FALSE(sources.video()[0].removed);
-
- EXPECT_EQ("Joe", sources.audio()[1].nick);
- EXPECT_TRUE(sources.audio()[1].ssrc_set);
- EXPECT_EQ(1234U, sources.audio()[1].ssrc);
- EXPECT_TRUE(sources.audio()[1].removed);
-
- EXPECT_EQ("Bob", sources.audio()[2].nick);
- EXPECT_EQ(3692U, sources.audio()[2].ssrc);
- EXPECT_TRUE(sources.audio()[2].ssrc_set);
- EXPECT_FALSE(sources.audio()[2].removed);
}
// Test serializing/deserializing a malformed <notify> message.
@@ -314,7 +365,7 @@
talk_base::scoped_ptr<buzz::XmlElement> action_elem(
new buzz::XmlElement(cricket::QN_JINGLE));
action_elem->AddElement(
- buzz::XmlElement::ForStr(NotifyAddXml("video1", "Joe", "", "", "XYZ")));
+ buzz::XmlElement::ForStr(NotifyAddXml("video1", "Joe", "", "XYZ")));
EXPECT_TRUE(cricket::IsSourcesNotify(action_elem.get()));
EXPECT_FALSE(cricket::ParseSourcesNotify(
action_elem.get(), remote_description_.get(), &sources, &error));
@@ -322,10 +373,69 @@
// Bad nick
action_elem.reset(new buzz::XmlElement(cricket::QN_JINGLE));
action_elem->AddElement(
- buzz::XmlElement::ForStr(NotifyAddXml("video1", "", "", "", "1234")));
+ buzz::XmlElement::ForStr(NotifyAddXml("video1", "", "", "1234")));
EXPECT_TRUE(cricket::IsSourcesNotify(action_elem.get()));
EXPECT_FALSE(cricket::ParseSourcesNotify(
action_elem.get(), remote_description_.get(), &sources, &error));
}
+// Test serializing/deserializing typical streams xml.
+TEST_F(MediaMessagesTest, StreamsToFromXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> expected_streams_elem(
+ buzz::XmlElement::ForStr(
+ StreamsXml(
+ StreamXml("nick1", "name1", "101", "102",
+ "semantics1", "type1", "display1"),
+ StreamXml("nick2", "name2", "201", "202",
+ "semantics2", "type2", "display2"))));
+
+ std::vector<cricket::StreamParams> expected_streams;
+ expected_streams.push_back(CreateStream("nick1", "name1", 101U, 102U,
+ "semantics1", "type1", "display1"));
+ expected_streams.push_back(CreateStream("nick2", "name2", 201U, 202U,
+ "semantics2", "type2", "display2"));
+
+ talk_base::scoped_ptr<buzz::XmlElement> actual_desc_elem(
+ new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
+ cricket::WriteJingleStreams(expected_streams, actual_desc_elem.get());
+
+ const buzz::XmlElement* actual_streams_elem =
+ actual_desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
+ ASSERT_TRUE(actual_streams_elem != NULL);
+ EXPECT_EQ(expected_streams_elem->Str(), actual_streams_elem->Str());
+
+ talk_base::scoped_ptr<buzz::XmlElement> expected_desc_elem(
+ new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
+ expected_desc_elem->AddElement(new buzz::XmlElement(
+ *expected_streams_elem));
+ std::vector<cricket::StreamParams> actual_streams;
+ cricket::ParseError parse_error;
+
+ EXPECT_TRUE(cricket::HasJingleStreams(expected_desc_elem.get()));
+ ASSERT_TRUE(cricket::ParseJingleStreams(
+ expected_desc_elem.get(), &actual_streams, &parse_error));
+ EXPECT_EQ(2U, actual_streams.size());
+ EXPECT_EQ(expected_streams[0], actual_streams[0]);
+ EXPECT_EQ(expected_streams[1], actual_streams[1]);
+}
+
+// Test deserializing bad streams xml.
+TEST_F(MediaMessagesTest, StreamsFromBadXml) {
+ talk_base::scoped_ptr<buzz::XmlElement> streams_elem(
+ buzz::XmlElement::ForStr(
+ StreamsXml(
+ StreamXml("nick1", "name1", "101", "not-an-ssrc",
+ "semantics1", "type1", "display1"),
+ StreamXml("nick2", "name2", "202", "not-an-ssrc",
+ "semantics2", "type2", "display2"))));
+ talk_base::scoped_ptr<buzz::XmlElement> desc_elem(
+ new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
+ desc_elem->AddElement(new buzz::XmlElement(*streams_elem));
+
+ std::vector<cricket::StreamParams> actual_streams;
+ cricket::ParseError parse_error;
+ ASSERT_FALSE(cricket::ParseJingleStreams(
+ desc_elem.get(), &actual_streams, &parse_error));
+}
+
} // namespace cricket
diff --git a/talk/session/phone/mediasession.cc b/talk/session/phone/mediasession.cc
index 9bb83e6..05875b5 100644
--- a/talk/session/phone/mediasession.cc
+++ b/talk/session/phone/mediasession.cc
@@ -233,8 +233,12 @@
}
uint32 ssrc = GenerateSsrc(*current_params);
// TODO: Generate the more complex types of stream_params.
- StreamParams stream_param(stream_it->name, ssrc, cname,
- stream_it->sync_label);
+
+ StreamParams stream_param;
+ stream_param.name = stream_it->name;
+ stream_param.ssrcs.push_back(ssrc);
+ stream_param.cname = cname;
+ stream_param.sync_label = stream_it->sync_label;
content_description->AddStream(stream_param);
// Store the new StreamParams in current_params.
@@ -303,8 +307,8 @@
}
if (options.streams.empty()) {
- // TODO: Remove this legacy ssrc when all apps use StreamParams.
- audio->set_ssrc(talk_base::CreateRandomNonZeroId());
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ audio->AddLegacyStream(talk_base::CreateRandomNonZeroId());
}
audio->set_rtcp_mux(true);
audio->set_lang(lang_);
@@ -355,8 +359,8 @@
}
if (options.streams.empty()) {
- // TODO: Remove this legacy ssrc when all apps use StreamParams.
- video->set_ssrc(talk_base::CreateRandomNonZeroId());
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ video->AddLegacyStream(talk_base::CreateRandomNonZeroId());
}
video->set_bandwidth(options.video_bandwidth);
video->set_rtcp_mux(true);
@@ -429,8 +433,8 @@
}
if (options.streams.empty()) {
- // TODO: Remove this legacy ssrc when all apps use StreamParams.
- audio_accept->set_ssrc(talk_base::CreateRandomNonZeroId());
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ audio_accept->AddLegacyStream(talk_base::CreateRandomNonZeroId());
}
audio_accept->set_rtcp_mux(audio_offer->rtcp_mux());
@@ -493,8 +497,8 @@
}
if (options.streams.empty()) {
- // TODO: Remove this legacy ssrc when all apps use StreamParams.
- video_accept->set_ssrc(talk_base::CreateRandomNonZeroId());
+ // TODO: Remove this legacy stream when all apps use StreamParams.
+ video_accept->AddLegacyStream(talk_base::CreateRandomNonZeroId());
}
video_accept->set_bandwidth(options.video_bandwidth);
video_accept->set_rtcp_mux(video_offer->rtcp_mux());
@@ -579,5 +583,3 @@
}
} // namespace cricket
-
-
diff --git a/talk/session/phone/mediasession.h b/talk/session/phone/mediasession.h
index ea4acd7..127a7ed 100644
--- a/talk/session/phone/mediasession.h
+++ b/talk/session/phone/mediasession.h
@@ -114,23 +114,15 @@
class MediaContentDescription : public ContentDescription {
public:
MediaContentDescription()
- : ssrc_(0),
- ssrc_set_(false),
- rtcp_mux_(false),
+ : rtcp_mux_(false),
bandwidth_(kAutoBandwidth),
crypto_required_(false),
- rtp_header_extensions_set_(false) {
+ rtp_header_extensions_set_(false),
+ multistream_(false) {
}
virtual MediaType type() const = 0;
- uint32 ssrc() const { return ssrc_; }
- bool ssrc_set() const { return ssrc_set_; }
- void set_ssrc(uint32 ssrc) {
- ssrc_ = ssrc;
- ssrc_set_ = true;
- }
-
bool rtcp_mux() const { return rtcp_mux_; }
void set_rtcp_mux(bool mux) { rtcp_mux_ = mux; }
@@ -165,22 +157,46 @@
bool rtp_header_extensions_set() const {
return rtp_header_extensions_set_;
}
+ // True iff the client supports multiple streams.
+ void set_multistream(bool multistream) { multistream_ = multistream; }
+ bool multistream() const { return multistream_; }
const StreamParamsVec& streams() const {
return streams_;
}
+ // TODO: Remove this by giving mediamessage.cc access
+ // to MediaContentDescription
+ StreamParamsVec& mutable_streams() {
+ return streams_;
+ }
void AddStream(const StreamParams& stream) {
streams_.push_back(stream);
}
+ // Legacy streams have an ssrc, but nothing else.
+ void AddLegacyStream(uint32 ssrc) {
+ streams_.push_back(StreamParams::CreateLegacy(ssrc));
+ }
+
+ uint32 first_ssrc() const {
+ if (streams_.empty()) {
+ return 0;
+ }
+ return streams_[0].first_ssrc();
+ }
+ bool has_ssrcs() const {
+ if (streams_.empty()) {
+ return false;
+ }
+ return streams_[0].has_ssrcs();
+ }
protected:
- uint32 ssrc_;
- bool ssrc_set_;
bool rtcp_mux_;
int bandwidth_;
std::vector<CryptoParams> cryptos_;
bool crypto_required_;
std::vector<RtpHeaderExtension> rtp_header_extensions_;
bool rtp_header_extensions_set_;
+ bool multistream_;
StreamParamsVec streams_;
};
@@ -285,5 +301,3 @@
} // namespace cricket
#endif // TALK_SESSION_PHONE_MEDIASESSION_H_
-
-
diff --git a/talk/session/phone/mediasession_unittest.cc b/talk/session/phone/mediasession_unittest.cc
index 8b083a3..36fedc6 100644
--- a/talk/session/phone/mediasession_unittest.cc
+++ b/talk/session/phone/mediasession_unittest.cc
@@ -137,10 +137,13 @@
ssrc_groups.push_back(fec_group2);
ssrc_groups.push_back(fec_group3);
- StreamParams simulcast_params(kVideoTrack1,
- MAKE_VECTOR(kSimulcastParamsSsrc),
- ssrc_groups, "Video_SIM_FEC",
- kMediaStream1);
+ StreamParams simulcast_params;
+ simulcast_params.name = kVideoTrack1;
+ simulcast_params.ssrcs = MAKE_VECTOR(kSimulcastParamsSsrc);
+ simulcast_params.ssrc_groups = ssrc_groups;
+ simulcast_params.cname = "Video_SIM_FEC";
+ simulcast_params.sync_label = kMediaStream1;
+
StreamParamsVec video_streams;
video_streams.push_back(simulcast_params);
@@ -178,7 +181,7 @@
static_cast<const AudioContentDescription*>(ac->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
- EXPECT_NE(0U, acd->ssrc()); // a random nonzero ssrc
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
ASSERT_CRYPTO(acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
@@ -204,13 +207,13 @@
static_cast<const VideoContentDescription*>(vc->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
- EXPECT_NE(0U, acd->ssrc()); // a random nonzero ssrc
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
ASSERT_CRYPTO(acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
- EXPECT_NE(0U, vcd->ssrc()); // a random nonzero ssrc
+ EXPECT_NE(0U, vcd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
@@ -234,7 +237,7 @@
static_cast<const AudioContentDescription*>(ac->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
- EXPECT_NE(0U, acd->ssrc()); // a random nonzero ssrc
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
ASSERT_CRYPTO(acd, false, 1U, CS_AES_CM_128_HMAC_SHA1_32);
@@ -263,12 +266,12 @@
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
- EXPECT_NE(0U, acd->ssrc()); // a random nonzero ssrc
+ EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
ASSERT_CRYPTO(acd, false, 1U, CS_AES_CM_128_HMAC_SHA1_32);
EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
- EXPECT_NE(0U, vcd->ssrc()); // a random nonzero ssrc
+ EXPECT_NE(0U, vcd->first_ssrc()); // a random nonzero ssrc
EXPECT_TRUE(vcd->rtcp_mux()); // negotiated rtcp-mux
ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
}
@@ -324,7 +327,6 @@
ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
- EXPECT_EQ(0U, acd->ssrc()); // 0- not used.
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
ASSERT_CRYPTO(acd, false, 2U, CS_AES_CM_128_HMAC_SHA1_32);
@@ -337,7 +339,6 @@
ASSERT_EQ(1U, video_streams.size());
EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
EXPECT_EQ(kVideoTrack1, video_streams[0].name);
- EXPECT_EQ(0U, vcd->ssrc()); // 0- not used.
EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
@@ -429,7 +430,6 @@
ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
- EXPECT_EQ(0U, acd->ssrc()); // 0- not used.
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
@@ -440,7 +440,6 @@
ASSERT_EQ(1U, video_streams.size());
EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
EXPECT_EQ(kVideoTrack1, video_streams[0].name);
- EXPECT_EQ(0U, vcd->ssrc()); // 0- not used.
EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
diff --git a/talk/session/phone/mediasessionclient.cc b/talk/session/phone/mediasessionclient.cc
index f20b0f0..c7d8c88 100644
--- a/talk/session/phone/mediasessionclient.cc
+++ b/talk/session/phone/mediasessionclient.cc
@@ -36,6 +36,7 @@
#include "talk/p2p/base/constants.h"
#include "talk/p2p/base/parsing.h"
#include "talk/session/phone/cryptoparams.h"
+#include "talk/session/phone/mediamessages.h"
#include "talk/session/phone/srtpfilter.h"
#include "talk/xmpp/constants.h"
#include "talk/xmllite/qname.h"
@@ -198,6 +199,8 @@
return session;
}
+// TODO: Move all of the parsing and writing functions into
+// mediamessages.cc, with unit tests.
bool ParseGingleAudioCodec(const buzz::XmlElement* element, AudioCodec* out) {
int id = GetXmlAttr(element, QN_ID, -1);
if (id < 0)
@@ -225,26 +228,30 @@
return true;
}
-uint32 parse_ssrc(const std::string& ssrc) {
- // TODO: Return an error rather than defaulting to 0.
- uint32 default_ssrc = 0U;
- return talk_base::FromString(default_ssrc, ssrc);
+// Parses an ssrc string as a legacy stream. If it fails, returns
+// false and fills an error message.
+bool ParseSsrcAsLegacyStream(const std::string& ssrc_str,
+ std::vector<StreamParams>* streams,
+ ParseError* error) {
+ if (!ssrc_str.empty()) {
+ uint32 ssrc;
+ if (!talk_base::FromString(ssrc_str, &ssrc)) {
+ return BadParse("Missing or invalid ssrc.", error);
+ }
+
+ streams->push_back(StreamParams::CreateLegacy(ssrc));
+ }
+ return true;
}
void ParseGingleSsrc(const buzz::XmlElement* parent_elem,
const buzz::QName& name,
- MediaContentDescription* content) {
+ MediaContentDescription* media) {
const buzz::XmlElement* ssrc_elem = parent_elem->FirstNamed(name);
if (ssrc_elem) {
- content->set_ssrc(parse_ssrc(ssrc_elem->BodyText()));
- }
-}
-
-void ParseJingleSsrc(const buzz::XmlElement* desc_elem,
- MediaContentDescription* content) {
- const std::string ssrc = desc_elem->Attr(QN_JINGLE_SSRC);
- if (!ssrc.empty()) {
- content->set_ssrc(parse_ssrc(ssrc));
+ ParseError error;
+ ParseSsrcAsLegacyStream(
+ ssrc_elem->BodyText(), &(media->mutable_streams()), &error);
}
}
@@ -454,6 +461,23 @@
return true;
}
+bool ParseJingleStreamsOrLegacySsrc(const buzz::XmlElement* desc_elem,
+ MediaContentDescription* media,
+ ParseError* error) {
+ if (HasJingleStreams(desc_elem)) {
+ if (!ParseJingleStreams(desc_elem, &(media->mutable_streams()), error)) {
+ return false;
+ }
+ } else {
+ const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
+ if (!ParseSsrcAsLegacyStream(
+ ssrc_str, &(media->mutable_streams()), error)) {
+ return false;
+ }
+ }
+ return true;
+}
+
bool ParseJingleAudioContent(const buzz::XmlElement* content_elem,
const ContentDescription** content,
ParseError* error) {
@@ -469,12 +493,13 @@
}
}
- ParseJingleSsrc(content_elem, audio);
+ if (!ParseJingleStreamsOrLegacySsrc(content_elem, audio, error)) {
+ return false;
+ }
if (!ParseJingleEncryption(content_elem, audio, error)) {
return false;
}
- // TODO: Figure out how to integrate SSRC into Jingle.
*content = audio;
return true;
}
@@ -494,13 +519,14 @@
}
}
- ParseJingleSsrc(content_elem, video);
+ if (!ParseJingleStreamsOrLegacySsrc(content_elem, video, error)) {
+ return false;
+ }
ParseBandwidth(content_elem, video);
if (!ParseJingleEncryption(content_elem, video, error)) {
return false;
}
- // TODO: Figure out how to integrate SSRC into Jingle.
*content = video;
return true;
}
@@ -625,9 +651,9 @@
codec != audio->codecs().end(); ++codec) {
elem->AddElement(CreateGingleAudioCodecElem(*codec));
}
- if (audio->ssrc_set()) {
+ if (audio->has_ssrcs()) {
elem->AddElement(CreateGingleSsrcElem(
- QN_GINGLE_AUDIO_SRCID, audio->ssrc()));
+ QN_GINGLE_AUDIO_SRCID, audio->first_ssrc()));
}
const CryptoParamsVec& cryptos = audio->cryptos();
@@ -649,9 +675,9 @@
codec != video->codecs().end(); ++codec) {
elem->AddElement(CreateGingleVideoCodecElem(*codec));
}
- if (video->ssrc_set()) {
+ if (video->has_ssrcs()) {
elem->AddElement(CreateGingleSsrcElem(
- QN_GINGLE_VIDEO_SRCID, video->ssrc()));
+ QN_GINGLE_VIDEO_SRCID, video->first_ssrc()));
}
if (video->bandwidth() != kAutoBandwidth) {
elem->AddElement(CreateBandwidthElem(QN_GINGLE_VIDEO_BANDWIDTH,
@@ -712,15 +738,19 @@
return elem;
}
-void WriteJingleSsrc(const MediaContentDescription* media,
- buzz::XmlElement* elem) {
- // TODO: Right now, we have an ssrc=0 to mean "let the
- // server choose". In Jingle, it would make the most sense to just
- // leave off the attribute. But then we can't have an ssrc of 0.
- // Once we have initiator-choosen ssrcs, we can remove this check
- // and write out ssrc=0.
- if (media->ssrc_set() && (media->ssrc() != 0)) {
- AddXmlAttr(elem, QN_JINGLE_SSRC, media->ssrc());
+void WriteLegacyJingleSsrc(const MediaContentDescription* media,
+ buzz::XmlElement* elem) {
+ if (media->has_ssrcs()) {
+ AddXmlAttr(elem, QN_SSRC, media->first_ssrc());
+ }
+}
+
+void WriteJingleStreamsOrLegacySsrc(const MediaContentDescription* media,
+ buzz::XmlElement* desc_elem) {
+ if (!media->multistream()) {
+ WriteLegacyJingleSsrc(media, desc_elem);
+ } else {
+ WriteJingleStreams(media->streams(), desc_elem);
}
}
@@ -730,7 +760,7 @@
new buzz::XmlElement(QN_JINGLE_RTP_CONTENT, true);
elem->SetAttr(QN_JINGLE_CONTENT_MEDIA, JINGLE_CONTENT_MEDIA_AUDIO);
- WriteJingleSsrc(audio, elem);
+ WriteJingleStreamsOrLegacySsrc(audio, elem);
for (AudioCodecs::const_iterator codec = audio->codecs().begin();
codec != audio->codecs().end(); ++codec) {
@@ -755,7 +785,7 @@
new buzz::XmlElement(QN_JINGLE_RTP_CONTENT, true);
elem->SetAttr(QN_JINGLE_CONTENT_MEDIA, JINGLE_CONTENT_MEDIA_VIDEO);
- WriteJingleSsrc(video, elem);
+ WriteJingleStreamsOrLegacySsrc(video, elem);
for (VideoCodecs::const_iterator codec = video->codecs().begin();
codec != video->codecs().end(); ++codec) {
diff --git a/talk/session/phone/ssrcmuxfilter.cc b/talk/session/phone/ssrcmuxfilter.cc
index 76245f2..2f3e1f2 100644
--- a/talk/session/phone/ssrcmuxfilter.cc
+++ b/talk/session/phone/ssrcmuxfilter.cc
@@ -35,6 +35,8 @@
namespace cricket {
+static const uint32 kSsrc01 = 0x01;
+
SsrcMuxFilter::SsrcMuxFilter()
: state_(ST_INIT),
enabled_(false) {
@@ -88,10 +90,16 @@
if (!GetRtcpType(data, len, &pl_type)) return false;
if (pl_type == kRtcpTypeSR || pl_type == kRtcpTypeRR) {
// Getting SSRC from the report packets.
- GetRtcpSsrc(data, len, &ssrc);
+ if (!GetRtcpSsrc(data, len, &ssrc)) return false;
+ if (ssrc == kSsrc01) {
+ // SSRC 1 has a special meaning and indicates generic feedback on
+ // some systems and should never be dropped. If it is forwarded
+ // incorrectly it will be ignored by lower layers anyway.
+ return true;
+ }
} else {
// All other RTCP packets are handled by the all channels.
- // TODO - Add SSRC parsing to all RTCP messages.
+ // TODO: Add SSRC parsing to all RTCP messages.
LOG(LS_INFO) << "Non RTCP report packet received for demux.";
return true;
}
diff --git a/talk/session/phone/streamparams.h b/talk/session/phone/streamparams.h
index 527d9b7..ec4b380 100644
--- a/talk/session/phone/streamparams.h
+++ b/talk/session/phone/streamparams.h
@@ -52,6 +52,7 @@
SsrcGroup(const std::string& usage, const std::vector<uint32>& ssrcs)
: semantics(usage), ssrcs(ssrcs) {
}
+
bool operator==(const SsrcGroup& other) const {
return (semantics == other.semantics && ssrcs == other.ssrcs);
}
@@ -64,38 +65,48 @@
};
struct StreamParams {
- StreamParams(const std::string& name,
- const std::vector<uint32>& ssrcs,
- const std::vector<SsrcGroup>& ssrc_groups,
- const std::string& cname,
- const std::string& sync_label)
- : name(name),
- ssrcs(ssrcs),
- ssrc_groups(ssrc_groups),
- cname(cname),
- sync_label(sync_label) {
- }
- StreamParams(const std::string& name,
- uint32 ssrc,
- const std::string& cname,
- const std::string& sync_label)
- : name(name),
- cname(cname),
- sync_label(sync_label) {
- ssrcs.push_back(ssrc);
+ static StreamParams CreateLegacy(uint32 ssrc) {
+ StreamParams stream;
+ stream.ssrcs.push_back(ssrc);
+ return stream;
}
bool operator==(const StreamParams& other) const {
- return (name == other.name && ssrcs == other.ssrcs &&
- ssrc_groups == other.ssrc_groups && cname == other.cname &&
- sync_label == sync_label);
+ return (nick == other.nick &&
+ name == other.name &&
+ ssrcs == other.ssrcs &&
+ ssrc_groups == other.ssrc_groups &&
+ type == other.type &&
+ display == other.display &&
+ cname == other.cname &&
+ sync_label == sync_label);
}
bool operator!=(const StreamParams &other) const {
return !(*this == other);
}
- std::string name; // Unique name of this source.
+ uint32 first_ssrc() const {
+ if (ssrcs.empty()) {
+ return 0;
+ }
+
+ return ssrcs[0];
+ }
+ bool has_ssrcs() const {
+ return !ssrcs.empty();
+ }
+
+ // Resource of the MUC jid of the participant of with this stream.
+ // For 1:1 calls, should be left empty (which means remote streams
+ // and local streams should not be mixed together).
+ std::string nick;
+ // Unique name of this source (unique per-nick, not for all nicks)
+ std::string name;
std::vector<uint32> ssrcs; // All SSRCs for this source
std::vector<SsrcGroup> ssrc_groups; // e.g. FID, FEC, SIM
+ // Examples: "camera", "screencast"
+ std::string type;
+ // Friendly name describing stream
+ std::string display;
std::string cname; // RTCP CNAME
std::string sync_label; // Friendly name of cname.
};
diff --git a/talk/session/phone/webrtcvideoengine.cc b/talk/session/phone/webrtcvideoengine.cc
index 3460e49..046ae5f 100644
--- a/talk/session/phone/webrtcvideoengine.cc
+++ b/talk/session/phone/webrtcvideoengine.cc
@@ -33,6 +33,7 @@
#include "talk/session/phone/webrtcvideoengine.h"
+#include "talk/base/basictypes.h"
#include "talk/base/common.h"
#include "talk/base/buffer.h"
#include "talk/base/byteorder.h"
@@ -53,7 +54,8 @@
static const int kDefaultLogSeverity = talk_base::LS_WARNING;
-static const int kMinVideoBitrate = 300;
+static const int kMinVideoBitrate = 100;
+static const int kStartVideoBitrate = 300;
static const int kMaxVideoBitrate = 2000;
static const int kVideoMtu = 1200;
@@ -772,9 +774,9 @@
out_codec.maxFramerate = in_codec.framerate;
// Init the codec with the default bandwidth options.
- out_codec.maxBitrate = kMaxVideoBitrate;
- out_codec.startBitrate = kMinVideoBitrate;
out_codec.minBitrate = kMinVideoBitrate;
+ out_codec.startBitrate = kStartVideoBitrate;
+ out_codec.maxBitrate = kMaxVideoBitrate;
return true;
}
@@ -946,6 +948,7 @@
render_started_(false),
muted_(false),
send_min_bitrate_(kMinVideoBitrate),
+ send_start_bitrate_(kStartVideoBitrate),
send_max_bitrate_(kMaxVideoBitrate),
local_stream_info_(new LocalStreamInfo()) {
engine->RegisterChannel(this);
@@ -1171,7 +1174,8 @@
kDefaultNumberOfTemporalLayers;
}
- if (!SetSendCodec(codec, send_min_bitrate_, send_max_bitrate_)) {
+ if (!SetSendCodec(
+ codec, send_min_bitrate_, send_start_bitrate_, send_max_bitrate_)) {
return false;
}
@@ -1420,21 +1424,25 @@
return true;
}
- int min_bitrate = kMinVideoBitrate;
- int max_bitrate = kMaxVideoBitrate;
+ int min_bitrate;
+ int start_bitrate;
+ int max_bitrate;
if (autobw) {
- // Use the default values as min
+ // Use the default values for min bitrate.
min_bitrate = kMinVideoBitrate;
// Use the default value or the bps for the max
max_bitrate = (bps <= 0) ? kMaxVideoBitrate : (bps / 1000);
+ // Maximum start bitrate can be kStartVideoBitrate.
+ start_bitrate = talk_base::_min(kStartVideoBitrate, max_bitrate);
} else {
// Use the default start or the bps as the target bitrate.
- int target_bitrate = (bps <= 0) ? kMinVideoBitrate : (bps / 1000);
+ int target_bitrate = (bps <= 0) ? kStartVideoBitrate : (bps / 1000);
min_bitrate = target_bitrate;
+ start_bitrate = target_bitrate;
max_bitrate = target_bitrate;
}
- if (!SetSendCodec(*send_codec_, min_bitrate, max_bitrate)) {
+ if (!SetSendCodec(*send_codec_, min_bitrate, start_bitrate, max_bitrate)) {
return false;
}
@@ -1467,6 +1475,23 @@
// Update local stream statistics.
local_stream_info_->UpdateFrame(frame->GetWidth(), frame->GetHeight());
+ // If the captured video format is smaller than what we asked for, reset send
+ // codec on video engine.
+ if (send_codec_.get() != NULL &&
+ frame->GetWidth() < send_codec_->width &&
+ frame->GetHeight() < send_codec_->height) {
+ LOG(LS_INFO) << "Captured video frame size changed to: "
+ << frame->GetWidth() << "x" << frame->GetHeight();
+ webrtc::VideoCodec new_codec = *send_codec_;
+ new_codec.width = frame->GetWidth();
+ new_codec.height = frame->GetHeight();
+ if (!SetSendCodec(
+ new_codec, send_min_bitrate_, send_start_bitrate_, send_max_bitrate_)) {
+ LOG(LS_WARNING) << "Failed to switch to new frame size: "
+ << frame->GetWidth() << "x" << frame->GetHeight();
+ }
+ }
+
// Blacken the frame if video is muted.
const VideoFrame* frame_out = frame;
talk_base::scoped_ptr<VideoFrame> black_frame;
@@ -1543,10 +1568,12 @@
}
bool WebRtcVideoMediaChannel::SetSendCodec(const webrtc::VideoCodec& codec,
- int min_bitrate, int max_bitrate) {
+ int min_bitrate,
+ int start_bitrate,
+ int max_bitrate) {
// Make a copy of the codec
webrtc::VideoCodec target_codec = codec;
- target_codec.startBitrate = min_bitrate;
+ target_codec.startBitrate = start_bitrate;
target_codec.minBitrate = min_bitrate;
target_codec.maxBitrate = max_bitrate;
@@ -1558,6 +1585,7 @@
// Reset the send_codec_ only if SetSendCodec is success.
send_codec_.reset(new webrtc::VideoCodec(target_codec));
send_min_bitrate_ = min_bitrate;
+ send_start_bitrate_ = start_bitrate;
send_max_bitrate_ = max_bitrate;
return true;
diff --git a/talk/session/phone/webrtcvideoengine.h b/talk/session/phone/webrtcvideoengine.h
index eb2caa9..be8c5f0 100644
--- a/talk/session/phone/webrtcvideoengine.h
+++ b/talk/session/phone/webrtcvideoengine.h
@@ -267,7 +267,9 @@
bool EnableNack();
bool SetNackFec(int red_payload_type, int fec_payload_type);
bool SetSendCodec(const webrtc::VideoCodec& codec,
- int min_bitrate, int max_bitrate);
+ int min_bitrate,
+ int start_bitrate,
+ int max_bitrate);
bool ResetRecvCodecs(int channel);
WebRtcVideoEngine* engine_;
@@ -279,6 +281,7 @@
bool render_started_;
bool muted_; // Flag to tell if we need to mute video.
int send_min_bitrate_;
+ int send_start_bitrate_;
int send_max_bitrate_;
talk_base::scoped_ptr<webrtc::VideoCodec> send_codec_;
talk_base::scoped_ptr<WebRtcRenderAdapter> remote_renderer_;
diff --git a/talk/session/phone/webrtcvideoengine_unittest.cc b/talk/session/phone/webrtcvideoengine_unittest.cc
index 0c1fa4b..ad11f20 100644
--- a/talk/session/phone/webrtcvideoengine_unittest.cc
+++ b/talk/session/phone/webrtcvideoengine_unittest.cc
@@ -34,6 +34,7 @@
#include "talk/session/phone/videoengine_unittest.h"
#include "talk/session/phone/webrtcvideocapturer.h"
#include "talk/session/phone/webrtcvideoengine.h"
+#include "talk/session/phone/webrtcvideoframe.h"
#include "talk/session/phone/webrtcvoiceengine.h"
// Tests for the WebRtcVideoEngine/VideoChannel code.
@@ -47,7 +48,8 @@
&kUlpFecCodec
};
-static const unsigned int kMinBandwidthKbps = 300;
+static const unsigned int kMinBandwidthKbps = 100;
+static const unsigned int kStartBandwidthKbps = 300;
static const unsigned int kMaxBandwidthKbps = 2000;
class FakeViEWrapper : public cricket::ViEWrapper {
@@ -171,7 +173,7 @@
EXPECT_EQ(kVP8Codec.height, gcodec.height);
EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
- EXPECT_EQ(kMinBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
EXPECT_EQ(kMaxBandwidthKbps, gcodec.maxBitrate);
// TODO: Check HybridNackFecStatus.
// TODO: Check RTCP, PLI, TMMBR.
@@ -250,6 +252,40 @@
EXPECT_EQ(0, gcodec.plType);
}
+// Test that send codec is reset if the captured frame is smaller.
+TEST_F(WebRtcVideoEngineTestFake, ResetSendCodecOnSmallerFrame) {
+ EXPECT_TRUE(SetupEngine());
+ int channel_num = vie_.GetLastChannel();
+
+ const int old_w = 640;
+ const int old_h = 400;
+ const int new_w = 160;
+ const int new_h = 100;
+
+ // Set send codec and start sending.
+ cricket::VideoCodec codec(kVP8Codec);
+ codec.width = old_w;
+ codec.height = old_h;
+ std::vector<cricket::VideoCodec> codec_list;
+ codec_list.push_back(codec);
+ EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
+ EXPECT_TRUE(channel_->SetSend(true));
+
+ // Capture a smaller frame.
+ cricket::WebRtcVideoFrame frame;
+ uint8 pixel[new_w * new_h * 3 / 2] = { 0 }; // I420
+ EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, new_w, new_h, new_w, new_h,
+ pixel, sizeof(pixel), 1, 1, 0, 0, 0));
+ EXPECT_TRUE(channel_->SendFrame(0, &frame));
+
+ // Verify the send codec has been reset to the new format.
+ webrtc::VideoCodec gcodec;
+ EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+ EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+ EXPECT_EQ(new_w, gcodec.width);
+ EXPECT_EQ(new_h, gcodec.height);
+}
+
// Test that we set our inbound codecs properly.
TEST_F(WebRtcVideoEngineTestFake, SetRecvCodecs) {
EXPECT_TRUE(SetupEngine());
@@ -367,7 +403,7 @@
EXPECT_EQ(kVP8Codec.id, gcodec.plType);
EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
- EXPECT_EQ(kMinBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
EXPECT_EQ(kMaxBandwidthKbps, gcodec.maxBitrate);
}
@@ -382,7 +418,7 @@
EXPECT_EQ(kVP8Codec.id, gcodec.plType);
EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
EXPECT_EQ(kMinBandwidthKbps, gcodec.minBitrate);
- EXPECT_EQ(kMinBandwidthKbps, gcodec.startBitrate);
+ EXPECT_EQ(kStartBandwidthKbps, gcodec.startBitrate);
EXPECT_EQ(768U, gcodec.maxBitrate);
}
diff --git a/talk/session/phone/webrtcvideoframe.cc b/talk/session/phone/webrtcvideoframe.cc
index e12771d..2562ed5 100644
--- a/talk/session/phone/webrtcvideoframe.cc
+++ b/talk/session/phone/webrtcvideoframe.cc
@@ -27,14 +27,10 @@
#include "talk/session/phone/webrtcvideoframe.h"
+#include "libyuv/planar_functions.h"
#include "talk/base/logging.h"
#include "talk/session/phone/videocapturer.h"
#include "talk/session/phone/videocommon.h"
-#ifdef WEBRTC_RELATIVE_PATH
-#include "common_video/vplib/main/interface/vplib.h"
-#else
-#include "third_party/webrtc/files/include/vplib.h"
-#endif
namespace cricket {
@@ -217,10 +213,11 @@
return needed;
}
+// TODO: Refactor into base class and share with lmi
size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32 to_fourcc,
uint8* buffer,
size_t size,
- size_t pitch_rgb) const {
+ size_t stride_rgb) const {
if (!video_frame_.Buffer()) {
return 0;
}
@@ -231,29 +228,44 @@
// explanation of pitch and why this is the amount of space we need.
// TODO: increase to stride * height to allow padding to be used
// to overwrite for efficiency.
- size_t needed = pitch_rgb * (height - 1) + 4 * width;
+ size_t needed = stride_rgb * (height - 1) + 4 * width;
if (needed > size) {
LOG(LS_WARNING) << "RGB buffer is not large enough";
- return 0;
+ return needed;
}
- webrtc::VideoType to_type = webrtc::kUnknown;
+ // TODO: Use libyuv::ConvertFromI420
switch (to_fourcc) {
case FOURCC_ARGB:
- to_type = webrtc::kARGB;
+ libyuv::I420ToARGB(
+ GetYPlane(), GetYPitch(),
+ GetUPlane(), GetUPitch(),
+ GetVPlane(), GetVPitch(),
+ buffer, stride_rgb, width, height);
break;
+
+ case FOURCC_BGRA:
+ libyuv::I420ToBGRA(
+ GetYPlane(), GetYPitch(),
+ GetUPlane(), GetUPitch(),
+ GetVPlane(), GetVPitch(),
+ buffer, stride_rgb, width, height);
+ break;
+
+ case FOURCC_ABGR:
+ libyuv::I420ToABGR(
+ GetYPlane(), GetYPitch(),
+ GetUPlane(), GetUPitch(),
+ GetVPlane(), GetVPitch(),
+ buffer, stride_rgb, width, height);
+ break;
+
default:
+ needed = 0;
LOG(LS_WARNING) << "RGB type not supported: " << to_fourcc;
- return 0;
+ break;
}
-
- if (to_type != webrtc::kUnknown) {
- // TODO: Use libyuv::ConvertFromI420
- webrtc::ConvertFromI420(to_type, video_frame_.Buffer(),
- width, height, buffer);
- }
-
return needed;
}
diff --git a/talk/session/phone/webrtcvideoframe_unittest.cc b/talk/session/phone/webrtcvideoframe_unittest.cc
index 7b057e5..c4526c0 100644
--- a/talk/session/phone/webrtcvideoframe_unittest.cc
+++ b/talk/session/phone/webrtcvideoframe_unittest.cc
@@ -57,8 +57,10 @@
// Re-evaluate once WebRTC switches to libyuv
// TEST_LMIVIDEOFRAME(ConstructYuy2AllSizes)
// TODO: WebRtcVideoFrame currently only supports ARGB output.
-// TEST_WEBRTCVIDEOFRAME(ConvertToBGRABuffer)
-// TEST_WEBRTCVIDEOFRAME(ConvertToABGRBuffer)
+#ifdef HAVE_YUV
+TEST_WEBRTCVIDEOFRAME(ConvertToBGRABuffer)
+TEST_WEBRTCVIDEOFRAME(ConvertToABGRBuffer)
+#endif
TEST_WEBRTCVIDEOFRAME(ConvertToARGBBuffer)
//TEST_WEBRTCVIDEOFRAME(ConvertToYUY2Buffer)
//TEST_WEBRTCVIDEOFRAME(ConvertToI422Buffer)
diff --git a/talk/session/phone/webrtcvoiceengine.cc b/talk/session/phone/webrtcvoiceengine.cc
index cfe7345..561c13c 100644
--- a/talk/session/phone/webrtcvoiceengine.cc
+++ b/talk/session/phone/webrtcvoiceengine.cc
@@ -1410,9 +1410,8 @@
}
}
-// This api is currently present but nonfunctional in WebRTC VoiceEngine.
// This api call is not available in iOS version of VoiceEngine currently.
-#if 0 // !defined(IOS) && !defined(ANDROID)
+#if !defined(IOS) && !defined(ANDROID)
if (engine()->voe()->rtp()->SetRTPAudioLevelIndicationStatus(
voe_channel(), enable, id) == -1) {
LOG_RTCERR3(SetRTPAudioLevelIndicationStatus, voe_channel(), enable, id);
diff --git a/talk/session/phone/webrtcvoiceengine_unittest.cc b/talk/session/phone/webrtcvoiceengine_unittest.cc
index b1b1783..6bcc04e 100644
--- a/talk/session/phone/webrtcvoiceengine_unittest.cc
+++ b/talk/session/phone/webrtcvoiceengine_unittest.cc
@@ -4,11 +4,11 @@
#include "talk/base/byteorder.h"
#include "talk/base/gunit.h"
+#include "talk/p2p/base/fakesession.h"
#include "talk/session/phone/channel.h"
#include "talk/session/phone/fakemediaengine.h"
#include "talk/session/phone/fakemediaprocessor.h"
#include "talk/session/phone/fakertp.h"
-#include "talk/session/phone/fakesession.h"
#include "talk/session/phone/fakewebrtcvoiceengine.h"
#include "talk/session/phone/webrtcvoiceengine.h"
@@ -558,9 +558,8 @@
EXPECT_FALSE(enable);
}
-// TODO: Re-enable this test once audio level status is restored.
// Test that we support setting certain send header extensions.
-TEST_F(WebRtcVoiceEngineTestFake, DISABLED_SetSendRtpHeaderExtensions) {
+TEST_F(WebRtcVoiceEngineTestFake, SetSendRtpHeaderExtensions) {
EXPECT_TRUE(SetupEngine());
std::vector<cricket::RtpHeaderExtension> extensions;
int channel_num = voe_.GetLastChannel();
diff --git a/talk/xmllite/xmlelement.cc b/talk/xmllite/xmlelement.cc
index 6a0e8e8..7b208e6 100644
--- a/talk/xmllite/xmlelement.cc
+++ b/talk/xmllite/xmlelement.cc
@@ -521,7 +521,7 @@
std::string
XmlElement::Str() const {
std::stringstream ss;
- Print(&ss, NULL, 0);
+ XmlPrinter::PrintXml(&ss, this);
return ss.str();
}
@@ -532,12 +532,6 @@
return builder.CreateElement();
}
-void
-XmlElement::Print(
- std::ostream * pout, std::string xmlns[], int xmlnsCount) const {
- XmlPrinter::PrintXml(pout, this, xmlns, xmlnsCount);
-}
-
XmlElement::~XmlElement() {
XmlAttr * pattr;
for (pattr = pFirstAttr_; pattr; ) {
diff --git a/talk/xmllite/xmlelement.h b/talk/xmllite/xmlelement.h
index f50985a..7cb30f3 100644
--- a/talk/xmllite/xmlelement.h
+++ b/talk/xmllite/xmlelement.h
@@ -223,8 +223,6 @@
static XmlElement * ForStr(const std::string & str);
std::string Str() const;
- void Print(std::ostream * pout, std::string xmlns[], int xmlnsCount) const;
-
bool IsCDATA() const { return cdata_; }
protected:
diff --git a/talk/xmllite/xmlprinter.cc b/talk/xmllite/xmlprinter.cc
index 691419c..1350454 100644
--- a/talk/xmllite/xmlprinter.cc
+++ b/talk/xmllite/xmlprinter.cc
@@ -39,117 +39,111 @@
class XmlPrinterImpl {
public:
- XmlPrinterImpl(std::ostream * pout,
- const std::string * const xmlns, int xmlnsCount);
- void PrintElement(const XmlElement * element);
- void PrintQuotedValue(const std::string & text);
- void PrintBodyText(const std::string & text);
- void PrintCDATAText(const std::string & text);
+ XmlPrinterImpl(std::ostream* pout, XmlnsStack* ns_stack);
+ void PrintElement(const XmlElement* element);
+ void PrintQuotedValue(const std::string& text);
+ void PrintBodyText(const std::string& text);
+ void PrintCDATAText(const std::string& text);
private:
std::ostream *pout_;
- XmlnsStack xmlnsStack_;
+ XmlnsStack* ns_stack_;
};
-void
-XmlPrinter::PrintXml(std::ostream * pout, const XmlElement * element) {
- PrintXml(pout, element, NULL, 0);
+void XmlPrinter::PrintXml(std::ostream* pout, const XmlElement* element) {
+ XmlnsStack ns_stack;
+ PrintXml(pout, element, &ns_stack);
}
-void
-XmlPrinter::PrintXml(std::ostream * pout, const XmlElement * element,
- const std::string * const xmlns, int xmlnsCount) {
- XmlPrinterImpl printer(pout, xmlns, xmlnsCount);
+void XmlPrinter::PrintXml(std::ostream* pout, const XmlElement* element,
+ XmlnsStack* ns_stack) {
+ XmlPrinterImpl printer(pout, ns_stack);
printer.PrintElement(element);
}
-XmlPrinterImpl::XmlPrinterImpl(std::ostream * pout,
- const std::string * const xmlns, int xmlnsCount) :
- pout_(pout),
- xmlnsStack_() {
- int i;
- for (i = 0; i < xmlnsCount; i += 2) {
- xmlnsStack_.AddXmlns(xmlns[i], xmlns[i + 1]);
- }
+XmlPrinterImpl::XmlPrinterImpl(std::ostream* pout, XmlnsStack* ns_stack)
+ : pout_(pout),
+ ns_stack_(ns_stack) {
}
-void
-XmlPrinterImpl::PrintElement(const XmlElement * element) {
- xmlnsStack_.PushFrame();
+void XmlPrinterImpl::PrintElement(const XmlElement* element) {
+ ns_stack_->PushFrame();
// first go through attrs of pel to add xmlns definitions
- const XmlAttr * pattr;
- for (pattr = element->FirstAttr(); pattr; pattr = pattr->NextAttr()) {
- if (pattr->Name() == QN_XMLNS)
- xmlnsStack_.AddXmlns(STR_EMPTY, pattr->Value());
- else if (pattr->Name().Namespace() == NS_XMLNS)
- xmlnsStack_.AddXmlns(pattr->Name().LocalPart(),
- pattr->Value());
+ const XmlAttr* attr;
+ for (attr = element->FirstAttr(); attr; attr = attr->NextAttr()) {
+ if (attr->Name() == QN_XMLNS) {
+ ns_stack_->AddXmlns(STR_EMPTY, attr->Value());
+ } else if (attr->Name().Namespace() == NS_XMLNS) {
+ ns_stack_->AddXmlns(attr->Name().LocalPart(),
+ attr->Value());
+ }
}
// then go through qnames to make sure needed xmlns definitons are added
- std::vector<std::string> newXmlns;
+ std::vector<std::string> new_ns;
std::pair<std::string, bool> prefix;
- prefix = xmlnsStack_.AddNewPrefix(element->Name().Namespace(), false);
+ prefix = ns_stack_->AddNewPrefix(element->Name().Namespace(), false);
if (prefix.second) {
- newXmlns.push_back(prefix.first);
- newXmlns.push_back(element->Name().Namespace());
+ new_ns.push_back(prefix.first);
+ new_ns.push_back(element->Name().Namespace());
}
- for (pattr = element->FirstAttr(); pattr; pattr = pattr->NextAttr()) {
- prefix = xmlnsStack_.AddNewPrefix(pattr->Name().Namespace(), true);
+ for (attr = element->FirstAttr(); attr; attr = attr->NextAttr()) {
+ prefix = ns_stack_->AddNewPrefix(attr->Name().Namespace(), true);
if (prefix.second) {
- newXmlns.push_back(prefix.first);
- newXmlns.push_back(pattr->Name().Namespace());
+ new_ns.push_back(prefix.first);
+ new_ns.push_back(attr->Name().Namespace());
}
}
// print the element name
- *pout_ << '<' << xmlnsStack_.FormatQName(element->Name(), false);
+ *pout_ << '<' << ns_stack_->FormatQName(element->Name(), false);
// and the attributes
- for (pattr = element->FirstAttr(); pattr; pattr = pattr->NextAttr()) {
- *pout_ << ' ' << xmlnsStack_.FormatQName(pattr->Name(), true) << "=\"";
- PrintQuotedValue(pattr->Value());
+ for (attr = element->FirstAttr(); attr; attr = attr->NextAttr()) {
+ *pout_ << ' ' << ns_stack_->FormatQName(attr->Name(), true) << "=\"";
+ PrintQuotedValue(attr->Value());
*pout_ << '"';
}
// and the extra xmlns declarations
- std::vector<std::string>::iterator i(newXmlns.begin());
- while (i < newXmlns.end()) {
- if (*i == STR_EMPTY)
+ std::vector<std::string>::iterator i(new_ns.begin());
+ while (i < new_ns.end()) {
+ if (*i == STR_EMPTY) {
*pout_ << " xmlns=\"" << *(i + 1) << '"';
- else
+ } else {
*pout_ << " xmlns:" << *i << "=\"" << *(i + 1) << '"';
+ }
i += 2;
}
// now the children
- const XmlChild * pchild = element->FirstChild();
+ const XmlChild* child = element->FirstChild();
- if (pchild == NULL)
+ if (child == NULL)
*pout_ << "/>";
else {
*pout_ << '>';
- while (pchild) {
- if (pchild->IsText()) {
+ while (child) {
+ if (child->IsText()) {
if (element->IsCDATA()) {
- PrintCDATAText(pchild->AsText()->Text());
+ PrintCDATAText(child->AsText()->Text());
} else {
- PrintBodyText(pchild->AsText()->Text());
+ PrintBodyText(child->AsText()->Text());
}
- } else
- PrintElement(pchild->AsElement());
- pchild = pchild->NextChild();
+ } else {
+ PrintElement(child->AsElement());
+ }
+ child = child->NextChild();
}
- *pout_ << "</" << xmlnsStack_.FormatQName(element->Name(), false) << '>';
+ *pout_ << "</" << ns_stack_->FormatQName(element->Name(), false) << '>';
}
- xmlnsStack_.PopFrame();
+ ns_stack_->PopFrame();
}
-void
-XmlPrinterImpl::PrintQuotedValue(const std::string & text) {
+void XmlPrinterImpl::PrintQuotedValue(const std::string& text) {
size_t safe = 0;
for (;;) {
size_t unsafe = text.find_first_of("<>&\"", safe);
@@ -170,8 +164,7 @@
}
}
-void
-XmlPrinterImpl::PrintBodyText(const std::string & text) {
+void XmlPrinterImpl::PrintBodyText(const std::string& text) {
size_t safe = 0;
for (;;) {
size_t unsafe = text.find_first_of("<>&", safe);
@@ -191,9 +184,8 @@
}
}
-void
-XmlPrinterImpl::PrintCDATAText(const std::string & text) {
+void XmlPrinterImpl::PrintCDATAText(const std::string& text) {
*pout_ << "<![CDATA[" << text << "]]>";
}
-}
+} // namespace buzz
diff --git a/talk/xmllite/xmlprinter.h b/talk/xmllite/xmlprinter.h
index 96900d0..90cc255 100644
--- a/talk/xmllite/xmlprinter.h
+++ b/talk/xmllite/xmlprinter.h
@@ -2,48 +2,48 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
- * 1. Redistributions of source code must retain the above copyright notice,
+ * 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. 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.
- * 3. The name of the author may not be used to endorse or promote products
+ * 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL THE AUTHOR 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
+ * 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 _xmlprinter_h_
-#define _xmlprinter_h_
+#ifndef TALK_XMLLITE_XMLPRINTER_H_
+#define TALK_XMLLITE_XMLPRINTER_H_
#include <iosfwd>
#include <string>
-#include "talk/base/scoped_ptr.h"
namespace buzz {
class XmlElement;
+class XmlnsStack;
class XmlPrinter {
-public:
- static void PrintXml(std::ostream * pout, const XmlElement * pelt);
+ public:
+ static void PrintXml(std::ostream* pout, const XmlElement* pelt);
- static void PrintXml(std::ostream * pout, const XmlElement * pelt,
- const std::string * const xmlns, int xmlnsCount);
+ static void PrintXml(std::ostream* pout, const XmlElement* pelt,
+ XmlnsStack* ns_stack);
};
-}
+} // namespace buzz
-#endif
+#endif // TALK_XMLLITE_XMLPRINTER_H_
diff --git a/talk/xmllite/xmlprinter_unittest.cc b/talk/xmllite/xmlprinter_unittest.cc
index 8ac7e04..60b0e42 100644
--- a/talk/xmllite/xmlprinter_unittest.cc
+++ b/talk/xmllite/xmlprinter_unittest.cc
@@ -25,24 +25,22 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include <string>
+#include "talk/xmllite/xmlprinter.h"
+
#include <sstream>
-#include <iostream>
+#include <string>
+
#include "talk/base/common.h"
#include "talk/base/gunit.h"
#include "talk/xmllite/qname.h"
#include "talk/xmllite/xmlelement.h"
-#include "talk/xmllite/xmlprinter.h"
+#include "talk/xmllite/xmlnsstack.h"
using buzz::QName;
using buzz::XmlElement;
+using buzz::XmlnsStack;
using buzz::XmlPrinter;
-static std::string XmlPrinterTest_Ns[] = {
- "gg", "google:test",
- "", "nested:test",
-};
-
TEST(XmlPrinterTest, TestBasicPrinting) {
XmlElement elt(QName("google:test", "first"));
std::stringstream ss;
@@ -55,7 +53,10 @@
elt.AddElement(new XmlElement(QName("nested:test", "second")));
std::stringstream ss;
- XmlPrinter::PrintXml(&ss, &elt, XmlPrinterTest_Ns, 4);
+ XmlnsStack ns_stack;
+ ns_stack.AddXmlns("gg", "google:test");
+ ns_stack.AddXmlns("", "nested:test");
+
+ XmlPrinter::PrintXml(&ss, &elt, &ns_stack);
EXPECT_EQ("<gg:first><second/></gg:first>", ss.str());
}
-
diff --git a/talk/xmpp/xmppengineimpl.cc b/talk/xmpp/xmppengineimpl.cc
index 3edddf2..eb539d1 100644
--- a/talk/xmpp/xmppengineimpl.cc
+++ b/talk/xmpp/xmppengineimpl.cc
@@ -2,87 +2,83 @@
* libjingle
* Copyright 2004--2005, Google Inc.
*
- * Redistribution and use in source and binary forms, with or without
+ * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
- * 1. Redistributions of source code must retain the above copyright notice,
+ * 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. 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.
- * 3. The name of the author may not be used to endorse or promote products
+ * 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL THE AUTHOR 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
+ * 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.
*/
-#define TRACK_ARRAY_ALLOC_PROBLEM
-
-#include <vector>
-#include <sstream>
-#include <algorithm>
-#include "talk/xmllite/xmlelement.h"
-#include "talk/base/common.h"
#include "talk/xmpp/xmppengineimpl.h"
-#include "talk/xmpp/xmpplogintask.h"
-#include "talk/xmpp/constants.h"
+
+#include <algorithm>
+#include <sstream>
+#include <vector>
+
+#include "talk/base/common.h"
+#include "talk/xmllite/xmlelement.h"
#include "talk/xmllite/xmlprinter.h"
+#include "talk/xmpp/constants.h"
#include "talk/xmpp/saslhandler.h"
+#include "talk/xmpp/xmpplogintask.h"
namespace buzz {
-static const std::string XMPP_CLIENT_NAMESPACES[] = {
- "stream", "http://etherx.jabber.org/streams",
- "", "jabber:client",
-};
-
-static const size_t XMPP_CLIENT_NAMESPACES_LEN = 4;
-
-XmppEngine * XmppEngine::Create() {
+XmppEngine* XmppEngine::Create() {
return new XmppEngineImpl();
}
-XmppEngineImpl::XmppEngineImpl() :
- stanzaParseHandler_(this),
- stanzaParser_(&stanzaParseHandler_),
- engine_entered_(0),
- password_(),
- requested_resource_(STR_EMPTY),
- tls_option_(buzz::TLS_REQUIRED),
- login_task_(new XmppLoginTask(this)),
- next_id_(0),
- state_(STATE_START),
- encrypted_(false),
- error_code_(ERROR_NONE),
- subcode_(0),
- stream_error_(NULL),
- raised_reset_(false),
- output_handler_(NULL),
- session_handler_(NULL),
- iq_entries_(new IqEntryVector()),
- sasl_handler_(NULL),
- output_(new std::stringstream()) {
+XmppEngineImpl::XmppEngineImpl()
+ : stanza_parse_handler_(this),
+ stanza_parser_(&stanza_parse_handler_),
+ engine_entered_(0),
+ password_(),
+ requested_resource_(STR_EMPTY),
+ tls_option_(buzz::TLS_REQUIRED),
+ login_task_(new XmppLoginTask(this)),
+ next_id_(0),
+ state_(STATE_START),
+ encrypted_(false),
+ error_code_(ERROR_NONE),
+ subcode_(0),
+ stream_error_(NULL),
+ raised_reset_(false),
+ output_handler_(NULL),
+ session_handler_(NULL),
+ iq_entries_(new IqEntryVector()),
+ sasl_handler_(NULL),
+ output_(new std::stringstream()) {
for (int i = 0; i < HL_COUNT; i+= 1) {
stanza_handlers_[i].reset(new StanzaHandlerVector());
}
+
+ xmlns_stack_.AddXmlns("stream", "http://etherx.jabber.org/streams");
+ xmlns_stack_.AddXmlns("", "jabber:client");
}
XmppEngineImpl::~XmppEngineImpl() {
DeleteIqCookies();
}
-XmppReturnStatus
-XmppEngineImpl::SetOutputHandler(XmppOutputHandler* output_handler) {
+XmppReturnStatus XmppEngineImpl::SetOutputHandler(
+ XmppOutputHandler* output_handler) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -91,8 +87,8 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetSessionHandler(XmppSessionHandler* session_handler) {
+XmppReturnStatus XmppEngineImpl::SetSessionHandler(
+ XmppSessionHandler* session_handler) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -101,21 +97,20 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::HandleInput(const char * bytes, size_t len) {
+XmppReturnStatus XmppEngineImpl::HandleInput(
+ const char* bytes, size_t len) {
if (state_ < STATE_OPENING || state_ > STATE_OPEN)
return XMPP_RETURN_BADSTATE;
EnterExit ee(this);
// TODO: The return value of the xml parser is not checked.
- stanzaParser_.Parse(bytes, len, false);
+ stanza_parser_.Parse(bytes, len, false);
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::ConnectionClosed(int subcode) {
+XmppReturnStatus XmppEngineImpl::ConnectionClosed(int subcode) {
if (state_ != STATE_CLOSED) {
EnterExit ee(this);
// If told that connection closed and not already closed,
@@ -129,17 +124,16 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetTls(TlsOptions useTls) {
+XmppReturnStatus XmppEngineImpl::SetTls(TlsOptions useTls) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
tls_option_ = useTls;
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetTlsServer(const std::string & tls_server_hostname,
- const std::string & tls_server_domain) {
+XmppReturnStatus XmppEngineImpl::SetTlsServer(
+ const std::string& tls_server_hostname,
+ const std::string& tls_server_domain) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -149,13 +143,11 @@
return XMPP_RETURN_OK;
}
-TlsOptions
-XmppEngineImpl::GetTls() {
+TlsOptions XmppEngineImpl::GetTls() {
return tls_option_;
}
-XmppReturnStatus
-XmppEngineImpl::SetUser(const Jid & jid) {
+XmppReturnStatus XmppEngineImpl::SetUser(const Jid& jid) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -164,13 +156,11 @@
return XMPP_RETURN_OK;
}
-const Jid &
-XmppEngineImpl::GetUser() {
+const Jid& XmppEngineImpl::GetUser() {
return user_jid_;
}
-XmppReturnStatus
-XmppEngineImpl::SetSaslHandler(SaslHandler * sasl_handler) {
+XmppReturnStatus XmppEngineImpl::SetSaslHandler(SaslHandler* sasl_handler) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -178,8 +168,8 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SetRequestedResource(const std::string & resource) {
+XmppReturnStatus XmppEngineImpl::SetRequestedResource(
+ const std::string& resource) {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -188,14 +178,13 @@
return XMPP_RETURN_OK;
}
-const std::string &
-XmppEngineImpl::GetRequestedResource() {
+const std::string& XmppEngineImpl::GetRequestedResource() {
return requested_resource_;
}
-XmppReturnStatus
-XmppEngineImpl::AddStanzaHandler(XmppStanzaHandler * stanza_handler,
- XmppEngine::HandlerLevel level) {
+XmppReturnStatus XmppEngineImpl::AddStanzaHandler(
+ XmppStanzaHandler* stanza_handler,
+ XmppEngine::HandlerLevel level) {
if (state_ == STATE_CLOSED)
return XMPP_RETURN_BADSTATE;
@@ -204,9 +193,8 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::RemoveStanzaHandler(XmppStanzaHandler * stanza_handler) {
-
+XmppReturnStatus XmppEngineImpl::RemoveStanzaHandler(
+ XmppStanzaHandler* stanza_handler) {
bool found = false;
for (int level = 0; level < HL_COUNT; level += 1) {
@@ -221,15 +209,13 @@
}
}
- if (!found) {
+ if (!found)
return XMPP_RETURN_BADARGUMENT;
- }
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::Connect() {
+XmppReturnStatus XmppEngineImpl::Connect() {
if (state_ != STATE_START)
return XMPP_RETURN_BADSTATE;
@@ -246,8 +232,7 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SendStanza(const XmlElement * element) {
+XmppReturnStatus XmppEngineImpl::SendStanza(const XmlElement* element) {
if (state_ == STATE_CLOSED)
return XMPP_RETURN_BADSTATE;
@@ -264,8 +249,7 @@
return XMPP_RETURN_OK;
}
-XmppReturnStatus
-XmppEngineImpl::SendRaw(const std::string & text) {
+XmppReturnStatus XmppEngineImpl::SendRaw(const std::string& text) {
if (state_ == STATE_CLOSED || login_task_.get())
return XMPP_RETURN_BADSTATE;
@@ -276,16 +260,13 @@
return XMPP_RETURN_OK;
}
-std::string
-XmppEngineImpl::NextId() {
+std::string XmppEngineImpl::NextId() {
std::stringstream ss;
ss << next_id_++;
return ss.str();
}
-XmppReturnStatus
-XmppEngineImpl::Disconnect() {
-
+XmppReturnStatus XmppEngineImpl::Disconnect() {
if (state_ != STATE_CLOSED) {
EnterExit ee(this);
if (state_ == STATE_OPEN)
@@ -296,14 +277,13 @@
return XMPP_RETURN_OK;
}
-void
-XmppEngineImpl::IncomingStart(const XmlElement * pelStart) {
+void XmppEngineImpl::IncomingStart(const XmlElement* start) {
if (HasError() || raised_reset_)
return;
if (login_task_.get()) {
// start-stream should go to login task
- login_task_->IncomingStanza(pelStart, true);
+ login_task_->IncomingStanza(start, true);
if (login_task_->IsDone())
login_task_.reset();
}
@@ -313,8 +293,7 @@
}
}
-void
-XmppEngineImpl::IncomingStanza(const XmlElement * stanza) {
+void XmppEngineImpl::IncomingStanza(const XmlElement* stanza) {
if (HasError() || raised_reset_)
return;
@@ -338,7 +317,7 @@
for (int level = HL_SINGLE; level <= HL_ALL; level += 1) {
for (size_t i = 0; i < stanza_handlers_[level]->size(); i += 1) {
if ((*stanza_handlers_[level])[i]->HandleStanza(stanza))
- goto Handled;
+ return;
}
}
@@ -346,29 +325,24 @@
// Only do this for IQ stanzas as messages should probably just be dropped
// and presence stanzas should certainly be dropped.
std::string type = stanza->Attr(QN_TYPE);
- if (stanza->Name() == QN_IQ &&
+ if (stanza->Name() == QN_IQ &&
!(type == "error" || type == "result")) {
SendStanzaError(stanza, XSE_FEATURE_NOT_IMPLEMENTED, STR_EMPTY);
}
}
- Handled:
- ; // handled - we're done
}
-void
-XmppEngineImpl::IncomingEnd(bool isError) {
+void XmppEngineImpl::IncomingEnd(bool isError) {
if (HasError() || raised_reset_)
return;
SignalError(isError ? ERROR_XML : ERROR_DOCUMENT_CLOSED, 0);
}
-void
-XmppEngineImpl::InternalSendStart(const std::string & to) {
+void XmppEngineImpl::InternalSendStart(const std::string& to) {
std::string hostname = tls_server_hostname_;
- if (hostname.empty()) {
+ if (hostname.empty())
hostname = to;
- }
// If not language is specified, the spec says use *
std::string lang = lang_;
@@ -385,60 +359,51 @@
<< "xmlns=\"jabber:client\">\r\n";
}
-void
-XmppEngineImpl::InternalSendStanza(const XmlElement * element) {
+void XmppEngineImpl::InternalSendStanza(const XmlElement* element) {
// It should really never be necessary to set a FROM attribute on a stanza.
// It is implied by the bind on the stream and if you get it wrong
// (by flipping from/to on a message?) the server will close the stream.
ASSERT(!element->HasAttr(QN_FROM));
- // TODO: consider caching the XmlPrinter
- XmlPrinter::PrintXml(output_.get(), element,
- XMPP_CLIENT_NAMESPACES, XMPP_CLIENT_NAMESPACES_LEN);
+ XmlPrinter::PrintXml(output_.get(), element, &xmlns_stack_);
}
-std::string
-XmppEngineImpl::ChooseBestSaslMechanism(const std::vector<std::string> & mechanisms, bool encrypted) {
+std::string XmppEngineImpl::ChooseBestSaslMechanism(
+ const std::vector<std::string>& mechanisms, bool encrypted) {
return sasl_handler_->ChooseBestSaslMechanism(mechanisms, encrypted);
}
-SaslMechanism *
-XmppEngineImpl::GetSaslMechanism(const std::string & name) {
+SaslMechanism* XmppEngineImpl::GetSaslMechanism(const std::string& name) {
return sasl_handler_->CreateSaslMechanism(name);
}
-void
-XmppEngineImpl::SignalBound(const Jid & fullJid) {
+void XmppEngineImpl::SignalBound(const Jid& fullJid) {
if (state_ == STATE_OPENING) {
bound_jid_ = fullJid;
state_ = STATE_OPEN;
}
}
-void
-XmppEngineImpl::SignalStreamError(const XmlElement * pelStreamError) {
+void XmppEngineImpl::SignalStreamError(const XmlElement* stream_error) {
if (state_ != STATE_CLOSED) {
- stream_error_.reset(new XmlElement(*pelStreamError));
+ stream_error_.reset(new XmlElement(*stream_error));
SignalError(ERROR_STREAM, 0);
}
}
-void
-XmppEngineImpl::SignalError(Error errorCode, int subCode) {
+void XmppEngineImpl::SignalError(Error error_code, int sub_code) {
if (state_ != STATE_CLOSED) {
- error_code_ = errorCode;
- subcode_ = subCode;
+ error_code_ = error_code;
+ subcode_ = sub_code;
state_ = STATE_CLOSED;
}
}
-bool
-XmppEngineImpl::HasError() {
+bool XmppEngineImpl::HasError() {
return error_code_ != ERROR_NONE;
}
-void
-XmppEngineImpl::StartTls(const std::string & domain) {
+void XmppEngineImpl::StartTls(const std::string& domain) {
if (output_handler_) {
// As substitute for the real (login jid's) domain, we permit
// verifying a tls_server_domain_ instead, if one was passed.
@@ -451,7 +416,7 @@
}
XmppEngineImpl::EnterExit::EnterExit(XmppEngineImpl* engine)
- : engine_(engine),
+ : engine_(engine),
state_(engine->state_),
error_(engine->error_code_) {
engine->engine_entered_ += 1;
@@ -482,17 +447,17 @@
return;
if (engine->raised_reset_) {
- engine->stanzaParser_.Reset();
+ engine->stanza_parser_.Reset();
engine->raised_reset_ = false;
}
if (engine->session_handler_) {
if (engine->state_ != state_)
engine->session_handler_->OnStateChange(engine->state_);
- // Note: Handling of OnStateChange(CLOSED) should allow for the
- // deletion of the engine, so no members should be accessed
- // after this line.
+ // Note: Handling of OnStateChange(CLOSED) should allow for the
+ // deletion of the engine, so no members should be accessed
+ // after this line.
}
}
-}
+} // namespace buzz
diff --git a/talk/xmpp/xmppengineimpl.h b/talk/xmpp/xmppengineimpl.h
index 931955d..1fdb2a0 100644
--- a/talk/xmpp/xmppengineimpl.h
+++ b/talk/xmpp/xmppengineimpl.h
@@ -25,8 +25,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _xmppengineimpl_h_
-#define _xmppengineimpl_h_
+#ifndef TALK_XMPP_XMPPENGINEIMPL_H_
+#define TALK_XMPP_XMPPENGINEIMPL_H_
#include <sstream>
#include <vector>
@@ -50,7 +50,7 @@
//! An application can listen for events and receive stanzas by
//! registering an XmppStanzaHandler via AddStanzaHandler().
class XmppEngineImpl : public XmppEngine {
-public:
+ public:
XmppEngineImpl();
virtual ~XmppEngineImpl();
@@ -60,7 +60,7 @@
virtual XmppReturnStatus SetOutputHandler(XmppOutputHandler *pxoh);
//! Provides socket input to the engine
- virtual XmppReturnStatus HandleInput(const char * bytes, size_t len);
+ virtual XmppReturnStatus HandleInput(const char* bytes, size_t len);
//! Advises the engine that the socket has closed
virtual XmppReturnStatus ConnectionClosed(int subcode);
@@ -68,13 +68,13 @@
// SESSION SETUP ---------------------------------------------------------
//! Indicates the (bare) JID for the user to use.
- virtual XmppReturnStatus SetUser(const Jid & jid);
+ virtual XmppReturnStatus SetUser(const Jid& jid);
//! Get the login (bare) JID.
- virtual const Jid & GetUser();
+ virtual const Jid& GetUser();
//! Indicates the autentication to use. Takes ownership of the object.
- virtual XmppReturnStatus SetSaslHandler(SaslHandler * sasl_handler);
+ virtual XmppReturnStatus SetSaslHandler(SaslHandler* sasl_handler);
//! Sets whether TLS will be used within the connection (default true).
virtual XmppReturnStatus SetTls(TlsOptions useTls);
@@ -83,8 +83,8 @@
//! This is for use in the case where a we want to allow a proxy to
//! serve up its own certificate rather than one owned by the underlying
//! domain.
- virtual XmppReturnStatus SetTlsServer(const std::string & proxy_hostname,
- const std::string & proxy_domain);
+ virtual XmppReturnStatus SetTlsServer(const std::string& proxy_hostname,
+ const std::string& proxy_domain);
//! Gets whether TLS will be used within the connection.
virtual TlsOptions GetTls();
@@ -95,10 +95,10 @@
virtual XmppReturnStatus SetRequestedResource(const std::string& resource);
//! Gets the request resource name.
- virtual const std::string & GetRequestedResource();
+ virtual const std::string& GetRequestedResource();
//! Sets language
- virtual void SetLanguage(const std::string & lang) {
+ virtual void SetLanguage(const std::string& lang) {
lang_ = lang;
}
@@ -130,7 +130,7 @@
//! The stream:error stanza, when the error is XmppEngine::ERROR_STREAM.
//! Notice the stanza returned is owned by the XmppEngine and
//! is deleted when the engine is destroyed.
- virtual const XmlElement * GetStreamError() { return stream_error_.get(); }
+ virtual const XmlElement* GetStreamError() { return stream_error_.get(); }
//! Closes down the connection.
//! Sends CloseConnection to output, and disconnects and registered
@@ -150,14 +150,14 @@
virtual XmppReturnStatus RemoveStanzaHandler(XmppStanzaHandler* handler);
//! Sends a stanza to the server.
- virtual XmppReturnStatus SendStanza(const XmlElement * pelStanza);
+ virtual XmppReturnStatus SendStanza(const XmlElement* stanza);
//! Sends raw text to the server
- virtual XmppReturnStatus SendRaw(const std::string & text);
+ virtual XmppReturnStatus SendRaw(const std::string& text);
//! Sends an iq to the server, and registers a callback for the result.
//! Returns the cookie passed to the result handler.
- virtual XmppReturnStatus SendIq(const XmlElement* pelStanza,
+ virtual XmppReturnStatus SendIq(const XmlElement* stanza,
XmppIqHandler* iq_handler,
XmppIqCookie* cookie);
@@ -169,55 +169,62 @@
//! Forms and sends an error in response to the given stanza.
//! Swaps to and from, sets type to "error", and adds error information
//! based on the passed code. Text is optional and may be STR_EMPTY.
- virtual XmppReturnStatus SendStanzaError(const XmlElement * pelOriginal,
+ virtual XmppReturnStatus SendStanzaError(const XmlElement* pelOriginal,
XmppStanzaError code,
- const std::string & text);
+ const std::string& text);
//! The fullly bound JID.
//! This JID is only valid after binding has succeeded. If the value
//! is JID_NULL, the binding has not succeeded.
- virtual const Jid & FullJid() { return bound_jid_; }
+ virtual const Jid& FullJid() { return bound_jid_; }
//! The next unused iq id for this connection.
//! Call this when building iq stanzas, to ensure that each iq
//! gets its own unique id.
virtual std::string NextId();
-private:
+ private:
friend class XmppLoginTask;
friend class XmppIqEntry;
- void IncomingStanza(const XmlElement *pelStanza);
- void IncomingStart(const XmlElement *pelStanza);
+ void IncomingStanza(const XmlElement *stanza);
+ void IncomingStart(const XmlElement *stanza);
void IncomingEnd(bool isError);
- void InternalSendStart(const std::string & domainName);
- void InternalSendStanza(const XmlElement * pelStanza);
- std::string ChooseBestSaslMechanism(const std::vector<std::string> & mechanisms, bool encrypted);
- SaslMechanism * GetSaslMechanism(const std::string & name);
- void SignalBound(const Jid & fullJid);
- void SignalStreamError(const XmlElement * pelStreamError);
+ void InternalSendStart(const std::string& domainName);
+ void InternalSendStanza(const XmlElement* stanza);
+ std::string ChooseBestSaslMechanism(
+ const std::vector<std::string>& mechanisms, bool encrypted);
+ SaslMechanism* GetSaslMechanism(const std::string& name);
+ void SignalBound(const Jid& fullJid);
+ void SignalStreamError(const XmlElement* streamError);
void SignalError(Error errorCode, int subCode);
bool HasError();
void DeleteIqCookies();
- bool HandleIqResponse(const XmlElement * element);
- void StartTls(const std::string & domain);
+ bool HandleIqResponse(const XmlElement* element);
+ void StartTls(const std::string& domain);
void RaiseReset() { raised_reset_ = true; }
class StanzaParseHandler : public XmppStanzaParseHandler {
- public:
- StanzaParseHandler(XmppEngineImpl * outer) : outer_(outer) {}
+ public:
+ StanzaParseHandler(XmppEngineImpl* outer) : outer_(outer) {}
virtual ~StanzaParseHandler() {}
- virtual void StartStream(const XmlElement * pelStream)
- { outer_->IncomingStart(pelStream); }
- virtual void Stanza(const XmlElement * pelStanza)
- { outer_->IncomingStanza(pelStanza); }
- virtual void EndStream()
- { outer_->IncomingEnd(false); }
- virtual void XmlError()
- { outer_->IncomingEnd(true); }
- private:
- XmppEngineImpl * const outer_;
+
+ virtual void StartStream(const XmlElement* stream) {
+ outer_->IncomingStart(stream);
+ }
+ virtual void Stanza(const XmlElement* stanza) {
+ outer_->IncomingStanza(stanza);
+ }
+ virtual void EndStream() {
+ outer_->IncomingEnd(false);
+ }
+ virtual void XmlError() {
+ outer_->IncomingEnd(true);
+ }
+
+ private:
+ XmppEngineImpl* const outer_;
};
class EnterExit {
@@ -234,9 +241,8 @@
friend class StanzaParseHandler;
friend class EnterExit;
- StanzaParseHandler stanzaParseHandler_;
- XmppStanzaParser stanzaParser_;
-
+ StanzaParseHandler stanza_parse_handler_;
+ XmppStanzaParser stanza_parser_;
// state
int engine_entered_;
@@ -260,6 +266,8 @@
XmppOutputHandler* output_handler_;
XmppSessionHandler* session_handler_;
+ XmlnsStack xmlns_stack_;
+
typedef std::vector<XmppStanzaHandler*> StanzaHandlerVector;
talk_base::scoped_ptr<StanzaHandlerVector> stanza_handlers_[HL_COUNT];
@@ -271,7 +279,6 @@
talk_base::scoped_ptr<std::stringstream> output_;
};
-}
+} // namespace buzz
-
-#endif
+#endif // TALK_XMPP_XMPPENGINEIMPL_H_
