pending_accept_(false) {
DCHECK(host);
++g_num_instances;
- if (!host->GetRenderFrameIDsForInstance(instance,
- &render_process_id_,
- &render_frame_id_)) {
+ if (!host->GetRenderFrameIDsForInstance(
+ instance, &render_process_id_, &render_frame_id_)) {
NOTREACHED();
}
}
DCHECK_NE(version, ppapi::TCP_SOCKET_VERSION_1_0);
++g_num_instances;
- if (!host->GetRenderFrameIDsForInstance(instance,
- &render_process_id_,
- &render_frame_id_)) {
+ if (!host->GetRenderFrameIDsForInstance(
+ instance, &render_process_id_, &render_frame_id_)) {
NOTREACHED();
}
}
const IPC::Message& msg,
ppapi::host::HostMessageContext* context) {
IPC_BEGIN_MESSAGE_MAP(PepperTCPSocketMessageFilter, msg)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_Bind, OnMsgBind)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_Connect, OnMsgConnect)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_ConnectWithNetAddress,
- OnMsgConnectWithNetAddress)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_SSLHandshake, OnMsgSSLHandshake)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_Read, OnMsgRead)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_Write, OnMsgWrite)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_Listen, OnMsgListen)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
- PpapiHostMsg_TCPSocket_Accept, OnMsgAccept)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
- PpapiHostMsg_TCPSocket_Close, OnMsgClose)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_TCPSocket_SetOption, OnMsgSetOption)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_Bind, OnMsgBind)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_Connect,
+ OnMsgConnect)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+ PpapiHostMsg_TCPSocket_ConnectWithNetAddress, OnMsgConnectWithNetAddress)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_SSLHandshake,
+ OnMsgSSLHandshake)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_Read, OnMsgRead)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_Write, OnMsgWrite)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_Listen, OnMsgListen)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_TCPSocket_Accept,
+ OnMsgAccept)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_TCPSocket_Close, OnMsgClose)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_TCPSocket_SetOption,
+ OnMsgSetOption)
IPC_END_MESSAGE_MAP()
return PP_ERROR_FAILED;
}
int32_t PepperTCPSocketMessageFilter::OnMsgBind(
const ppapi::host::HostMessageContext* context,
const PP_NetAddress_Private& net_addr) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
// This is only supported by PPB_TCPSocket v1.1 or above.
if (version_ != ppapi::TCP_SOCKET_VERSION_1_1_OR_ABOVE) {
return PP_ERROR_NOACCESS;
}
- if (!pepper_socket_utils::CanUseSocketAPIs(
- external_plugin_, false /* private_api */, NULL, render_process_id_,
- render_frame_id_)) {
+ if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_,
+ false /* private_api */,
+ NULL,
+ render_process_id_,
+ render_frame_id_)) {
return PP_ERROR_NOACCESS;
}
bind_input_addr_ = net_addr;
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- base::Bind(&PepperTCPSocketMessageFilter::DoBind, this,
- context->MakeReplyMessageContext(), net_addr));
+ BrowserThread::PostTask(BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(&PepperTCPSocketMessageFilter::DoBind,
+ this,
+ context->MakeReplyMessageContext(),
+ net_addr));
return PP_OK_COMPLETIONPENDING;
}
const ppapi::host::HostMessageContext* context,
const std::string& host,
uint16_t port) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
// This is only supported by PPB_TCPSocket_Private.
if (!IsPrivateAPI()) {
return PP_ERROR_NOACCESS;
}
- SocketPermissionRequest request(SocketPermissionRequest::TCP_CONNECT,
- host,
- port);
- if (!pepper_socket_utils::CanUseSocketAPIs(
- external_plugin_, true /* private_api */, &request,
- render_process_id_, render_frame_id_)) {
+ SocketPermissionRequest request(
+ SocketPermissionRequest::TCP_CONNECT, host, port);
+ if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_,
+ true /* private_api */,
+ &request,
+ render_process_id_,
+ render_frame_id_)) {
return PP_ERROR_NOACCESS;
}
if (!browser_context || !browser_context->GetResourceContext())
return PP_ERROR_FAILED;
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- base::Bind(&PepperTCPSocketMessageFilter::DoConnect, this,
- context->MakeReplyMessageContext(),
- host, port, browser_context->GetResourceContext()));
+ BrowserThread::PostTask(BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(&PepperTCPSocketMessageFilter::DoConnect,
+ this,
+ context->MakeReplyMessageContext(),
+ host,
+ port,
+ browser_context->GetResourceContext()));
return PP_OK_COMPLETIONPENDING;
}
int32_t PepperTCPSocketMessageFilter::OnMsgConnectWithNetAddress(
const ppapi::host::HostMessageContext* context,
const PP_NetAddress_Private& net_addr) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::SocketPermissionRequest request =
pepper_socket_utils::CreateSocketPermissionRequest(
content::SocketPermissionRequest::TCP_CONNECT, net_addr);
- if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_, IsPrivateAPI(),
- &request, render_process_id_,
+ if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_,
+ IsPrivateAPI(),
+ &request,
+ render_process_id_,
render_frame_id_)) {
return PP_ERROR_NOACCESS;
}
BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- base::Bind(&PepperTCPSocketMessageFilter::DoConnectWithNetAddress, this,
- context->MakeReplyMessageContext(), net_addr));
+ BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(&PepperTCPSocketMessageFilter::DoConnectWithNetAddress,
+ this,
+ context->MakeReplyMessageContext(),
+ net_addr));
return PP_OK_COMPLETIONPENDING;
}
uint16_t server_port,
const std::vector<std::vector<char> >& trusted_certs,
const std::vector<std::vector<char> >& untrusted_certs) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
// Allow to do SSL handshake only if currently the socket has been connected
// and there isn't pending read or write.
ssl_context.cert_verifier = ssl_context_helper_->GetCertVerifier();
ssl_context.transport_security_state =
ssl_context_helper_->GetTransportSecurityState();
- ssl_socket_ = factory->CreateSSLClientSocket(
- handle.Pass(), host_port_pair, ssl_context_helper_->ssl_config(),
- ssl_context);
+ ssl_socket_ =
+ factory->CreateSSLClientSocket(handle.Pass(),
+ host_port_pair,
+ ssl_context_helper_->ssl_config(),
+ ssl_context);
if (!ssl_socket_) {
LOG(WARNING) << "Failed to create an SSL client socket.";
state_.CompletePendingTransition(false);
context->MakeReplyMessageContext());
int net_result = ssl_socket_->Connect(
base::Bind(&PepperTCPSocketMessageFilter::OnSSLHandshakeCompleted,
- base::Unretained(this), reply_context));
+ base::Unretained(this),
+ reply_context));
if (net_result != net::ERR_IO_PENDING)
OnSSLHandshakeCompleted(reply_context, net_result);
return PP_OK_COMPLETIONPENDING;
int32_t PepperTCPSocketMessageFilter::OnMsgRead(
const ppapi::host::HostMessageContext* context,
int32_t bytes_to_read) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsConnected() || end_of_file_reached_)
return PP_ERROR_FAILED;
if (read_buffer_.get())
int net_result = net::ERR_FAILED;
if (socket_) {
DCHECK_EQ(state_.state(), TCPSocketState::CONNECTED);
- net_result = socket_->Read(
- read_buffer_.get(),
- bytes_to_read,
- base::Bind(&PepperTCPSocketMessageFilter::OnReadCompleted,
- base::Unretained(this), reply_context));
+ net_result =
+ socket_->Read(read_buffer_.get(),
+ bytes_to_read,
+ base::Bind(&PepperTCPSocketMessageFilter::OnReadCompleted,
+ base::Unretained(this),
+ reply_context));
} else if (ssl_socket_) {
DCHECK_EQ(state_.state(), TCPSocketState::SSL_CONNECTED);
net_result = ssl_socket_->Read(
read_buffer_.get(),
bytes_to_read,
base::Bind(&PepperTCPSocketMessageFilter::OnReadCompleted,
- base::Unretained(this), reply_context));
+ base::Unretained(this),
+ reply_context));
}
if (net_result != net::ERR_IO_PENDING)
OnReadCompleted(reply_context, net_result);
int32_t PepperTCPSocketMessageFilter::OnMsgWrite(
const ppapi::host::HostMessageContext* context,
const std::string& data) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsConnected())
return PP_ERROR_FAILED;
int32_t PepperTCPSocketMessageFilter::OnMsgListen(
const ppapi::host::HostMessageContext* context,
int32_t backlog) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
// This is only supported by PPB_TCPSocket v1.1 or above.
if (version_ != ppapi::TCP_SOCKET_VERSION_1_1_OR_ABOVE) {
content::SocketPermissionRequest request =
pepper_socket_utils::CreateSocketPermissionRequest(
content::SocketPermissionRequest::TCP_LISTEN, bind_input_addr_);
- if (!pepper_socket_utils::CanUseSocketAPIs(
- external_plugin_, false /* private_api */, &request,
- render_process_id_, render_frame_id_)) {
+ if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_,
+ false /* private_api */,
+ &request,
+ render_process_id_,
+ render_frame_id_)) {
return PP_ERROR_NOACCESS;
}
- BrowserThread::PostTask(
- BrowserThread::IO, FROM_HERE,
- base::Bind(&PepperTCPSocketMessageFilter::DoListen, this,
- context->MakeReplyMessageContext(), backlog));
+ BrowserThread::PostTask(BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(&PepperTCPSocketMessageFilter::DoListen,
+ this,
+ context->MakeReplyMessageContext(),
+ backlog));
return PP_OK_COMPLETIONPENDING;
}
int32_t PepperTCPSocketMessageFilter::OnMsgAccept(
const ppapi::host::HostMessageContext* context) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (pending_accept_)
return PP_ERROR_INPROGRESS;
&accepted_socket_,
&accepted_address_,
base::Bind(&PepperTCPSocketMessageFilter::OnAcceptCompleted,
- base::Unretained(this), reply_context));
+ base::Unretained(this),
+ reply_context));
if (net_result != net::ERR_IO_PENDING)
OnAcceptCompleted(reply_context, net_result);
return PP_OK_COMPLETIONPENDING;
int32_t PepperTCPSocketMessageFilter::OnMsgClose(
const ppapi::host::HostMessageContext* context) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (state_.state() == TCPSocketState::CLOSED)
return PP_OK;
const ppapi::host::HostMessageContext* context,
PP_TCPSocket_Option name,
const ppapi::SocketOptionData& value) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
switch (name) {
case PP_TCPSOCKET_OPTION_NO_DELAY: {
if (!value.GetInt32(&integer_value) || integer_value <= 0)
return PP_ERROR_BADARGUMENT;
- bool result = false;
+ int net_result = net::ERR_UNEXPECTED;
if (name == PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE) {
if (integer_value > TCPSocketResourceBase::kMaxSendBufferSize)
return PP_ERROR_BADARGUMENT;
- result = socket_->SetSendBufferSize(integer_value);
+ net_result = socket_->SetSendBufferSize(integer_value);
} else {
if (integer_value > TCPSocketResourceBase::kMaxReceiveBufferSize)
return PP_ERROR_BADARGUMENT;
- result = socket_->SetReceiveBufferSize(integer_value);
+ net_result = socket_->SetReceiveBufferSize(integer_value);
}
- return result ? PP_OK : PP_ERROR_FAILED;
+ // TODO(wtc): Add error mapping code.
+ return (net_result == net::OK) ? PP_OK : PP_ERROR_FAILED;
}
default: {
NOTREACHED();
void PepperTCPSocketMessageFilter::DoBind(
const ppapi::host::ReplyMessageContext& context,
const PP_NetAddress_Private& net_addr) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (state_.IsPending(TCPSocketState::BIND)) {
SendBindError(context, PP_ERROR_INPROGRESS);
do {
net::IPAddressNumber address;
int port;
- if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(net_addr, &address,
- &port)) {
+ if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(
+ net_addr, &address, &port)) {
pp_result = PP_ERROR_ADDRESS_INVALID;
break;
}
break;
net::IPEndPoint ip_end_point_local;
- pp_result = NetErrorToPepperError(
- socket_->GetLocalAddress(&ip_end_point_local));
+ pp_result =
+ NetErrorToPepperError(socket_->GetLocalAddress(&ip_end_point_local));
if (pp_result != PP_OK)
break;
const std::string& host,
uint16_t port,
ResourceContext* resource_context) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsValidTransition(TCPSocketState::CONNECT)) {
SendConnectError(context, PP_ERROR_FAILED);
address_index_ = 0;
address_list_.clear();
net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
- resolver_.reset(new net::SingleRequestHostResolver(
- resource_context->GetHostResolver()));
+ resolver_.reset(
+ new net::SingleRequestHostResolver(resource_context->GetHostResolver()));
int net_result = resolver_->Resolve(
request_info,
net::DEFAULT_PRIORITY,
&address_list_,
base::Bind(&PepperTCPSocketMessageFilter::OnResolveCompleted,
- base::Unretained(this), context),
+ base::Unretained(this),
+ context),
net::BoundNetLog());
if (net_result != net::ERR_IO_PENDING)
OnResolveCompleted(context, net_result);
void PepperTCPSocketMessageFilter::DoConnectWithNetAddress(
const ppapi::host::ReplyMessageContext& context,
const PP_NetAddress_Private& net_addr) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsValidTransition(TCPSocketState::CONNECT)) {
SendConnectError(context, PP_ERROR_FAILED);
net::IPAddressNumber address;
int port;
- if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(net_addr, &address,
- &port)) {
+ if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(
+ net_addr, &address, &port)) {
state_.CompletePendingTransition(false);
SendConnectError(context, PP_ERROR_ADDRESS_INVALID);
return;
void PepperTCPSocketMessageFilter::DoWrite(
const ppapi::host::ReplyMessageContext& context) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(write_buffer_base_.get());
DCHECK(write_buffer_.get());
DCHECK_GT(write_buffer_->BytesRemaining(), 0);
write_buffer_.get(),
write_buffer_->BytesRemaining(),
base::Bind(&PepperTCPSocketMessageFilter::OnWriteCompleted,
- base::Unretained(this), context));
+ base::Unretained(this),
+ context));
} else if (ssl_socket_) {
DCHECK_EQ(state_.state(), TCPSocketState::SSL_CONNECTED);
net_result = ssl_socket_->Write(
write_buffer_.get(),
write_buffer_->BytesRemaining(),
base::Bind(&PepperTCPSocketMessageFilter::OnWriteCompleted,
- base::Unretained(this), context));
+ base::Unretained(this),
+ context));
}
if (net_result != net::ERR_IO_PENDING)
OnWriteCompleted(context, net_result);
void PepperTCPSocketMessageFilter::DoListen(
const ppapi::host::ReplyMessageContext& context,
int32_t backlog) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (state_.IsPending(TCPSocketState::LISTEN)) {
SendListenReply(context, PP_ERROR_INPROGRESS);
void PepperTCPSocketMessageFilter::OnResolveCompleted(
const ppapi::host::ReplyMessageContext& context,
int net_result) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsPending(TCPSocketState::CONNECT)) {
DCHECK(state_.state() == TCPSocketState::CLOSED);
void PepperTCPSocketMessageFilter::StartConnect(
const ppapi::host::ReplyMessageContext& context) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(state_.IsPending(TCPSocketState::CONNECT));
DCHECK_LT(address_index_, address_list_.size());
net_result = socket_->Connect(
address_list_[address_index_],
base::Bind(&PepperTCPSocketMessageFilter::OnConnectCompleted,
- base::Unretained(this), context));
+ base::Unretained(this),
+ context));
}
if (net_result != net::ERR_IO_PENDING)
OnConnectCompleted(context, net_result);
void PepperTCPSocketMessageFilter::OnConnectCompleted(
const ppapi::host::ReplyMessageContext& context,
int net_result) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsPending(TCPSocketState::CONNECT)) {
DCHECK(state_.state() == TCPSocketState::CLOSED);
net::IPEndPoint ip_end_point_local;
net::IPEndPoint ip_end_point_remote;
- pp_result = NetErrorToPepperError(
- socket_->GetLocalAddress(&ip_end_point_local));
+ pp_result =
+ NetErrorToPepperError(socket_->GetLocalAddress(&ip_end_point_local));
if (pp_result != PP_OK)
break;
- pp_result = NetErrorToPepperError(
- socket_->GetPeerAddress(&ip_end_point_remote));
+ pp_result =
+ NetErrorToPepperError(socket_->GetPeerAddress(&ip_end_point_remote));
if (pp_result != PP_OK)
break;
void PepperTCPSocketMessageFilter::OnSSLHandshakeCompleted(
const ppapi::host::ReplyMessageContext& context,
int net_result) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!state_.IsPending(TCPSocketState::SSL_CONNECT)) {
DCHECK(state_.state() == TCPSocketState::CLOSED);
void PepperTCPSocketMessageFilter::OnReadCompleted(
const ppapi::host::ReplyMessageContext& context,
int net_result) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(read_buffer_.get());
if (net_result > 0) {
- SendReadReply(context,
- PP_OK,
- std::string(read_buffer_->data(), net_result));
+ SendReadReply(
+ context, PP_OK, std::string(read_buffer_->data(), net_result));
} else if (net_result == 0) {
end_of_file_reached_ = true;
SendReadReply(context, PP_OK, std::string());
void PepperTCPSocketMessageFilter::OnWriteCompleted(
const ppapi::host::ReplyMessageContext& context,
int net_result) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(write_buffer_base_.get());
DCHECK(write_buffer_.get());
void PepperTCPSocketMessageFilter::OnAcceptCompleted(
const ppapi::host::ReplyMessageContext& context,
int net_result) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(pending_accept_);
pending_accept_ = false;
PP_NetAddress_Private local_addr = NetAddressPrivateImpl::kInvalidNetAddress;
PP_NetAddress_Private remote_addr = NetAddressPrivateImpl::kInvalidNetAddress;
- int32_t pp_result =
- NetErrorToPepperError(accepted_socket_->GetLocalAddress(
- &ip_end_point_local));
+ int32_t pp_result = NetErrorToPepperError(
+ accepted_socket_->GetLocalAddress(&ip_end_point_local));
if (pp_result != PP_OK) {
SendAcceptError(context, pp_result);
return;
void PepperTCPSocketMessageFilter::SendAcceptError(
const ppapi::host::ReplyMessageContext& context,
int32_t pp_error) {
- SendAcceptReply(context, pp_error, 0,
+ SendAcceptReply(context,
+ pp_error,
+ 0,
NetAddressPrivateImpl::kInvalidNetAddress,
NetAddressPrivateImpl::kInvalidNetAddress);
}
projects / platform / framework / web / crosswalk.git / blobdiff