Skip to content

GitLab

T
tangled
Commit 71045750 authored by sergeyu@chromium.org's avatar sergeyu@chromium.org
Browse files
Options

Remove obsolete webkit_glue::P2PTransport interface. 

The P2PTransport interface was used to implement PPB_Transport_Dev
Pepper interface. That interface was removed a while ago. Removing
webkit_glue::P2PTransport too as we don't need it.

Review URL: https://chromiumcodereview.appspot.com/10854131

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151813 0039d316-1c4b-4281-b951-d872f2087c98
parent a5fd82b5
Hide whitespace changes
Inline Side-by-side
Showing with 42 additions and 967 deletions
content/content_renderer.gypi
View file @ 71045750
...@@ -333,8 +333,6 @@ ...@@ -333,8 +333,6 @@
'renderer/p2p/ipc_network_manager.h', 'renderer/p2p/ipc_network_manager.h',
'renderer/p2p/ipc_socket_factory.cc', 'renderer/p2p/ipc_socket_factory.cc',
'renderer/p2p/ipc_socket_factory.h', 'renderer/p2p/ipc_socket_factory.h',
'renderer/p2p/p2p_transport_impl.cc',
'renderer/p2p/p2p_transport_impl.h',
'renderer/p2p/port_allocator.cc', 'renderer/p2p/port_allocator.cc',
'renderer/p2p/port_allocator.h', 'renderer/p2p/port_allocator.h',
'renderer/p2p/socket_client.cc', 'renderer/p2p/socket_client.cc',
......
content/content_tests.gypi
View file @ 71045750
...@@ -445,7 +445,6 @@ ...@@ -445,7 +445,6 @@
'renderer/media/peer_connection_handler_jsep_unittest.cc', 'renderer/media/peer_connection_handler_jsep_unittest.cc',
'renderer/media/rtc_video_decoder_unittest.cc', 'renderer/media/rtc_video_decoder_unittest.cc',
'renderer/media/webrtc_audio_device_unittest.cc', 'renderer/media/webrtc_audio_device_unittest.cc',
'renderer/p2p/p2p_transport_impl_unittest.cc',
], ],
'dependencies': [ 'dependencies': [
'../third_party/libjingle/libjingle.gyp:libjingle_peerconnection', '../third_party/libjingle/libjingle.gyp:libjingle_peerconnection',
......
content/renderer/media/media_stream_dependency_factory.cc
View file @ 71045750
...@@ -34,7 +34,7 @@ class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface { ...@@ -34,7 +34,7 @@ class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface {
LOG(ERROR) << "WebFrame is NULL."; LOG(ERROR) << "WebFrame is NULL.";
return NULL; return NULL;
} }
webkit_glue::P2PTransport::Config config; content::P2PPortAllocator::Config config;
if (stun_servers.size() > 0) { if (stun_servers.size() > 0) {
config.stun_server = stun_servers[0].server.hostname(); config.stun_server = stun_servers[0].server.hostname();
config.stun_server_port = stun_servers[0].server.port(); config.stun_server_port = stun_servers[0].server.port();
......
content/renderer/media/media_stream_dependency_factory.h
View file @ 71045750
...@@ -11,7 +11,6 @@ ...@@ -11,7 +11,6 @@
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "content/common/content_export.h" #include "content/common/content_export.h"
#include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h" #include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h"
#include "webkit/glue/p2p_transport.h"
namespace content { namespace content {
class IpcNetworkManager; class IpcNetworkManager;
......
content/renderer/p2p/p2p_transport_impl.cc deleted 100644 → 0
View file @ a5fd82b5
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/p2p/p2p_transport_impl.h"
#include "content/renderer/p2p/ipc_network_manager.h"
#include "content/renderer/p2p/ipc_socket_factory.h"
#include "content/renderer/p2p/port_allocator.h"
#include "jingle/glue/channel_socket_adapter.h"
#include "jingle/glue/pseudotcp_adapter.h"
#include "jingle/glue/thread_wrapper.h"
#include "jingle/glue/utils.h"
#include "net/base/net_errors.h"
#include "third_party/libjingle/source/talk/base/helpers.h"
#include "third_party/libjingle/source/talk/p2p/base/constants.h"
#include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
#include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
namespace content {
P2PTransportImpl::P2PTransportImpl(
talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory)
: socket_dispatcher_(NULL),
event_handler_(NULL),
state_(STATE_NONE),
network_manager_(network_manager),
socket_factory_(socket_factory) {
}
P2PTransportImpl::P2PTransportImpl(P2PSocketDispatcher* socket_dispatcher)
: socket_dispatcher_(socket_dispatcher),
event_handler_(NULL),
state_(STATE_NONE),
network_manager_(new IpcNetworkManager(socket_dispatcher)),
socket_factory_(new IpcPacketSocketFactory(socket_dispatcher)) {
DCHECK(socket_dispatcher);
}
P2PTransportImpl::~P2PTransportImpl() {
MessageLoop* message_loop = MessageLoop::current();
// Because libjingle's sigslot doesn't handle deletion from a signal
// handler we have to postpone deletion of libjingle objects.
message_loop->DeleteSoon(FROM_HERE, channel_.release());
message_loop->DeleteSoon(FROM_HERE, allocator_.release());
message_loop->DeleteSoon(FROM_HERE, socket_factory_.release());
message_loop->DeleteSoon(FROM_HERE, network_manager_.release());
}
bool P2PTransportImpl::Init(WebKit::WebFrame* web_frame,
const std::string& name,
Protocol protocol,
const Config& config,
EventHandler* event_handler) {
DCHECK(event_handler);
// Before proceeding, ensure we have libjingle thread wrapper for
// the current thread.
jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
name_ = name;
event_handler_ = event_handler;
if (socket_dispatcher_) {
DCHECK(web_frame);
allocator_.reset(new P2PPortAllocator(
web_frame, socket_dispatcher_, network_manager_.get(),
socket_factory_.get(), config));
} else {
// Use BasicPortAllocator if we don't have P2PSocketDispatcher
// (for unittests).
allocator_.reset(new cricket::BasicPortAllocator(
network_manager_.get(), socket_factory_.get()));
}
DCHECK(!channel_.get());
channel_.reset(new cricket::P2PTransportChannel(
"", 0, NULL, allocator_.get()));
channel_->SetIceUfrag(
talk_base::CreateRandomString(cricket::ICE_UFRAG_LENGTH));
channel_->SetIcePwd(talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH));
channel_->SignalRequestSignaling.connect(
this, &P2PTransportImpl::OnRequestSignaling);
channel_->SignalCandidateReady.connect(
this, &P2PTransportImpl::OnCandidateReady);
if (protocol == PROTOCOL_UDP) {
channel_->SignalReadableState.connect(
this, &P2PTransportImpl::OnReadableState);
channel_->SignalWritableState.connect(
this, &P2PTransportImpl::OnWriteableState);
}
channel_adapter_.reset(new jingle_glue::TransportChannelSocketAdapter(
channel_.get()));
channel_->Connect();
if (protocol == PROTOCOL_TCP) {
pseudo_tcp_adapter_.reset(new jingle_glue::PseudoTcpAdapter(
channel_adapter_.release()));
if (config.tcp_receive_window > 0)
pseudo_tcp_adapter_->SetReceiveBufferSize(config.tcp_receive_window);
if (config.tcp_send_window > 0)
pseudo_tcp_adapter_->SetReceiveBufferSize(config.tcp_receive_window);
pseudo_tcp_adapter_->SetNoDelay(config.tcp_no_delay);
if (config.tcp_ack_delay_ms > 0)
pseudo_tcp_adapter_->SetAckDelay(config.tcp_ack_delay_ms);
int result = pseudo_tcp_adapter_->Connect(
base::Bind(&P2PTransportImpl::OnTcpConnected, base::Unretained(this)));
if (result != net::ERR_IO_PENDING)
OnTcpConnected(result);
}
return true;
}
bool P2PTransportImpl::AddRemoteCandidate(const std::string& address) {
cricket::Candidate candidate;
if (!jingle_glue::DeserializeP2PCandidate(address, &candidate)) {
LOG(ERROR) << "Failed to parse candidate " << address;
return false;
}
channel_->OnCandidate(candidate);
return true;
}
void P2PTransportImpl::OnRequestSignaling(
cricket::TransportChannelImpl* channel) {
channel_->OnSignalingReady();
}
void P2PTransportImpl::OnCandidateReady(
cricket::TransportChannelImpl* channel,
const cricket::Candidate& candidate) {
event_handler_->OnCandidateReady(
jingle_glue::SerializeP2PCandidate(candidate));
}
void P2PTransportImpl::OnReadableState(cricket::TransportChannel* channel) {
state_ = static_cast<State>(state_ | STATE_READABLE);
event_handler_->OnStateChange(state_);
}
void P2PTransportImpl::OnWriteableState(cricket::TransportChannel* channel) {
state_ = static_cast<State>(state_ | STATE_WRITABLE);
event_handler_->OnStateChange(state_);
}
net::Socket* P2PTransportImpl::GetChannel() {
if (pseudo_tcp_adapter_.get()) {
DCHECK(!channel_adapter_.get());
return pseudo_tcp_adapter_.get();
} else {
DCHECK(channel_adapter_.get());
return channel_adapter_.get();
}
}
void P2PTransportImpl::OnTcpConnected(int result) {
if (result < 0) {
event_handler_->OnError(result);
return;
}
state_ = static_cast<State>(STATE_READABLE | STATE_WRITABLE);
event_handler_->OnStateChange(state_);
}
} // namespace content
content/renderer/p2p/p2p_transport_impl.h deleted 100644 → 0
View file @ a5fd82b5
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_RENDERER_P2P_P2P_TRANSPORT_IMPL_H_
#define CONTENT_RENDERER_P2P_P2P_TRANSPORT_IMPL_H_
#include <string>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "content/common/content_export.h"
#include "net/base/completion_callback.h"
#include "third_party/libjingle/source/talk/base/sigslot.h"
#include "webkit/glue/p2p_transport.h"
namespace cricket {
class Candidate;
class PortAllocator;
class P2PTransportChannel;
class TransportChannel;
class TransportChannelImpl;
} // namespace cricket
namespace jingle_glue {
class TransportChannelSocketAdapter;
class PseudoTcpAdapter;
} // namespace jingle_glue
namespace talk_base {
class NetworkManager;
class PacketSocketFactory;
} // namespace talk_base
namespace content {
class P2PSocketDispatcher;
class CONTENT_EXPORT P2PTransportImpl
: NON_EXPORTED_BASE(public webkit_glue::P2PTransport),
public sigslot::has_slots<> {
public:
// Creates P2PTransportImpl using specified NetworkManager and
// PacketSocketFactory. Takes ownership of |network_manager| and
// |socket_factory|. Provided to be used for tests only.
P2PTransportImpl(talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory);
// Creates P2PTransportImpl using specified
// P2PSocketDispatcher. This constructor creates IpcNetworkManager
// and IpcPacketSocketFactory, and keeps ownership of these objects.
explicit P2PTransportImpl(P2PSocketDispatcher* socket_dispatcher);
virtual ~P2PTransportImpl();
// webkit_glue::P2PTransport interface.
virtual bool Init(WebKit::WebFrame* web_frame,
const std::string& name,
Protocol protocol,
const Config& config,
EventHandler* event_handler) OVERRIDE;
virtual bool AddRemoteCandidate(const std::string& address) OVERRIDE;
virtual net::Socket* GetChannel() OVERRIDE;
private:
class ChannelAdapter;
void OnRequestSignaling(cricket::TransportChannelImpl* channel);
void OnCandidateReady(cricket::TransportChannelImpl* channel,
const cricket::Candidate& candidate);
void OnReadableState(cricket::TransportChannel* channel);
void OnWriteableState(cricket::TransportChannel* channel);
void OnTcpConnected(int result);
P2PSocketDispatcher* socket_dispatcher_;
std::string name_;
EventHandler* event_handler_;
State state_;
scoped_ptr<talk_base::NetworkManager> network_manager_;
scoped_ptr<talk_base::PacketSocketFactory> socket_factory_;
scoped_ptr<cricket::PortAllocator> allocator_;
scoped_ptr<cricket::P2PTransportChannel> channel_;
scoped_ptr<jingle_glue::TransportChannelSocketAdapter> channel_adapter_;
scoped_ptr<jingle_glue::PseudoTcpAdapter> pseudo_tcp_adapter_;
DISALLOW_COPY_AND_ASSIGN(P2PTransportImpl);
};
} // namespace content
#endif // CONTENT_RENDERER_P2P_P2P_TRANSPORT_IMPL_H_
content/renderer/p2p/p2p_transport_impl_unittest.cc deleted 100644 → 0
View file @ a5fd82b5
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/p2p/p2p_transport_impl.h"
#include "base/bind.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/message_loop.h"
#include "base/test/test_timeouts.h"
#include "jingle/glue/fake_network_manager.h"
#include "jingle/glue/fake_socket_factory.h"
#include "jingle/glue/thread_wrapper.h"
#include "net/base/completion_callback.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/base/net_util.h"
#include "net/socket/socket.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::_;
using testing::AtMost;
using testing::Exactly;
using testing::InvokeWithoutArgs;
using webkit_glue::P2PTransport;
namespace {
const char kTestAddress1[] = "192.168.15.12";
const char kTestAddress2[] = "192.168.15.33";
const char kTransportName1[] = "tr1";
const char kTransportName2[] = "tr2";
// Send 10 packets 10 bytes each. Packets are sent with 10ms delay
// between packets (about 100 ms for 10 messages).
const int kMessageSize = 10;
const int kMessages = 10;
const int kUdpWriteDelayMs = 10;
const int kTcpDataSize = 10 * 1024;
const int kTcpWriteDelayMs = 1;
class UdpChannelTester : public base::RefCountedThreadSafe<UdpChannelTester> {
public:
UdpChannelTester(MessageLoop* message_loop,
net::Socket* write_socket,
net::Socket* read_socket)
: message_loop_(message_loop),
write_socket_(write_socket),
read_socket_(read_socket),
done_(false),
write_errors_(0),
read_errors_(0),
packets_sent_(0),
packets_received_(0),
broken_packets_(0) {
}
void Start() {
message_loop_->PostTask(
FROM_HERE, base::Bind(&UdpChannelTester::DoStart, this));
}
void CheckResults() {
EXPECT_EQ(0, write_errors_);
EXPECT_EQ(0, read_errors_);
EXPECT_EQ(0, broken_packets_);
// Verify that we've received at least one packet.
EXPECT_GT(packets_received_, 0);
LOG(INFO) << "Received " << packets_received_ << " packets out of "
<< kMessages;
}
protected:
friend class base::RefCountedThreadSafe<UdpChannelTester>;
virtual ~UdpChannelTester() {}
void Done() {
done_ = true;
message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
}
void DoStart() {
DoRead();
DoWrite();
}
void DoWrite() {
if (packets_sent_ >= kMessages) {
Done();
return;
}
scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(kMessageSize));
memset(packet->data(), 123, kMessageSize);
sent_packets_[packets_sent_] = packet;
// Put index of this packet in the beginning of the packet body.
memcpy(packet->data(), &packets_sent_, sizeof(packets_sent_));
int result = write_socket_->Write(packet, kMessageSize,
base::Bind(&UdpChannelTester::OnWritten,
base::Unretained(this)));
HandleWriteResult(result);
}
void OnWritten(int result) {
HandleWriteResult(result);
}
void HandleWriteResult(int result) {
if (result <= 0 && result != net::ERR_IO_PENDING) {
LOG(ERROR) << "Received error " << result << " when trying to write";
write_errors_++;
Done();
} else if (result > 0) {
EXPECT_EQ(kMessageSize, result);
packets_sent_++;
message_loop_->PostDelayedTask(
FROM_HERE, base::Bind(&UdpChannelTester::DoWrite, this),
base::TimeDelta::FromMilliseconds(kUdpWriteDelayMs));
}
}
void DoRead() {
int result = 1;
while (result > 0) {
int kReadSize = kMessageSize * 2;
read_buffer_ = new net::IOBuffer(kReadSize);
result = read_socket_->Read(read_buffer_, kReadSize,
base::Bind(&UdpChannelTester::OnRead,
base::Unretained(this)));
HandleReadResult(result);
};
}
void OnRead(int result) {
HandleReadResult(result);
DoRead();
}
void HandleReadResult(int result) {
if (result <= 0 && result != net::ERR_IO_PENDING) {
// Error will be received after the socket is closed.
if (!done_) {
LOG(ERROR) << "Received error " << result << " when trying to read";
read_errors_++;
Done();
}
} else if (result > 0) {
packets_received_++;
if (kMessageSize != result) {
// Invalid packet size;
broken_packets_++;
} else {
// Validate packet body.
int packet_id;
memcpy(&packet_id, read_buffer_->data(), sizeof(packet_id));
if (packet_id < 0 || packet_id >= kMessages) {
broken_packets_++;
} else {
if (memcmp(read_buffer_->data(), sent_packets_[packet_id]->data(),
kMessageSize) != 0)
broken_packets_++;
}
}
}
}
private:
MessageLoop* message_loop_;
net::Socket* write_socket_;
net::Socket* read_socket_;
bool done_;
scoped_refptr<net::IOBuffer> sent_packets_[kMessages];
scoped_refptr<net::IOBuffer> read_buffer_;
int write_errors_;
int read_errors_;
int packets_sent_;
int packets_received_;
int broken_packets_;
};
class TcpChannelTester : public base::RefCountedThreadSafe<TcpChannelTester> {
public:
TcpChannelTester(MessageLoop* message_loop,
net::Socket* write_socket,
net::Socket* read_socket)
: message_loop_(message_loop),
write_socket_(write_socket),
read_socket_(read_socket),
done_(false),
write_errors_(0),
read_errors_(0) {
}
void Init() {
// Initialize |send_buffer_|.
send_buffer_ = new net::DrainableIOBuffer(new net::IOBuffer(kTcpDataSize),
kTcpDataSize);
for (int i = 0; i < kTcpDataSize; ++i) {
send_buffer_->data()[i] = rand() % 256;
}
}
void StartRead() {
message_loop_->PostTask(
FROM_HERE, base::Bind(&TcpChannelTester::DoRead, this));
}
void StartWrite() {
message_loop_->PostTask(
FROM_HERE, base::Bind(&TcpChannelTester::DoWrite, this));
}
void CheckResults() {
EXPECT_EQ(0, write_errors_);
EXPECT_EQ(0, read_errors_);
EXPECT_EQ(0, send_buffer_->BytesRemaining());
send_buffer_->SetOffset(0);
EXPECT_EQ(kTcpDataSize, static_cast<int>(received_data_.size()));
EXPECT_EQ(0, memcmp(send_buffer_->data(),
&received_data_[0], received_data_.size()));
}
protected:
friend class base::RefCountedThreadSafe<TcpChannelTester>;
virtual ~TcpChannelTester() {}
void Done() {
done_ = true;
message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
}
void DoWrite() {
if (send_buffer_->BytesRemaining() == 0) {
return;
}
int result = write_socket_->Write(
send_buffer_, send_buffer_->BytesRemaining(),
base::Bind(&TcpChannelTester::OnWritten, base::Unretained(this)));
HandleWriteResult(result);
}
void OnWritten(int result) {
HandleWriteResult(result);
}
void HandleWriteResult(int result) {
if (result <= 0 && result != net::ERR_IO_PENDING) {
LOG(ERROR) << "Received error " << result << " when trying to write";
write_errors_++;
Done();
} else if (result > 0) {
send_buffer_->DidConsume(result);
message_loop_->PostDelayedTask(
FROM_HERE, base::Bind(&TcpChannelTester::DoWrite, this),
base::TimeDelta::FromMilliseconds(kTcpWriteDelayMs));
}
}
void DoRead() {
int result = 1;
while (result > 0) {
int kReadSize = kMessageSize * 2;
read_buffer_ = new net::IOBuffer(kReadSize);
result = read_socket_->Read(
read_buffer_, kReadSize,
base::Bind(&TcpChannelTester::OnRead, base::Unretained(this)));
HandleReadResult(result);
};
}
void OnRead(int result) {
HandleReadResult(result);
DoRead();
}
void HandleReadResult(int result) {
if (result <= 0 && result != net::ERR_IO_PENDING) {
// Error will be received after the socket is closed.
if (!done_) {
LOG(ERROR) << "Received error " << result << " when trying to read";
read_errors_++;
Done();
}
} else if (result > 0) {
received_data_.insert(received_data_.end(), read_buffer_->data(),
read_buffer_->data() + result);
if (static_cast<int>(received_data_.size()) == kTcpDataSize)
Done();
}
}
private:
MessageLoop* message_loop_;
net::Socket* write_socket_;
net::Socket* read_socket_;
bool done_;
scoped_refptr<net::DrainableIOBuffer> send_buffer_;
scoped_refptr<net::IOBuffer> read_buffer_;
std::vector<char> sent_data_;
std::vector<char> received_data_;
int write_errors_;
int read_errors_;
};
} // namespace
namespace content {
class MockP2PEventHandler : public P2PTransport::EventHandler {
public:
MOCK_METHOD1(OnCandidateReady, void(const std::string& address));
MOCK_METHOD1(OnStateChange, void(P2PTransport::State state));
MOCK_METHOD1(OnError, void(int error));
};
class P2PTransportImplTest : public testing::Test {
public:
void DestroyTransport() {
transport1_.reset();
transport2_.reset();
}
protected:
virtual void SetUp() OVERRIDE {
socket_manager_ = new jingle_glue::FakeSocketManager();
net::IPAddressNumber ip;
ASSERT_TRUE(net::ParseIPLiteralToNumber(kTestAddress1, &ip));
transport1_.reset(new P2PTransportImpl(
new jingle_glue::FakeNetworkManager(ip),
new jingle_glue::FakeSocketFactory(socket_manager_, ip)));
ASSERT_TRUE(net::ParseIPLiteralToNumber(kTestAddress2, &ip));
transport2_.reset(new P2PTransportImpl(
new jingle_glue::FakeNetworkManager(ip),
new jingle_glue::FakeSocketFactory(socket_manager_, ip)));
}
virtual void TearDown() OVERRIDE {
DestroyTransport();
message_loop_.RunAllPending();
}
void Init(P2PTransport::Protocol protocol) {
P2PTransport::Config config;
ASSERT_TRUE(transport1_->Init(
NULL, kTransportName1, protocol, config, &event_handler1_));
ASSERT_TRUE(transport2_->Init(
NULL, kTransportName2, protocol, config, &event_handler2_));
}
MessageLoop message_loop_;
scoped_refptr<jingle_glue::FakeSocketManager> socket_manager_;
scoped_ptr<P2PTransportImpl> transport1_;
MockP2PEventHandler event_handler1_;
scoped_ptr<P2PTransportImpl> transport2_;
MockP2PEventHandler event_handler2_;
};
TEST_F(P2PTransportImplTest, Create) {
Init(P2PTransport::PROTOCOL_UDP);
EXPECT_CALL(event_handler1_, OnCandidateReady(_));
EXPECT_CALL(event_handler2_, OnCandidateReady(_));
message_loop_.RunAllPending();
}
ACTION_P(AddRemoteCandidate, transport) {
EXPECT_TRUE(transport->AddRemoteCandidate(arg0));
}
TEST_F(P2PTransportImplTest, ConnectUdp) {
Init(P2PTransport::PROTOCOL_UDP);
EXPECT_CALL(event_handler1_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport2_.get()));
EXPECT_CALL(event_handler2_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport1_.get()));
message_loop_.RunAllPending();
}
TEST_F(P2PTransportImplTest, ConnectTcp) {
Init(P2PTransport::PROTOCOL_TCP);
EXPECT_CALL(event_handler1_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport2_.get()));
EXPECT_CALL(event_handler2_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport1_.get()));
message_loop_.RunAllPending();
}
TEST_F(P2PTransportImplTest, SendDataUdp) {
Init(P2PTransport::PROTOCOL_UDP);
EXPECT_CALL(event_handler1_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport2_.get()));
EXPECT_CALL(event_handler2_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport1_.get()));
// Transport may first become ether readable or writable, but
// eventually it must be readable and writable.
EXPECT_CALL(event_handler1_, OnStateChange(P2PTransport::STATE_READABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler1_, OnStateChange(P2PTransport::STATE_WRITABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler1_, OnStateChange(
static_cast<P2PTransport::State>(P2PTransport::STATE_READABLE |
P2PTransport::STATE_WRITABLE)))
.Times(Exactly(1));
EXPECT_CALL(event_handler2_, OnStateChange(P2PTransport::STATE_READABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(P2PTransport::STATE_WRITABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(
static_cast<P2PTransport::State>(P2PTransport::STATE_READABLE |
P2PTransport::STATE_WRITABLE)))
.Times(Exactly(1));
scoped_refptr<UdpChannelTester> channel_tester = new UdpChannelTester(
&message_loop_, transport1_->GetChannel(), transport2_->GetChannel());
message_loop_.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
TestTimeouts::action_max_timeout());
channel_tester->Start();
message_loop_.Run();
channel_tester->CheckResults();
}
TEST_F(P2PTransportImplTest, SendDataTcp) {
Init(P2PTransport::PROTOCOL_TCP);
EXPECT_CALL(event_handler1_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport2_.get()));
EXPECT_CALL(event_handler2_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport1_.get()));
scoped_refptr<TcpChannelTester> channel_tester = new TcpChannelTester(
&message_loop_, transport1_->GetChannel(), transport2_->GetChannel());
// Transport may first become ether readable or writable, but
// eventually it must be readable and writable.
EXPECT_CALL(event_handler1_, OnStateChange(P2PTransport::STATE_READABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler1_, OnStateChange(P2PTransport::STATE_WRITABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler1_, OnStateChange(
static_cast<P2PTransport::State>(P2PTransport::STATE_READABLE |
P2PTransport::STATE_WRITABLE)))
.Times(Exactly(1))
.WillOnce(InvokeWithoutArgs(channel_tester.get(),
&TcpChannelTester::StartWrite))
.RetiresOnSaturation();
EXPECT_CALL(event_handler2_, OnStateChange(P2PTransport::STATE_READABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(P2PTransport::STATE_WRITABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(
static_cast<P2PTransport::State>(P2PTransport::STATE_READABLE |
P2PTransport::STATE_WRITABLE)))
.Times(Exactly(1))
.WillOnce(InvokeWithoutArgs(channel_tester.get(),
&TcpChannelTester::StartRead))
.RetiresOnSaturation();
message_loop_.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
TestTimeouts::action_max_timeout());
channel_tester->Init();
message_loop_.Run();
channel_tester->CheckResults();
}
TEST_F(P2PTransportImplTest, DeleteFromCallback) {
Init(P2PTransport::PROTOCOL_TCP);
EXPECT_CALL(event_handler1_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport2_.get()));
EXPECT_CALL(event_handler2_, OnCandidateReady(_)).WillRepeatedly(
AddRemoteCandidate(transport1_.get()));
// Transport may first become ether readable or writable, but
// eventually it must be readable and writable.
EXPECT_CALL(event_handler1_, OnStateChange(P2PTransport::STATE_READABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler1_, OnStateChange(P2PTransport::STATE_WRITABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler1_, OnStateChange(
static_cast<P2PTransport::State>(P2PTransport::STATE_READABLE |
P2PTransport::STATE_WRITABLE)))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(P2PTransport::STATE_READABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(P2PTransport::STATE_WRITABLE))
.Times(AtMost(1));
EXPECT_CALL(event_handler2_, OnStateChange(
static_cast<P2PTransport::State>(P2PTransport::STATE_READABLE |
P2PTransport::STATE_WRITABLE)))
.Times(Exactly(1))
.WillOnce(DoAll(
InvokeWithoutArgs(this, &P2PTransportImplTest::DestroyTransport),
InvokeWithoutArgs(&message_loop_, &MessageLoop::Quit)));
message_loop_.Run();
}
} // namespace content
content/renderer/p2p/port_allocator.cc
View file @ 71045750
...@@ -50,12 +50,22 @@ bool ParsePortNumber( ...@@ -50,12 +50,22 @@ bool ParsePortNumber(
} // namespace } // namespace
P2PPortAllocator::Config::Config()
: stun_server_port(0),
relay_server_port(0),
legacy_relay(false),
disable_tcp_transport(false) {
}
P2PPortAllocator::Config::~Config() {
}
P2PPortAllocator::P2PPortAllocator( P2PPortAllocator::P2PPortAllocator(
WebKit::WebFrame* web_frame, WebKit::WebFrame* web_frame,
P2PSocketDispatcher* socket_dispatcher, P2PSocketDispatcher* socket_dispatcher,
talk_base::NetworkManager* network_manager, talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory, talk_base::PacketSocketFactory* socket_factory,
const webkit_glue::P2PTransport::Config& config) const Config& config)
: cricket::BasicPortAllocator(network_manager, socket_factory), : cricket::BasicPortAllocator(network_manager, socket_factory),
web_frame_(web_frame), web_frame_(web_frame),
socket_dispatcher_(socket_dispatcher), socket_dispatcher_(socket_dispatcher),
......
content/renderer/p2p/port_allocator.h
View file @ 71045750
...@@ -10,7 +10,6 @@ ...@@ -10,7 +10,6 @@
#include "net/base/net_util.h" #include "net/base/net_util.h"
#include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h" #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLLoaderClient.h" #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLLoaderClient.h"
#include "webkit/glue/p2p_transport.h"
namespace WebKit { namespace WebKit {
class WebFrame; class WebFrame;
...@@ -23,15 +22,41 @@ class P2PHostAddressRequest; ...@@ -23,15 +22,41 @@ class P2PHostAddressRequest;
class P2PPortAllocatorSession; class P2PPortAllocatorSession;
class P2PSocketDispatcher; class P2PSocketDispatcher;
// TODO(sergeyu): There is overlap between this class and // TODO(sergeyu): There is overlap between this class and HttpPortAllocator.
// HttpPortAllocator. Refactor HttpPortAllocator // Refactor this class to inherit from HttpPortAllocator to avoid code
// duplication.
class P2PPortAllocator : public cricket::BasicPortAllocator { class P2PPortAllocator : public cricket::BasicPortAllocator {
public: public:
struct Config {
Config();
~Config();
// STUN server address and port.
std::string stun_server;
int stun_server_port;
// Relay server address and port.
std::string relay_server;
int relay_server_port;
// Relay server username.
std::string relay_username;
// Relay server password.
std::string relay_password;
// When set to true relay is a legacy Google relay (not TURN compliant).
bool legacy_relay;
// Disable TCP-based transport when set to true.
bool disable_tcp_transport;
};
P2PPortAllocator(WebKit::WebFrame* web_frame, P2PPortAllocator(WebKit::WebFrame* web_frame,
P2PSocketDispatcher* socket_dispatcher, P2PSocketDispatcher* socket_dispatcher,
talk_base::NetworkManager* network_manager, talk_base::NetworkManager* network_manager,
talk_base::PacketSocketFactory* socket_factory, talk_base::PacketSocketFactory* socket_factory,
const webkit_glue::P2PTransport::Config& config); const Config& config);
virtual ~P2PPortAllocator(); virtual ~P2PPortAllocator();
virtual cricket::PortAllocatorSession* CreateSessionInternal( virtual cricket::PortAllocatorSession* CreateSessionInternal(
...@@ -45,7 +70,7 @@ class P2PPortAllocator : public cricket::BasicPortAllocator { ...@@ -45,7 +70,7 @@ class P2PPortAllocator : public cricket::BasicPortAllocator {
WebKit::WebFrame* web_frame_; WebKit::WebFrame* web_frame_;
P2PSocketDispatcher* socket_dispatcher_; P2PSocketDispatcher* socket_dispatcher_;
webkit_glue::P2PTransport::Config config_; Config config_;
DISALLOW_COPY_AND_ASSIGN(P2PPortAllocator); DISALLOW_COPY_AND_ASSIGN(P2PPortAllocator);
}; };
......
content/renderer/pepper/pepper_plugin_delegate_impl.cc
View file @ 71045750
...@@ -40,7 +40,6 @@ ...@@ -40,7 +40,6 @@
#include "content/renderer/media/audio_hardware.h" #include "content/renderer/media/audio_hardware.h"
#include "content/renderer/media/media_stream_dispatcher.h" #include "content/renderer/media/media_stream_dispatcher.h"
#include "content/renderer/media/pepper_platform_video_decoder_impl.h" #include "content/renderer/media/pepper_platform_video_decoder_impl.h"
#include "content/renderer/p2p/p2p_transport_impl.h"
#include "content/renderer/p2p/socket_dispatcher.h" #include "content/renderer/p2p/socket_dispatcher.h"
#include "content/renderer/pepper/content_renderer_pepper_host_factory.h" #include "content/renderer/pepper/content_renderer_pepper_host_factory.h"
#include "content/renderer/pepper/pepper_broker_impl.h" #include "content/renderer/pepper/pepper_broker_impl.h"
...@@ -1402,14 +1401,6 @@ void PepperPluginDelegateImpl::SaveURLAs(const GURL& url) { ...@@ -1402,14 +1401,6 @@ void PepperPluginDelegateImpl::SaveURLAs(const GURL& url) {
render_view_->routing_id(), url, referrer)); render_view_->routing_id(), url, referrer));
} }
webkit_glue::P2PTransport* PepperPluginDelegateImpl::CreateP2PTransport() {
#if defined(ENABLE_P2P_APIS)
return new P2PTransportImpl(render_view_->p2p_socket_dispatcher());
#else
return NULL;
#endif
}
double PepperPluginDelegateImpl::GetLocalTimeZoneOffset(base::Time t) { double PepperPluginDelegateImpl::GetLocalTimeZoneOffset(base::Time t) {
double result = 0.0; double result = 0.0;
render_view_->Send(new PepperMsg_GetLocalTimeZoneOffset( render_view_->Send(new PepperMsg_GetLocalTimeZoneOffset(
......
content/renderer/pepper/pepper_plugin_delegate_impl.h
View file @ 71045750
...@@ -361,7 +361,6 @@ class PepperPluginDelegateImpl ...@@ -361,7 +361,6 @@ class PepperPluginDelegateImpl
virtual void DidStopLoading() OVERRIDE; virtual void DidStopLoading() OVERRIDE;
virtual void SetContentRestriction(int restrictions) OVERRIDE; virtual void SetContentRestriction(int restrictions) OVERRIDE;
virtual void SaveURLAs(const GURL& url) OVERRIDE; virtual void SaveURLAs(const GURL& url) OVERRIDE;
virtual webkit_glue::P2PTransport* CreateP2PTransport() OVERRIDE;
virtual double GetLocalTimeZoneOffset(base::Time t) OVERRIDE; virtual double GetLocalTimeZoneOffset(base::Time t) OVERRIDE;
virtual base::SharedMemory* CreateAnonymousSharedMemory(uint32_t size) virtual base::SharedMemory* CreateAnonymousSharedMemory(uint32_t size)
OVERRIDE; OVERRIDE;
......
webkit/glue/p2p_transport.cc deleted 100644 → 0
View file @ a5fd82b5
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "webkit/glue/p2p_transport.h"
namespace webkit_glue {
P2PTransport::Config::Config()
: stun_server_port(0),
relay_server_port(0),
legacy_relay(false),
tcp_receive_window(0),
tcp_send_window(0),
tcp_no_delay(false),
tcp_ack_delay_ms(0),
disable_tcp_transport(false) {
}
P2PTransport::Config::~Config() {
}
} // namespace webkit_glue
webkit/glue/p2p_transport.h deleted 100644 → 0
View file @ a5fd82b5
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef WEBKIT_GLUE_P2P_TRANSPORT_H_
#define WEBKIT_GLUE_P2P_TRANSPORT_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "webkit/glue/webkit_glue_export.h"
namespace net {
class Socket;
} // namespace net
namespace WebKit {
class WebFrame;
} // namespace WebKit
namespace webkit_glue {
// Interface for P2P transport.
class P2PTransport {
public:
enum State {
STATE_NONE = 0,
STATE_WRITABLE = 1,
STATE_READABLE = 2,
};
enum Protocol {
PROTOCOL_UDP = 0,
PROTOCOL_TCP = 1,
};
class EventHandler {
public:
virtual ~EventHandler() {}
// Called for each local candidate.
virtual void OnCandidateReady(const std::string& address) = 0;
// Called when readable of writable state of the stream changes.
virtual void OnStateChange(State state) = 0;
// Called when an error occures (e.g. TCP handshake
// failed). P2PTransport object is not usable after that and
// should be destroyed.
virtual void OnError(int error) = 0;
};
struct WEBKIT_GLUE_EXPORT Config {
Config();
~Config();
// STUN server address and port.
std::string stun_server;
int stun_server_port;
// Relay server address and port.
std::string relay_server;
int relay_server_port;
// Relay server username.
std::string relay_username;
// Relay server password.
std::string relay_password;
// When set to true relay is a legacy Google relay (not TURN
// compliant).
bool legacy_relay;
// TCP window sizes. Default size is used when set to 0.
int tcp_receive_window;
int tcp_send_window;
// Disables Neagle's algorithm when set to true.
bool tcp_no_delay;
// TCP ACK delay.
int tcp_ack_delay_ms;
// Disable TCP-based transport when set to true.
bool disable_tcp_transport;
};
virtual ~P2PTransport() {}
// Initialize transport using specified configuration. |web_frame|
// is used to make HTTP requests to relay servers. Returns true
// if initialization succeeded.
virtual bool Init(WebKit::WebFrame* web_frame,
const std::string& name,
Protocol protocol,
const Config& config,
EventHandler* event_handler) = 0;
// Add candidate received from the remote peer. Returns false if the
// provided address is not in a valid format.
virtual bool AddRemoteCandidate(const std::string& address) = 0;
// Returns socket interface that can be used to send/receive
// data. Returned object is owned by the transport. Pending calls on
// the socket are canceled when the transport is destroyed.
virtual net::Socket* GetChannel() = 0;
};
} // namespace webkit_glue
#endif // WEBKIT_GLUE_P2P_TRANSPORT_H_
webkit/glue/webkit_glue.gypi
View file @ 71045750
...@@ -374,8 +374,6 @@ ...@@ -374,8 +374,6 @@
'network_list_observer.h', 'network_list_observer.h',
'npruntime_util.cc', 'npruntime_util.cc',
'npruntime_util.h', 'npruntime_util.h',
'p2p_transport.cc',
'p2p_transport.h',
'resource_fetcher.cc', 'resource_fetcher.cc',
'resource_fetcher.h', 'resource_fetcher.h',
'resource_loader_bridge.cc', 'resource_loader_bridge.cc',
......
webkit/plugins/ppapi/mock_plugin_delegate.cc
View file @ 71045750
...@@ -398,10 +398,6 @@ void MockPluginDelegate::SetContentRestriction(int restrictions) { ...@@ -398,10 +398,6 @@ void MockPluginDelegate::SetContentRestriction(int restrictions) {
void MockPluginDelegate::SaveURLAs(const GURL& url) { void MockPluginDelegate::SaveURLAs(const GURL& url) {
} }
webkit_glue::P2PTransport* MockPluginDelegate::CreateP2PTransport() {
return NULL;
}
double MockPluginDelegate::GetLocalTimeZoneOffset(base::Time t) { double MockPluginDelegate::GetLocalTimeZoneOffset(base::Time t) {
return 0.0; return 0.0;
} }
......
webkit/plugins/ppapi/mock_plugin_delegate.h
View file @ 71045750
...@@ -187,7 +187,6 @@ class MockPluginDelegate : public PluginDelegate { ...@@ -187,7 +187,6 @@ class MockPluginDelegate : public PluginDelegate {
virtual void DidStopLoading(); virtual void DidStopLoading();
virtual void SetContentRestriction(int restrictions); virtual void SetContentRestriction(int restrictions);
virtual void SaveURLAs(const GURL& url); virtual void SaveURLAs(const GURL& url);
virtual webkit_glue::P2PTransport* CreateP2PTransport();
virtual double GetLocalTimeZoneOffset(base::Time t); virtual double GetLocalTimeZoneOffset(base::Time t);
virtual base::SharedMemory* CreateAnonymousSharedMemory(uint32_t size); virtual base::SharedMemory* CreateAnonymousSharedMemory(uint32_t size);
virtual ::ppapi::Preferences GetPreferences(); virtual ::ppapi::Preferences GetPreferences();
......
webkit/plugins/ppapi/plugin_delegate.h
View file @ 71045750
...@@ -602,9 +602,6 @@ class PluginDelegate { ...@@ -602,9 +602,6 @@ class PluginDelegate {
// Tells the browser to bring up SaveAs dialog to save specified URL. // Tells the browser to bring up SaveAs dialog to save specified URL.
virtual void SaveURLAs(const GURL& url) = 0; virtual void SaveURLAs(const GURL& url) = 0;
// Creates P2PTransport object.
virtual webkit_glue::P2PTransport* CreateP2PTransport() = 0;
virtual double GetLocalTimeZoneOffset(base::Time t) = 0; virtual double GetLocalTimeZoneOffset(base::Time t) = 0;
// Create an anonymous shared memory segment of size |size| bytes, and return // Create an anonymous shared memory segment of size |size| bytes, and return
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment