From 3e860d5aff9623d8252e0ed93e13645733b61f8b Mon Sep 17 00:00:00 2001 From: "sergeyu@chromium.org" Date: Sat, 9 Aug 2014 10:20:32 +0000 Subject: Add PepperAddressResolver. The new PepperAddressResolver provides AsyncResolverInterface implementation to P2PTransportChannel and is used there to resolve address of the STUN server. It's required after recent changes in libjingle. Also remove STUN address resolution from PepperPortAllocator as it is not needed there anymore. BUG=401102 Review URL: https://codereview.chromium.org/452923005 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@288549 0039d316-1c4b-4281-b951-d872f2087c98 --- remoting/client/plugin/pepper_address_resolver.cc | 84 ++++++++++++++++++++ remoting/client/plugin/pepper_address_resolver.h | 45 +++++++++++ .../client/plugin/pepper_packet_socket_factory.cc | 5 +- remoting/client/plugin/pepper_port_allocator.cc | 89 +--------------------- remoting/remoting_srcs.gypi | 2 + 5 files changed, 137 insertions(+), 88 deletions(-) create mode 100644 remoting/client/plugin/pepper_address_resolver.cc create mode 100644 remoting/client/plugin/pepper_address_resolver.h (limited to 'remoting') diff --git a/remoting/client/plugin/pepper_address_resolver.cc b/remoting/client/plugin/pepper_address_resolver.cc new file mode 100644 index 0000000..b39e4d7 --- /dev/null +++ b/remoting/client/plugin/pepper_address_resolver.cc @@ -0,0 +1,84 @@ +// Copyright 2014 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 "remoting/client/plugin/pepper_address_resolver.h" + +#include "base/logging.h" +#include "ppapi/cpp/net_address.h" +#include "remoting/client/plugin/pepper_util.h" + +namespace remoting { + +PepperAddressResolver::PepperAddressResolver(const pp::InstanceHandle& instance) + : resolver_(instance), + error_(0), + callback_factory_(this) { +} + +PepperAddressResolver::~PepperAddressResolver() { +} + +void PepperAddressResolver::Start(const rtc::SocketAddress& address) { + DCHECK(!address.hostname().empty()); + + PP_HostResolver_Hint hint; + hint.flags = 0; + hint.family = PP_NETADDRESS_FAMILY_UNSPECIFIED; + pp::CompletionCallback callback = + callback_factory_.NewCallback(&PepperAddressResolver::OnResolved); + int result = resolver_.Resolve( + address.hostname().c_str(), address.port(), hint, callback); + DCHECK_EQ(result, PP_OK_COMPLETIONPENDING); +} + +bool PepperAddressResolver::GetResolvedAddress(int family, + rtc::SocketAddress* addr) const { + rtc::SocketAddress result; + switch (family) { + case AF_INET: + result = ipv4_address_; + break; + case AF_INET6: + result = ipv6_address_; + break; + } + + if (result.IsNil()) + return false; + + *addr = result; + return true; +} + +int PepperAddressResolver::GetError() const { + return error_; +} + +void PepperAddressResolver::Destroy(bool wait) { + delete this; +} + +void PepperAddressResolver::OnResolved(int32_t result) { + if (result < 0) { + error_ = EAI_FAIL; + SignalDone(this); + return; + } + + int count = resolver_.GetNetAddressCount(); + for (int i = 0; i < count; ++i) { + pp::NetAddress address = resolver_.GetNetAddress(i); + if (address.GetFamily() == PP_NETADDRESS_FAMILY_IPV4 && + ipv4_address_.IsNil()) { + PpNetAddressToSocketAddress(address, &ipv4_address_); + } else if (address.GetFamily() == PP_NETADDRESS_FAMILY_IPV6 && + ipv6_address_.IsNil()) { + PpNetAddressToSocketAddress(address, &ipv6_address_); + } + } + + SignalDone(this); +} + +} // namespace remoting diff --git a/remoting/client/plugin/pepper_address_resolver.h b/remoting/client/plugin/pepper_address_resolver.h new file mode 100644 index 0000000..37012ea --- /dev/null +++ b/remoting/client/plugin/pepper_address_resolver.h @@ -0,0 +1,45 @@ +// Copyright 2014 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 REMOTING_CLIENT_PLUGIN_PEPPER_ADDRESS_RESOLVER_H_ +#define REMOTING_CLIENT_PLUGIN_PEPPER_ADDRESS_RESOLVER_H_ + +#include "ppapi/cpp/host_resolver.h" +#include "ppapi/utility/completion_callback_factory.h" +#include "third_party/webrtc/base/asyncresolverinterface.h" + +namespace remoting { + +// rtc::AsyncResolverInterface implementation that uses Pepper to resolve +// addresses. +class PepperAddressResolver : public rtc::AsyncResolverInterface { + public: + explicit PepperAddressResolver(const pp::InstanceHandle& instance); + virtual ~PepperAddressResolver(); + + // rtc::AsyncResolverInterface. + virtual void Start(const rtc::SocketAddress& addr) OVERRIDE; + virtual bool GetResolvedAddress(int family, + rtc::SocketAddress* addr) const OVERRIDE; + virtual int GetError() const OVERRIDE; + virtual void Destroy(bool wait) OVERRIDE; + + private: + void OnResolved(int32_t result); + + pp::HostResolver resolver_; + + rtc::SocketAddress ipv4_address_; + rtc::SocketAddress ipv6_address_; + + int error_; + + pp::CompletionCallbackFactory callback_factory_; + + DISALLOW_COPY_AND_ASSIGN(PepperAddressResolver); +}; + +} // namespace remoting + +#endif // REMOTING_CLIENT_PLUGIN_PEPPER_ADDRESS_RESOLVER_H_ diff --git a/remoting/client/plugin/pepper_packet_socket_factory.cc b/remoting/client/plugin/pepper_packet_socket_factory.cc index 4909f89..01a20a3 100644 --- a/remoting/client/plugin/pepper_packet_socket_factory.cc +++ b/remoting/client/plugin/pepper_packet_socket_factory.cc @@ -11,9 +11,11 @@ #include "ppapi/cpp/net_address.h" #include "ppapi/cpp/udp_socket.h" #include "ppapi/utility/completion_callback_factory.h" +#include "remoting/client/plugin/pepper_address_resolver.h" #include "remoting/client/plugin/pepper_util.h" #include "remoting/protocol/socket_util.h" #include "third_party/webrtc/base/asyncpacketsocket.h" +#include "third_party/webrtc/base/nethelpers.h" namespace remoting { @@ -437,8 +439,7 @@ rtc::AsyncPacketSocket* PepperPacketSocketFactory::CreateClientTcpSocket( rtc::AsyncResolverInterface* PepperPacketSocketFactory::CreateAsyncResolver() { - NOTREACHED(); - return NULL; + return new PepperAddressResolver(pp_instance_); } } // namespace remoting diff --git a/remoting/client/plugin/pepper_port_allocator.cc b/remoting/client/plugin/pepper_port_allocator.cc index 5cceee1..bcbb1b2 100644 --- a/remoting/client/plugin/pepper_port_allocator.cc +++ b/remoting/client/plugin/pepper_port_allocator.cc @@ -8,8 +8,6 @@ #include "base/strings/string_number_conversions.h" #include "net/base/net_util.h" #include "ppapi/c/pp_errors.h" -#include "ppapi/cpp/host_resolver.h" -#include "ppapi/cpp/net_address.h" #include "ppapi/cpp/url_loader.h" #include "ppapi/cpp/url_request_info.h" #include "ppapi/cpp/url_response_info.h" @@ -47,16 +45,12 @@ class PepperPortAllocatorSession virtual void SendSessionRequest(const std::string& host, int port) OVERRIDE; private: - void ResolveStunServerAddress(); - void OnStunAddressResolved(int32_t result); - void OnUrlOpened(int32_t result); void ReadResponseBody(); void OnResponseBodyRead(int32_t result); pp::InstanceHandle instance_; - pp::HostResolver stun_address_resolver_; rtc::SocketAddress stun_address_; int stun_port_; @@ -89,7 +83,6 @@ PepperPortAllocatorSession::PepperPortAllocatorSession( relay_token, std::string()), instance_(instance), - stun_address_resolver_(instance_), stun_port_(0), relay_response_received_(false), callback_factory_(this) { @@ -103,16 +96,6 @@ PepperPortAllocatorSession::~PepperPortAllocatorSession() { void PepperPortAllocatorSession::ConfigReady( cricket::PortConfiguration* config) { - if (config->stun_address.IsUnresolved()) { - // Make sure that the address that we pass to ConfigReady() is - // always resolved. - if (stun_address_.IsUnresolved()) { - config->stun_address.Clear(); - } else { - config->stun_address = stun_address_; - } - } - // Filter out non-UDP relay ports, so that we don't try using TCP. for (cricket::PortConfiguration::RelayList::iterator relay = config->relays.begin(); relay != config->relays.end(); ++relay) { @@ -129,80 +112,14 @@ void PepperPortAllocatorSession::ConfigReady( } void PepperPortAllocatorSession::GetPortConfigurations() { - // Add an empty configuration synchronously, so a local connection - // can be started immediately. + // Add a configuration without relay response first so local and STUN + // candidates can be allocated without waiting for the relay response. ConfigReady(new cricket::PortConfiguration( - rtc::SocketAddress(), std::string(), std::string())); + stun_address_, std::string(), std::string())); - ResolveStunServerAddress(); TryCreateRelaySession(); } -void PepperPortAllocatorSession::ResolveStunServerAddress() { - if (stun_address_.IsNil()) { - return; - } - - if (!stun_address_.IsUnresolved()) { - return; - } - - std::string hostname = stun_address_.hostname(); - uint16 port = stun_address_.port(); - - PP_HostResolver_Hint hint; - hint.flags = 0; - hint.family = PP_NETADDRESS_FAMILY_IPV4; - pp::CompletionCallback callback = callback_factory_.NewCallback( - &PepperPortAllocatorSession::OnStunAddressResolved); - int result = stun_address_resolver_.Resolve(hostname.c_str(), - port, - hint, - callback); - DCHECK_EQ(result, PP_OK_COMPLETIONPENDING); -} - -void PepperPortAllocatorSession::OnStunAddressResolved(int32_t result) { - if (result < 0) { - LOG(ERROR) << "Failed to resolve stun address " - << stun_address_.hostname() << ": " << result; - return; - } - - if (!stun_address_resolver_.GetNetAddressCount()) { - LOG(WARNING) << "Received 0 addresses for stun server " - << stun_address_.hostname(); - return; - } - - pp::NetAddress address = stun_address_resolver_.GetNetAddress(0); - if (address.is_null()) { - LOG(ERROR) << "Failed to get address for STUN server " - << stun_address_.hostname(); - return; - } - - PpNetAddressToSocketAddress(address, &stun_address_); - DCHECK(!stun_address_.IsUnresolved()); - - if (relay_response_received_) { - // If we've finished reading the response, then resubmit it to - // HttpPortAllocatorSessionBase. This is necessary because STUN - // and Relay parameters are stored together in PortConfiguration - // and ReceiveSessionResponse() doesn't save relay session - // configuration for the case we resolve STUN address later. This - // method invokes overriden ConfigReady() which then submits - // resolved |stun_address_|. - // - // TODO(sergeyu): Refactor HttpPortAllocatorSessionBase to fix this. - ReceiveSessionResponse(std::string(relay_response_body_.begin(), - relay_response_body_.end())); - } else { - ConfigReady(new cricket::PortConfiguration( - stun_address_, std::string(), std::string())); - } -} - void PepperPortAllocatorSession::SendSessionRequest( const std::string& host, int port) { diff --git a/remoting/remoting_srcs.gypi b/remoting/remoting_srcs.gypi index 5790eca..9ff6551 100644 --- a/remoting/remoting_srcs.gypi +++ b/remoting/remoting_srcs.gypi @@ -238,6 +238,8 @@ 'client/plugin/normalizing_input_filter_cros.h', 'client/plugin/normalizing_input_filter_mac.cc', 'client/plugin/normalizing_input_filter_mac.h', + 'client/plugin/pepper_address_resolver.cc', + 'client/plugin/pepper_address_resolver.h', 'client/plugin/pepper_audio_player.cc', 'client/plugin/pepper_audio_player.h', 'client/plugin/pepper_input_handler.cc', -- cgit v1.1