0

Unbranch libjingle

BUG=35195,76790
TEST=None

Review URL: http://codereview.chromium.org/7077019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@86954 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
sergeyu@chromium.org
2011-05-27 02:42:41 +00:00
parent 866cd68e4f
commit e18194cf54
4 changed files with 66 additions and 69 deletions

4
DEPS

@@ -13,7 +13,7 @@ vars = {
"nacl_irt_hash_x86_64": "423ce0d282f7e57b856be8e1ae46a60a05dc6f85", "nacl_irt_hash_x86_64": "423ce0d282f7e57b856be8e1ae46a60a05dc6f85",
"nacl_revision": "5445", "nacl_revision": "5445",
"nacl_tools_revision": "5308", "nacl_tools_revision": "5308",
"libjingle_revision": "59", "libjingle_revision": "63",
"libvpx_revision": "81610", "libvpx_revision": "81610",
"ffmpeg_revision": "83815", "ffmpeg_revision": "83815",
"skia_revision": "1437", "skia_revision": "1437",
@@ -204,7 +204,7 @@ deps = {
Var("ffmpeg_revision"), Var("ffmpeg_revision"),
"src/third_party/libjingle/source": "src/third_party/libjingle/source":
(Var("googlecode_url") % "libjingle") + "/branches/chrome-sandbox@" + (Var("googlecode_url") % "libjingle") + "/trunk@" +
Var("libjingle_revision"), Var("libjingle_revision"),
"src/third_party/speex": "src/third_party/speex":

@@ -29,13 +29,13 @@ class IpcPacketSocket : public talk_base::AsyncPacketSocket,
const talk_base::SocketAddress& remote_address); const talk_base::SocketAddress& remote_address);
// talk_base::AsyncPacketSocket interface. // talk_base::AsyncPacketSocket interface.
virtual bool GetLocalAddress(talk_base::SocketAddress* address) const; virtual talk_base::SocketAddress GetLocalAddress() const;
virtual talk_base::SocketAddress GetRemoteAddress() const; virtual talk_base::SocketAddress GetRemoteAddress() const;
virtual int Send(const void *pv, size_t cb); virtual int Send(const void *pv, size_t cb);
virtual int SendTo(const void *pv, size_t cb, virtual int SendTo(const void *pv, size_t cb,
const talk_base::SocketAddress& addr); const talk_base::SocketAddress& addr);
virtual int Close(); virtual int Close();
virtual talk_base::Socket::ConnState GetState() const; virtual State GetState() const;
virtual int GetOption(talk_base::Socket::Option opt, int* value); virtual int GetOption(talk_base::Socket::Option opt, int* value);
virtual int SetOption(talk_base::Socket::Option opt, int value); virtual int SetOption(talk_base::Socket::Option opt, int value);
virtual int GetError() const; virtual int GetError() const;
@@ -50,18 +50,20 @@ class IpcPacketSocket : public talk_base::AsyncPacketSocket,
const std::vector<char>& data) OVERRIDE; const std::vector<char>& data) OVERRIDE;
private: private:
enum State { enum InternalState {
STATE_UNINITIALIZED, IS_UNINITIALIZED,
STATE_OPENING, IS_OPENING,
STATE_OPEN, IS_OPEN,
STATE_CLOSED, IS_CLOSED,
STATE_ERROR, IS_ERROR,
}; };
void InitAcceptedTcp(P2PSocketClient* client, void InitAcceptedTcp(P2PSocketClient* client,
const talk_base::SocketAddress& local_address, const talk_base::SocketAddress& local_address,
const talk_base::SocketAddress& remote_address); const talk_base::SocketAddress& remote_address);
P2PSocketType type_;
// Message loop on which this socket was created and being used. // Message loop on which this socket was created and being used.
MessageLoop* message_loop_; MessageLoop* message_loop_;
@@ -72,15 +74,14 @@ class IpcPacketSocket : public talk_base::AsyncPacketSocket,
// renderer side doesn't know the address until it receives OnOpen() // renderer side doesn't know the address until it receives OnOpen()
// event from the browser. // event from the browser.
talk_base::SocketAddress local_address_; talk_base::SocketAddress local_address_;
bool address_initialized_;
// Remote address for client TCP connections. // Remote address for client TCP connections.
talk_base::SocketAddress remote_address_; talk_base::SocketAddress remote_address_;
// Current state of the object. // Current state of the object.
State state_; InternalState state_;
// Current error code. Valid when state_ == STATE_ERROR. // Current error code. Valid when state_ == IS_ERROR.
int error_; int error_;
DISALLOW_COPY_AND_ASSIGN(IpcPacketSocket); DISALLOW_COPY_AND_ASSIGN(IpcPacketSocket);
@@ -88,13 +89,12 @@ class IpcPacketSocket : public talk_base::AsyncPacketSocket,
IpcPacketSocket::IpcPacketSocket() IpcPacketSocket::IpcPacketSocket()
: message_loop_(MessageLoop::current()), : message_loop_(MessageLoop::current()),
address_initialized_(false), state_(IS_UNINITIALIZED), error_(0) {
state_(STATE_UNINITIALIZED), error_(0) {
} }
IpcPacketSocket::~IpcPacketSocket() { IpcPacketSocket::~IpcPacketSocket() {
if (state_ == STATE_OPENING || state_ == STATE_OPEN || if (state_ == IS_OPENING || state_ == IS_OPEN ||
state_ == STATE_ERROR) { state_ == IS_ERROR) {
Close(); Close();
} }
} }
@@ -103,12 +103,13 @@ bool IpcPacketSocket::Init(P2PSocketType type, P2PSocketClient* client,
const talk_base::SocketAddress& local_address, const talk_base::SocketAddress& local_address,
const talk_base::SocketAddress& remote_address) { const talk_base::SocketAddress& remote_address) {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
DCHECK_EQ(state_, STATE_UNINITIALIZED); DCHECK_EQ(state_, IS_UNINITIALIZED);
type_ = type;
client_ = client; client_ = client;
local_address_ = local_address; local_address_ = local_address;
remote_address_ = remote_address; remote_address_ = remote_address;
state_ = STATE_OPENING; state_ = IS_OPENING;
net::IPEndPoint local_endpoint; net::IPEndPoint local_endpoint;
if (!jingle_glue::SocketAddressToIPEndPoint(local_address, &local_endpoint)) { if (!jingle_glue::SocketAddressToIPEndPoint(local_address, &local_endpoint)) {
@@ -132,29 +133,23 @@ void IpcPacketSocket::InitAcceptedTcp(
const talk_base::SocketAddress& local_address, const talk_base::SocketAddress& local_address,
const talk_base::SocketAddress& remote_address) { const talk_base::SocketAddress& remote_address) {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
DCHECK_EQ(state_, STATE_UNINITIALIZED); DCHECK_EQ(state_, IS_UNINITIALIZED);
client_ = client; client_ = client;
local_address_ = local_address; local_address_ = local_address;
remote_address_ = remote_address; remote_address_ = remote_address;
state_ = STATE_OPEN; state_ = IS_OPEN;
client_->set_delegate(this); client_->set_delegate(this);
} }
// talk_base::AsyncPacketSocket interface. // talk_base::AsyncPacketSocket interface.
bool IpcPacketSocket::GetLocalAddress(talk_base::SocketAddress* address) const { talk_base::SocketAddress IpcPacketSocket::GetLocalAddress() const {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
return local_address_;
if (!address_initialized_)
return false;
*address = local_address_;
return true;
} }
talk_base::SocketAddress IpcPacketSocket::GetRemoteAddress() const { talk_base::SocketAddress IpcPacketSocket::GetRemoteAddress() const {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
return remote_address_; return remote_address_;
} }
@@ -168,16 +163,16 @@ int IpcPacketSocket::SendTo(const void *data, size_t data_size,
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
switch (state_) { switch (state_) {
case STATE_UNINITIALIZED: case IS_UNINITIALIZED:
NOTREACHED(); NOTREACHED();
return EWOULDBLOCK; return EWOULDBLOCK;
case STATE_OPENING: case IS_OPENING:
return EWOULDBLOCK; return EWOULDBLOCK;
case STATE_CLOSED: case IS_CLOSED:
return ENOTCONN; return ENOTCONN;
case STATE_ERROR: case IS_ERROR:
return error_; return error_;
case STATE_OPEN: case IS_OPEN:
// Continue sending the packet. // Continue sending the packet.
break; break;
} }
@@ -201,32 +196,36 @@ int IpcPacketSocket::Close() {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
client_->Close(); client_->Close();
state_ = STATE_CLOSED; state_ = IS_CLOSED;
return 0; return 0;
} }
talk_base::Socket::ConnState IpcPacketSocket::GetState() const { talk_base::AsyncPacketSocket::State IpcPacketSocket::GetState() const {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
switch (state_) { switch (state_) {
case STATE_UNINITIALIZED: case IS_UNINITIALIZED:
NOTREACHED(); NOTREACHED();
return talk_base::Socket::CS_CONNECTING; return STATE_CLOSED;
case STATE_OPENING: case IS_OPENING:
return talk_base::Socket::CS_CONNECTING; return STATE_BINDING;
case STATE_OPEN: case IS_OPEN:
return talk_base::Socket::CS_CONNECTED; if (type_ == P2P_SOCKET_TCP_CLIENT) {
return STATE_CONNECTED;
} else {
return STATE_BOUND;
}
case STATE_CLOSED: case IS_CLOSED:
case STATE_ERROR: case IS_ERROR:
return talk_base::Socket::CS_CLOSED; return STATE_CLOSED;
} }
NOTREACHED(); NOTREACHED();
return talk_base::Socket::CS_CLOSED; return STATE_CLOSED;
} }
int IpcPacketSocket::GetOption(talk_base::Socket::Option opt, int* value) { int IpcPacketSocket::GetOption(talk_base::Socket::Option opt, int* value) {
@@ -262,8 +261,9 @@ void IpcPacketSocket::OnOpen(const net::IPEndPoint& address) {
return; return;
} }
SignalAddressReady(this, local_address_); SignalAddressReady(this, local_address_);
address_initialized_ = true; if (type_ == P2P_SOCKET_TCP_CLIENT)
state_ = STATE_OPEN; SignalConnect(this);
state_ = IS_OPEN;
} }
void IpcPacketSocket::OnIncomingTcpConnection( void IpcPacketSocket::OnIncomingTcpConnection(
@@ -284,7 +284,7 @@ void IpcPacketSocket::OnIncomingTcpConnection(
void IpcPacketSocket::OnError() { void IpcPacketSocket::OnError() {
DCHECK_EQ(MessageLoop::current(), message_loop_); DCHECK_EQ(MessageLoop::current(), message_loop_);
state_ = STATE_ERROR; state_ = IS_ERROR;
error_ = ECONNABORTED; error_ = ECONNABORTED;
} }

@@ -13,7 +13,7 @@ namespace jingle_glue {
FakeUDPPacketSocket::FakeUDPPacketSocket(FakeSocketManager* fake_socket_manager, FakeUDPPacketSocket::FakeUDPPacketSocket(FakeSocketManager* fake_socket_manager,
const net::IPEndPoint& address) const net::IPEndPoint& address)
: fake_socket_manager_(fake_socket_manager), : fake_socket_manager_(fake_socket_manager),
endpoint_(address), state_(STATE_OPEN), error_(0) { endpoint_(address), state_(IS_OPEN), error_(0) {
CHECK(IPEndPointToSocketAddress(endpoint_, &local_address_)); CHECK(IPEndPointToSocketAddress(endpoint_, &local_address_));
fake_socket_manager_->AddSocket(this); fake_socket_manager_->AddSocket(this);
} }
@@ -22,11 +22,9 @@ FakeUDPPacketSocket::~FakeUDPPacketSocket() {
fake_socket_manager_->RemoveSocket(this); fake_socket_manager_->RemoveSocket(this);
} }
bool FakeUDPPacketSocket::GetLocalAddress( talk_base::SocketAddress FakeUDPPacketSocket::GetLocalAddress() const {
talk_base::SocketAddress* address) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
*address = local_address_; return local_address_;
return true;
} }
talk_base::SocketAddress FakeUDPPacketSocket::GetRemoteAddress() const { talk_base::SocketAddress FakeUDPPacketSocket::GetRemoteAddress() const {
@@ -43,7 +41,7 @@ int FakeUDPPacketSocket::SendTo(const void *data, size_t data_size,
const talk_base::SocketAddress& address) { const talk_base::SocketAddress& address) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
if (state_ == STATE_CLOSED) { if (state_ == IS_CLOSED) {
return ENOTCONN; return ENOTCONN;
} }
@@ -62,22 +60,22 @@ int FakeUDPPacketSocket::SendTo(const void *data, size_t data_size,
int FakeUDPPacketSocket::Close() { int FakeUDPPacketSocket::Close() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
state_ = STATE_CLOSED; state_ = IS_CLOSED;
return 0; return 0;
} }
talk_base::Socket::ConnState FakeUDPPacketSocket::GetState() const { talk_base::AsyncPacketSocket::State FakeUDPPacketSocket::GetState() const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
switch (state_) { switch (state_) {
case STATE_OPEN: case IS_OPEN:
return talk_base::Socket::CS_CONNECTED; return STATE_BOUND;
case STATE_CLOSED: case IS_CLOSED:
return talk_base::Socket::CS_CLOSED; return STATE_CLOSED;
} }
NOTREACHED(); NOTREACHED();
return talk_base::Socket::CS_CLOSED; return STATE_CLOSED;
} }
int FakeUDPPacketSocket::GetOption(talk_base::Socket::Option opt, int* value) { int FakeUDPPacketSocket::GetOption(talk_base::Socket::Option opt, int* value) {

@@ -34,30 +34,29 @@ class FakeUDPPacketSocket : public talk_base::AsyncPacketSocket,
const std::vector<char>& data); const std::vector<char>& data);
// talk_base::AsyncPacketSocket implementation. // talk_base::AsyncPacketSocket implementation.
virtual bool GetLocalAddress( virtual talk_base::SocketAddress GetLocalAddress() const OVERRIDE;
talk_base::SocketAddress* address) const OVERRIDE;
virtual talk_base::SocketAddress GetRemoteAddress() const OVERRIDE; virtual talk_base::SocketAddress GetRemoteAddress() const OVERRIDE;
virtual int Send(const void *pv, size_t cb) OVERRIDE; virtual int Send(const void *pv, size_t cb) OVERRIDE;
virtual int SendTo(const void *pv, size_t cb, virtual int SendTo(const void *pv, size_t cb,
const talk_base::SocketAddress& addr) OVERRIDE; const talk_base::SocketAddress& addr) OVERRIDE;
virtual int Close() OVERRIDE; virtual int Close() OVERRIDE;
virtual talk_base::Socket::ConnState GetState() const OVERRIDE; virtual State GetState() const OVERRIDE;
virtual int GetOption(talk_base::Socket::Option opt, int* value) OVERRIDE; virtual int GetOption(talk_base::Socket::Option opt, int* value) OVERRIDE;
virtual int SetOption(talk_base::Socket::Option opt, int value) OVERRIDE; virtual int SetOption(talk_base::Socket::Option opt, int value) OVERRIDE;
virtual int GetError() const OVERRIDE; virtual int GetError() const OVERRIDE;
virtual void SetError(int error) OVERRIDE; virtual void SetError(int error) OVERRIDE;
private: private:
enum State { enum InternalState {
STATE_OPEN, IS_OPEN,
STATE_CLOSED, IS_CLOSED,
}; };
scoped_refptr<FakeSocketManager> fake_socket_manager_; scoped_refptr<FakeSocketManager> fake_socket_manager_;
net::IPEndPoint endpoint_; net::IPEndPoint endpoint_;
talk_base::SocketAddress local_address_; talk_base::SocketAddress local_address_;
talk_base::SocketAddress remote_address_; talk_base::SocketAddress remote_address_;
State state_; InternalState state_;
int error_; int error_;
DISALLOW_COPY_AND_ASSIGN(FakeUDPPacketSocket); DISALLOW_COPY_AND_ASSIGN(FakeUDPPacketSocket);