Out-of-process implementation of the PPB_NetworkMonitor_Private interface.

content/browser/renderer_host/pepper_message_filter.cc

Index: content/browser/renderer_host/pepper_message_filter.cc
diff --git a/content/browser/renderer_host/pepper_message_filter.cc b/content/browser/renderer_host/pepper_message_filter.cc
index f17f73c4dbcc022a0233c82d7437a49df0a1c280..90140cb6cb79dd649915aee117404e6c92e5a119 100644
--- a/content/browser/renderer_host/pepper_message_filter.cc
+++ b/content/browser/renderer_host/pepper_message_filter.cc
@@ -35,6 +35,7 @@
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/private/net_address_private_impl.h"
+#include "ppapi/shared_impl/api_id.h"

[dmichael (off chromium), 2012/03/15 20:01:28]

nit: include order

[Sergey Ulanov, 2012/03/15 22:18:00]

Done.

 #include "webkit/plugins/ppapi/ppb_flash_net_connector_impl.h"
 
 #if defined(ENABLE_FLAPPER_HACKS)
@@ -64,7 +65,8 @@ PepperMessageFilter::PepperMessageFilter(
       process_id_(process_id),
       resource_context_(resource_context),
       host_resolver_(NULL),
-      next_socket_id_(1) {
+      next_socket_id_(1),
+      monitoring_networks_(false) {
   DCHECK(type == RENDERER);
   DCHECK(resource_context_);
 }
@@ -75,12 +77,16 @@ PepperMessageFilter::PepperMessageFilter(ProcessType type,
       process_id_(0),
       resource_context_(NULL),
       host_resolver_(host_resolver),
-      next_socket_id_(1) {
+      next_socket_id_(1),
+      monitoring_networks_(false) {
   DCHECK(type == PLUGIN);
   DCHECK(host_resolver);
 }
 
-PepperMessageFilter::~PepperMessageFilter() {}
+PepperMessageFilter::~PepperMessageFilter() {
+  if (monitoring_networks_)
+    net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
+}
 
 void PepperMessageFilter::OverrideThreadForMessage(
     const IPC::Message& message,
@@ -131,11 +137,20 @@ bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTCPServerSocket_Destroy,
                         RemoveTCPServerSocket)
 
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBNetworkMonitor_Start,
+                        OnNetworkMonitorStart)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBNetworkMonitor_Stop,
+                        OnNetworkMonitorStop)
+
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
+void PepperMessageFilter::OnIPAddressChanged() {
+  GetAndSendNetworkList();
+}
+
 net::HostResolver* PepperMessageFilter::GetHostResolver() {
   return resource_context_ ?
       resource_context_->GetHostResolver() : host_resolver_;
@@ -647,6 +662,24 @@ void PepperMessageFilter::OnTCPServerAccept(uint32 real_socket_id) {
   iter->second->Accept();
 }
 
+void PepperMessageFilter::OnNetworkMonitorStart(uint32 plugin_dispatcher_id) {
+  if (!monitoring_networks_) {
+    net::NetworkChangeNotifier::AddIPAddressObserver(this);
+    monitoring_networks_ = true;
+  }
+
+  network_monitor_ids_.insert(plugin_dispatcher_id);
+  GetAndSendNetworkList();
+}
+
+void PepperMessageFilter::OnNetworkMonitorStop(uint32 plugin_dispatcher_id) {
+  network_monitor_ids_.erase(plugin_dispatcher_id);
+  if (network_monitor_ids_.empty()) {
+    net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
+    monitoring_networks_ = false;
+  }
+}
+
 void PepperMessageFilter::GetFontFamiliesComplete(
     IPC::Message* reply_msg,
     scoped_ptr<base::ListValue> result) {
@@ -727,3 +760,48 @@ bool PepperMessageFilter::CanUseSocketAPIs(int32 render_id) {
 
   return true;
 }
+
+void PepperMessageFilter::GetAndSendNetworkList() {
+  scoped_ptr<net::NetworkInterfaceList> list(new net::NetworkInterfaceList());
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,

[dmichael (off chromium), 2012/03/15 20:01:28]

I think we're moving away from using the FILE thread. See this chromium-dev
thread for info:
https://groups.google.com/a/chromium.org/group/chromium-dev/browse_thread/thr...

[Sergey Ulanov, 2012/03/15 22:18:00]

Done. Changed it to PostBlockingPoolTask()

+      base::Bind(&PepperMessageFilter::DoGetNetworkList, this, list.get()),
+      base::Bind(&PepperMessageFilter::SendNetworkList, this,
+                 base::Passed(list.Pass())));

[dmichael (off chromium), 2012/03/15 20:01:28]

Seeing you pass list.get() to the first callback after seeing |list| is scoped
confused me at first. It's a nice approach, but I hadn't seen it before. Is this
a common pattern I just haven't seen before?

If not, I think it warrants a comment that the scope of the list is actually
from creation until the completion of the SendNetworkList callback.

[Sergey Ulanov, 2012/03/15 22:18:00]

Sharing arguments between task and reply closure is recommended approach in
PostTaskAndReply(), see base/task_runner.h, but the example in that header uses
ref-counted objects. Not sure if there are any cases when the ownership is
passed using scoped_ptr<> but that may be because scoped_ptr<>.Pass() is
relatively new. There is some code that uses the same ownership semantics with
PostTaskAndReply() without using scoped_ptr<>, e.g. see GetSessionName() in 
chrome/browser/sync/util/get_session_name.cc.

In any case, there is PostBlockingPoolTask() in BrowserThread, but no
PostBlockingPoolTaskAndReply(), so I changed this code to post SendNetworkList()
from DoGetNetworkList().

[dmichael (off chromium), 2012/03/16 20:27:17]

You might be able to use base/task_runner.h (I'm not that familiar with this
stuff, though).

[Sergey Ulanov, 2012/03/16 23:37:28]

Done.

+}
+
+void PepperMessageFilter::DoGetNetworkList(net::NetworkInterfaceList* list) {
+  net::GetNetworkList(list);
+}
+
+void PepperMessageFilter::SendNetworkList(
+    scoped_ptr<net::NetworkInterfaceList> list) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  scoped_ptr< ::ppapi::NetworkList> list_copy(
+      new ::ppapi::NetworkList(list->size()));
+  for (size_t i = 0; i < list->size(); ++i) {
+    const net::NetworkInterface& network = list->at(i);
+    ::ppapi::NetworkInfo& network_copy = list_copy->at(i);
+    network_copy.name = network.name;
+
+    network_copy.addresses.resize(1);
+    CHECK_LE(network.address.size(), sizeof(network_copy.addresses[0].data));

[dmichael (off chromium), 2012/03/15 20:01:28]

can you use arraysize instead of sizeof? sizeof will silently tell you the size
of a pointer if |data| ever changes to a pointer instead of a statically-sized
array. (I agree we shouldn't make such a change to PP_NetAddress_Private, but a
little paranoia in Browser code is healthy)

[Sergey Ulanov, 2012/03/15 22:18:00]

Actually this code wasn't converting address correctly. I changed it to use
NetAddressPrivateImpl::IPEndPointToNetAddress().

+    network_copy.addresses[0].size = network.address.size();
+    memcpy(network_copy.addresses[0].data, &(network.address.front()),

[dmichael (off chromium), 2012/03/15 20:01:28]

It's probably worth a CHECK that network.address is non-empty before calling
"network.address.front()"

[Sergey Ulanov, 2012/03/15 22:18:00]

NetAddressPrivateImpl::IPEndPointToNetAddress() is used instead now.

+           network.address.size());
+
+    // TODO(sergeyu): Currently net::NetworkInterfaceList provides
+    // only name and one IP address. Add all other fields and copy
+    // them here.
+    network_copy.type = PP_NETWORKLIST_UNKNOWN;
+    network_copy.state = PP_NETWORKLIST_UP;
+    network_copy.display_name = network.name;
+    network_copy.mtu = 0;
+  }
+  for (NetworkMonitorIdSet::iterator it = network_monitor_ids_.begin();
+       it != network_monitor_ids_.end(); ++it) {
+    Send(new PpapiMsg_PPBNetworkMonitor_NetworkList(
+        ppapi::API_ID_PPB_NETWORKMANAGER_PRIVATE, *it, *list_copy));
+  }
+}