OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/renderer_host/pepper/pepper_message_filter.h" | 5 #include "content/browser/renderer_host/pepper/pepper_message_filter.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
(...skipping 26 matching lines...) Expand all Loading... | |
37 #include "net/base/cert_verifier.h" | 37 #include "net/base/cert_verifier.h" |
38 #include "net/base/host_port_pair.h" | 38 #include "net/base/host_port_pair.h" |
39 #include "net/base/sys_addrinfo.h" | 39 #include "net/base/sys_addrinfo.h" |
40 #include "ppapi/c/pp_errors.h" | 40 #include "ppapi/c/pp_errors.h" |
41 #include "ppapi/c/private/ppb_host_resolver_private.h" | 41 #include "ppapi/c/private/ppb_host_resolver_private.h" |
42 #include "ppapi/c/private/ppb_net_address_private.h" | 42 #include "ppapi/c/private/ppb_net_address_private.h" |
43 #include "ppapi/proxy/ppapi_messages.h" | 43 #include "ppapi/proxy/ppapi_messages.h" |
44 #include "ppapi/shared_impl/api_id.h" | 44 #include "ppapi/shared_impl/api_id.h" |
45 #include "ppapi/shared_impl/private/net_address_private_impl.h" | 45 #include "ppapi/shared_impl/private/net_address_private_impl.h" |
46 #include "ppapi/shared_impl/private/ppb_host_resolver_shared.h" | 46 #include "ppapi/shared_impl/private/ppb_host_resolver_shared.h" |
47 #include "ppapi/cpp/private/net_address_private.h" | |
ygorshenin1
2012/09/28 14:43:34
nit: sort, please.
Dmitry Polukhin
2012/10/01 11:00:24
Done.
| |
47 | 48 |
48 #ifdef OS_WIN | 49 #ifdef OS_WIN |
49 #include <windows.h> | 50 #include <windows.h> |
50 #elif defined(OS_MACOSX) | 51 #elif defined(OS_MACOSX) |
51 #include <CoreServices/CoreServices.h> | 52 #include <CoreServices/CoreServices.h> |
52 #endif | 53 #endif |
53 | 54 |
54 using content::BrowserThread; | 55 using content::BrowserThread; |
55 using content::RenderViewHostImpl; | 56 using content::RenderViewHostImpl; |
56 using ppapi::NetAddressPrivateImpl; | 57 using ppapi::NetAddressPrivateImpl; |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
114 DCHECK(type == PLUGIN); | 115 DCHECK(type == PLUGIN); |
115 DCHECK(host_resolver); | 116 DCHECK(host_resolver); |
116 } | 117 } |
117 | 118 |
118 void PepperMessageFilter::OverrideThreadForMessage( | 119 void PepperMessageFilter::OverrideThreadForMessage( |
119 const IPC::Message& message, | 120 const IPC::Message& message, |
120 BrowserThread::ID* thread) { | 121 BrowserThread::ID* thread) { |
121 if (message.type() == PpapiHostMsg_PPBTCPSocket_Connect::ID || | 122 if (message.type() == PpapiHostMsg_PPBTCPSocket_Connect::ID || |
122 message.type() == PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress::ID || | 123 message.type() == PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress::ID || |
123 message.type() == PpapiHostMsg_PPBUDPSocket_Bind::ID || | 124 message.type() == PpapiHostMsg_PPBUDPSocket_Bind::ID || |
124 message.type() == PpapiHostMsg_PPBTCPServerSocket_Listen::ID || | 125 message.type() == PpapiHostMsg_PPBUDPSocket_SendTo::ID || |
125 message.type() == PpapiHostMsg_PPBHostResolver_Resolve::ID) { | 126 message.type() == PpapiHostMsg_PPBTCPServerSocket_Listen::ID) { |
ygorshenin1
2012/09/28 14:43:34
nit: message ID's could be sorted here, for better
Dmitry Polukhin
2012/10/01 11:00:24
Done.
| |
126 *thread = BrowserThread::UI; | 127 *thread = BrowserThread::UI; |
127 } else if (message.type() == PepperMsg_GetDeviceID::ID) { | 128 } else if (message.type() == PepperMsg_GetDeviceID::ID) { |
128 *thread = BrowserThread::FILE; | 129 *thread = BrowserThread::FILE; |
129 } | 130 } |
130 } | 131 } |
131 | 132 |
132 bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg, | 133 bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg, |
133 bool* message_was_ok) { | 134 bool* message_was_ok) { |
134 bool handled = true; | 135 bool handled = true; |
135 IPC_BEGIN_MESSAGE_MAP_EX(PepperMessageFilter, msg, *message_was_ok) | 136 IPC_BEGIN_MESSAGE_MAP_EX(PepperMessageFilter, msg, *message_was_ok) |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
279 | 280 |
280 tcp_sockets_[*socket_id] = linked_ptr<PepperTCPSocket>( | 281 tcp_sockets_[*socket_id] = linked_ptr<PepperTCPSocket>( |
281 new PepperTCPSocket(this, routing_id, plugin_dispatcher_id, *socket_id)); | 282 new PepperTCPSocket(this, routing_id, plugin_dispatcher_id, *socket_id)); |
282 } | 283 } |
283 | 284 |
284 void PepperMessageFilter::OnTCPConnect(int32 routing_id, | 285 void PepperMessageFilter::OnTCPConnect(int32 routing_id, |
285 uint32 socket_id, | 286 uint32 socket_id, |
286 const std::string& host, | 287 const std::string& host, |
287 uint16_t port) { | 288 uint16_t port) { |
288 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 289 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
290 content::ContentBrowserClient::SocketPermissionParam params( | |
291 content::ContentBrowserClient::SocketPermissionParam::TCP_CONNECT, | |
292 host, port); | |
293 bool allowed = CanUseSocketAPIs(routing_id, params); | |
289 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | 294 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
290 base::Bind(&PepperMessageFilter::DoTCPConnect, this, | 295 base::Bind(&PepperMessageFilter::DoTCPConnect, this, |
291 CanUseSocketAPIs(routing_id), routing_id, socket_id, host, port)); | 296 allowed, routing_id, socket_id, host, port)); |
292 } | 297 } |
293 | 298 |
294 void PepperMessageFilter::DoTCPConnect(bool allowed, | 299 void PepperMessageFilter::DoTCPConnect(bool allowed, |
295 int32 routing_id, | 300 int32 routing_id, |
296 uint32 socket_id, | 301 uint32 socket_id, |
297 const std::string& host, | 302 const std::string& host, |
298 uint16_t port) { | 303 uint16_t port) { |
299 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 304 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
300 TCPSocketMap::iterator iter = tcp_sockets_.find(socket_id); | 305 TCPSocketMap::iterator iter = tcp_sockets_.find(socket_id); |
301 if (iter == tcp_sockets_.end()) { | 306 if (iter == tcp_sockets_.end()) { |
302 NOTREACHED(); | 307 NOTREACHED(); |
303 return; | 308 return; |
304 } | 309 } |
305 | 310 |
306 if (routing_id == iter->second->routing_id() && allowed) | 311 if (routing_id == iter->second->routing_id() && allowed) |
307 iter->second->Connect(host, port); | 312 iter->second->Connect(host, port); |
308 else | 313 else |
309 iter->second->SendConnectACKError(); | 314 iter->second->SendConnectACKError(); |
310 } | 315 } |
311 | 316 |
312 void PepperMessageFilter::OnTCPConnectWithNetAddress( | 317 void PepperMessageFilter::OnTCPConnectWithNetAddress( |
313 int32 routing_id, | 318 int32 routing_id, |
314 uint32 socket_id, | 319 uint32 socket_id, |
315 const PP_NetAddress_Private& net_addr) { | 320 const PP_NetAddress_Private& net_addr) { |
316 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 321 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
322 bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionParam( | |
323 content::ContentBrowserClient::SocketPermissionParam::TCP_CONNECT, | |
324 net_addr)); | |
317 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | 325 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
318 base::Bind(&PepperMessageFilter::DoTCPConnectWithNetAddress, this, | 326 base::Bind(&PepperMessageFilter::DoTCPConnectWithNetAddress, this, |
319 CanUseSocketAPIs(routing_id), routing_id, socket_id, net_addr)); | 327 allowed, routing_id, socket_id, net_addr)); |
320 } | 328 } |
321 | 329 |
322 void PepperMessageFilter::DoTCPConnectWithNetAddress( | 330 void PepperMessageFilter::DoTCPConnectWithNetAddress( |
323 bool allowed, | 331 bool allowed, |
324 int32 routing_id, | 332 int32 routing_id, |
325 uint32 socket_id, | 333 uint32 socket_id, |
326 const PP_NetAddress_Private& net_addr) { | 334 const PP_NetAddress_Private& net_addr) { |
327 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 335 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
328 TCPSocketMap::iterator iter = tcp_sockets_.find(socket_id); | 336 TCPSocketMap::iterator iter = tcp_sockets_.find(socket_id); |
329 if (iter == tcp_sockets_.end()) { | 337 if (iter == tcp_sockets_.end()) { |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
425 default: | 433 default: |
426 NOTREACHED(); | 434 NOTREACHED(); |
427 break; | 435 break; |
428 } | 436 } |
429 } | 437 } |
430 | 438 |
431 void PepperMessageFilter::OnUDPBind(int32 routing_id, | 439 void PepperMessageFilter::OnUDPBind(int32 routing_id, |
432 uint32 socket_id, | 440 uint32 socket_id, |
433 const PP_NetAddress_Private& addr) { | 441 const PP_NetAddress_Private& addr) { |
434 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 442 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
443 bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionParam( | |
444 content::ContentBrowserClient::SocketPermissionParam::UDP_BIND, | |
445 addr)); | |
435 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | 446 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
436 base::Bind(&PepperMessageFilter::DoUDPBind, this, | 447 base::Bind(&PepperMessageFilter::DoUDPBind, this, |
437 CanUseSocketAPIs(routing_id), routing_id, socket_id, addr)); | 448 allowed, routing_id, socket_id, addr)); |
438 } | 449 } |
439 | 450 |
440 void PepperMessageFilter::DoUDPBind(bool allowed, | 451 void PepperMessageFilter::DoUDPBind(bool allowed, |
441 int32 routing_id, | 452 int32 routing_id, |
442 uint32 socket_id, | 453 uint32 socket_id, |
443 const PP_NetAddress_Private& addr) { | 454 const PP_NetAddress_Private& addr) { |
444 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 455 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
445 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); | 456 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); |
446 if (iter == udp_sockets_.end()) { | 457 if (iter == udp_sockets_.end()) { |
447 NOTREACHED(); | 458 NOTREACHED(); |
448 return; | 459 return; |
449 } | 460 } |
450 | 461 |
451 if (routing_id == iter->second->routing_id() && allowed) | 462 if (routing_id == iter->second->routing_id() && allowed) |
452 iter->second->Bind(addr); | 463 iter->second->Bind(addr); |
453 else | 464 else |
454 iter->second->SendBindACKError(); | 465 iter->second->SendBindACKError(); |
455 } | 466 } |
456 | 467 |
457 void PepperMessageFilter::OnUDPRecvFrom(uint32 socket_id, int32_t num_bytes) { | 468 void PepperMessageFilter::OnUDPRecvFrom(uint32 socket_id, int32_t num_bytes) { |
458 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); | 469 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); |
459 if (iter == udp_sockets_.end()) { | 470 if (iter == udp_sockets_.end()) { |
460 NOTREACHED(); | 471 NOTREACHED(); |
461 return; | 472 return; |
462 } | 473 } |
463 | 474 |
464 iter->second->RecvFrom(num_bytes); | 475 iter->second->RecvFrom(num_bytes); |
465 } | 476 } |
466 | 477 |
467 void PepperMessageFilter::OnUDPSendTo(uint32 socket_id, | 478 void PepperMessageFilter::OnUDPSendTo(int32 routing_id, |
479 uint32 socket_id, | |
468 const std::string& data, | 480 const std::string& data, |
469 const PP_NetAddress_Private& addr) { | 481 const PP_NetAddress_Private& addr) { |
482 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
483 bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionParam( | |
484 content::ContentBrowserClient::SocketPermissionParam::UDP_SEND_TO, | |
485 addr)); | |
486 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
487 base::Bind(&PepperMessageFilter::DoUDPSendTo, this, | |
488 allowed, routing_id, socket_id, data, addr)); | |
489 | |
490 } | |
491 | |
492 void PepperMessageFilter::DoUDPSendTo(bool allowed, | |
493 int32 routing_id, | |
494 uint32 socket_id, | |
495 const std::string& data, | |
496 const PP_NetAddress_Private& addr) { | |
497 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
470 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); | 498 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); |
471 if (iter == udp_sockets_.end()) { | 499 if (iter == udp_sockets_.end()) { |
472 NOTREACHED(); | 500 NOTREACHED(); |
473 return; | 501 return; |
474 } | 502 } |
475 | 503 |
476 iter->second->SendTo(data, addr); | 504 if (routing_id == iter->second->routing_id() && allowed) |
ygorshenin1
2012/09/28 14:43:34
nit: delete single space before "allowed".
| |
505 iter->second->SendTo(data, addr); | |
506 else | |
507 iter->second->SendSendToACKError(); | |
477 } | 508 } |
478 | 509 |
479 void PepperMessageFilter::OnUDPClose(uint32 socket_id) { | 510 void PepperMessageFilter::OnUDPClose(uint32 socket_id) { |
480 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); | 511 UDPSocketMap::iterator iter = udp_sockets_.find(socket_id); |
481 if (iter == udp_sockets_.end()) { | 512 if (iter == udp_sockets_.end()) { |
482 NOTREACHED(); | 513 NOTREACHED(); |
483 return; | 514 return; |
484 } | 515 } |
485 | 516 |
486 // Destroy the UDPSocket instance will cancel any pending completion | 517 // Destroy the UDPSocket instance will cancel any pending completion |
487 // callback. From this point on, there won't be any messages associated with | 518 // callback. From this point on, there won't be any messages associated with |
488 // this socket sent to the plugin side. | 519 // this socket sent to the plugin side. |
489 udp_sockets_.erase(iter); | 520 udp_sockets_.erase(iter); |
490 } | 521 } |
491 | 522 |
492 void PepperMessageFilter::OnTCPServerListen(int32 routing_id, | 523 void PepperMessageFilter::OnTCPServerListen(int32 routing_id, |
493 uint32 plugin_dispatcher_id, | 524 uint32 plugin_dispatcher_id, |
494 PP_Resource socket_resource, | 525 PP_Resource socket_resource, |
495 const PP_NetAddress_Private& addr, | 526 const PP_NetAddress_Private& addr, |
496 int32_t backlog) { | 527 int32_t backlog) { |
497 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 528 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
529 bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionParam( | |
530 content::ContentBrowserClient::SocketPermissionParam::TCP_LISTEN, | |
531 addr)); | |
498 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | 532 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
499 base::Bind(&PepperMessageFilter::DoTCPServerListen, | 533 base::Bind(&PepperMessageFilter::DoTCPServerListen, |
500 this, | 534 this, |
501 CanUseSocketAPIs(routing_id), | 535 allowed, |
502 routing_id, | 536 routing_id, |
503 plugin_dispatcher_id, | 537 plugin_dispatcher_id, |
504 socket_resource, | 538 socket_resource, |
505 addr, | 539 addr, |
506 backlog)); | 540 backlog)); |
507 } | 541 } |
508 | 542 |
509 void PepperMessageFilter::DoTCPServerListen(bool allowed, | 543 void PepperMessageFilter::DoTCPServerListen(bool allowed, |
510 int32 routing_id, | 544 int32 routing_id, |
511 uint32 plugin_dispatcher_id, | 545 uint32 plugin_dispatcher_id, |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
546 } | 580 } |
547 iter->second->Accept(tcp_client_socket_routing_id); | 581 iter->second->Accept(tcp_client_socket_routing_id); |
548 } | 582 } |
549 | 583 |
550 void PepperMessageFilter::OnHostResolverResolve( | 584 void PepperMessageFilter::OnHostResolverResolve( |
551 int32 routing_id, | 585 int32 routing_id, |
552 uint32 plugin_dispatcher_id, | 586 uint32 plugin_dispatcher_id, |
553 uint32 host_resolver_id, | 587 uint32 host_resolver_id, |
554 const ppapi::HostPortPair& host_port, | 588 const ppapi::HostPortPair& host_port, |
555 const PP_HostResolver_Private_Hint& hint) { | 589 const PP_HostResolver_Private_Hint& hint) { |
556 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
557 BrowserThread::PostTask( | |
558 BrowserThread::IO, FROM_HERE, | |
559 base::Bind(&PepperMessageFilter::DoHostResolverResolve, this, | |
560 CanUseSocketAPIs(routing_id), | |
561 routing_id, | |
562 plugin_dispatcher_id, | |
563 host_resolver_id, | |
564 host_port, | |
565 hint)); | |
566 } | |
567 | |
568 void PepperMessageFilter::DoHostResolverResolve( | |
569 bool allowed, | |
570 int32 routing_id, | |
571 uint32 plugin_dispatcher_id, | |
572 uint32 host_resolver_id, | |
573 const ppapi::HostPortPair& host_port, | |
574 const PP_HostResolver_Private_Hint& hint) { | |
575 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 590 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
576 if (!allowed) { | |
577 SendHostResolverResolveACKError(routing_id, | |
578 plugin_dispatcher_id, | |
579 host_resolver_id); | |
580 return; | |
581 } | |
582 | |
583 net::HostResolver::RequestInfo request_info( | 591 net::HostResolver::RequestInfo request_info( |
584 net::HostPortPair(host_port.host, host_port.port)); | 592 net::HostPortPair(host_port.host, host_port.port)); |
585 | 593 |
586 net::AddressFamily address_family; | 594 net::AddressFamily address_family; |
587 switch (hint.family) { | 595 switch (hint.family) { |
588 case PP_NETADDRESSFAMILY_IPV4: | 596 case PP_NETADDRESSFAMILY_IPV4: |
589 address_family = net::ADDRESS_FAMILY_IPV4; | 597 address_family = net::ADDRESS_FAMILY_IPV4; |
590 break; | 598 break; |
591 case PP_NETADDRESSFAMILY_IPV6: | 599 case PP_NETADDRESSFAMILY_IPV6: |
592 address_family = net::ADDRESS_FAMILY_IPV6; | 600 address_family = net::ADDRESS_FAMILY_IPV6; |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
804 // the counter overflows. | 812 // the counter overflows. |
805 socket_id = next_socket_id_++; | 813 socket_id = next_socket_id_++; |
806 } while (socket_id == kInvalidSocketID || | 814 } while (socket_id == kInvalidSocketID || |
807 tcp_sockets_.find(socket_id) != tcp_sockets_.end() || | 815 tcp_sockets_.find(socket_id) != tcp_sockets_.end() || |
808 udp_sockets_.find(socket_id) != udp_sockets_.end() || | 816 udp_sockets_.find(socket_id) != udp_sockets_.end() || |
809 tcp_server_sockets_.find(socket_id) != tcp_server_sockets_.end()); | 817 tcp_server_sockets_.find(socket_id) != tcp_server_sockets_.end()); |
810 | 818 |
811 return socket_id; | 819 return socket_id; |
812 } | 820 } |
813 | 821 |
814 bool PepperMessageFilter::CanUseSocketAPIs(int32 render_id) { | 822 bool PepperMessageFilter::CanUseSocketAPIs(int32 render_id, |
823 const content::ContentBrowserClient::SocketPermissionParam& params) { | |
815 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 824 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
816 if (process_type_ == PLUGIN) { | 825 if (process_type_ == PLUGIN) { |
817 // Always allow socket APIs for out-process plugins. | 826 // Always allow socket APIs for out-process plugins. |
818 return true; | 827 return true; |
819 } | 828 } |
820 | 829 |
821 RenderViewHostImpl* render_view_host = | 830 RenderViewHostImpl* render_view_host = |
822 RenderViewHostImpl::FromID(process_id_, render_id); | 831 RenderViewHostImpl::FromID(process_id_, render_id); |
823 if (!render_view_host) | 832 if (!render_view_host) |
824 return false; | 833 return false; |
825 | 834 |
826 content::SiteInstance* site_instance = render_view_host->GetSiteInstance(); | 835 content::SiteInstance* site_instance = render_view_host->GetSiteInstance(); |
827 if (!site_instance) | 836 if (!site_instance) |
828 return false; | 837 return false; |
829 | 838 |
830 if (!content::GetContentClient()->browser()->AllowPepperSocketAPI( | 839 if (!content::GetContentClient()->browser()->AllowPepperSocketAPI( |
831 site_instance->GetBrowserContext(), | 840 site_instance->GetBrowserContext(), |
832 site_instance->GetSite())) { | 841 site_instance->GetSite(), |
842 params)) { | |
833 LOG(ERROR) << "Host " << site_instance->GetSite().host() | 843 LOG(ERROR) << "Host " << site_instance->GetSite().host() |
834 << " cannot use socket API"; | 844 << " cannot use socket API or destination is not allowed"; |
835 return false; | 845 return false; |
836 } | 846 } |
837 | 847 |
838 return true; | 848 return true; |
839 } | 849 } |
840 | 850 |
851 content::ContentBrowserClient::SocketPermissionParam | |
852 PepperMessageFilter::CreateSocketPermissionParam( | |
853 content::ContentBrowserClient::SocketPermissionParam::OperationType type, | |
854 const PP_NetAddress_Private& net_addr) { | |
855 std::string host = NetAddressPrivateImpl::DescribeNetAddress(net_addr, false); | |
856 int port = 0; | |
857 std::vector<unsigned char> address; | |
858 NetAddressPrivateImpl::NetAddressToIPEndPoint(net_addr, &address, &port); | |
859 return content::ContentBrowserClient::SocketPermissionParam(type, host, port); | |
860 } | |
861 | |
841 void PepperMessageFilter::GetAndSendNetworkList() { | 862 void PepperMessageFilter::GetAndSendNetworkList() { |
842 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 863 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
843 | 864 |
844 BrowserThread::PostBlockingPoolTask( | 865 BrowserThread::PostBlockingPoolTask( |
845 FROM_HERE, base::Bind(&PepperMessageFilter::DoGetNetworkList, this)); | 866 FROM_HERE, base::Bind(&PepperMessageFilter::DoGetNetworkList, this)); |
846 } | 867 } |
847 | 868 |
848 void PepperMessageFilter::DoGetNetworkList() { | 869 void PepperMessageFilter::DoGetNetworkList() { |
849 scoped_ptr<net::NetworkInterfaceList> list(new net::NetworkInterfaceList()); | 870 scoped_ptr<net::NetworkInterfaceList> list(new net::NetworkInterfaceList()); |
850 net::GetNetworkList(list.get()); | 871 net::GetNetworkList(list.get()); |
(...skipping 26 matching lines...) Expand all Loading... | |
877 network_copy.state = PP_NETWORKLIST_UP; | 898 network_copy.state = PP_NETWORKLIST_UP; |
878 network_copy.display_name = network.name; | 899 network_copy.display_name = network.name; |
879 network_copy.mtu = 0; | 900 network_copy.mtu = 0; |
880 } | 901 } |
881 for (NetworkMonitorIdSet::iterator it = network_monitor_ids_.begin(); | 902 for (NetworkMonitorIdSet::iterator it = network_monitor_ids_.begin(); |
882 it != network_monitor_ids_.end(); ++it) { | 903 it != network_monitor_ids_.end(); ++it) { |
883 Send(new PpapiMsg_PPBNetworkMonitor_NetworkList( | 904 Send(new PpapiMsg_PPBNetworkMonitor_NetworkList( |
884 ppapi::API_ID_PPB_NETWORKMANAGER_PRIVATE, *it, *list_copy)); | 905 ppapi::API_ID_PPB_NETWORKMANAGER_PRIVATE, *it, *list_copy)); |
885 } | 906 } |
886 } | 907 } |
OLD | NEW |