Out-of-process implementation of the PPB_NetworkMonitor_Private interface.

ppapi/proxy/ppb_network_monitor_private_proxy.cc

+// 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 "ppapi/proxy/ppb_network_monitor_private_proxy.h"
+
+#include "ppapi/proxy/enter_proxy.h"
+#include "ppapi/proxy/plugin_proxy_delegate.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/thunk/ppb_network_monitor_private_api.h"
+
+namespace ppapi {
+namespace proxy {
+
+class PPB_NetworkMonitor_Private_Proxy::NetworkMonitor
+    : public Resource,
+      public thunk::PPB_NetworkMonitor_Private_API,
+      public base::SupportsWeakPtr<
+          PPB_NetworkMonitor_Private_Proxy::NetworkMonitor> {
+ public:
+  NetworkMonitor(PP_Instance instance,
+                 PPB_NetworkMonitor_Private_Proxy* proxy,
+                 PPB_NetworkMonitor_Callback callback,
+                 void* user_data)
+      : Resource(OBJECT_IS_PROXY, instance),
+        proxy_(proxy),
+        callback_(callback),
+        user_data_(user_data) {
+  }
+
+  virtual ~NetworkMonitor() {
+    proxy_->OnNetworkMonitorDeleted(this, pp_instance());
+  }
+
+  // Resource overrides.
+  virtual ppapi::thunk::PPB_NetworkMonitor_Private_API*
+  AsPPB_NetworkMonitor_Private_API() OVERRIDE {
+    return this;

[dmichael (off chromium), 2012/03/16 19:55:22]

ditto here

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

Done.

+  }
+
+  void OnNetworkListReceived(const scoped_refptr<NetworkListStorage>& list) {
+    PP_Resource list_resource =
+        PPB_NetworkList_Private_Shared::Create(
+            OBJECT_IS_PROXY, pp_instance(), list);
+    CallWhileUnlocked(callback_, user_data_, list_resource);
+  }
+
+ private:
+  PPB_NetworkMonitor_Private_Proxy* proxy_;
+  PPB_NetworkMonitor_Callback callback_;
+  void* user_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkMonitor);
+};
+
+PPB_NetworkMonitor_Private_Proxy::PPB_NetworkMonitor_Private_Proxy(
+    Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      monitors_(new ObserverListThreadSafe<NetworkMonitor>()),
+      monitors_count_(0) {
+}
+
+PPB_NetworkMonitor_Private_Proxy::~PPB_NetworkMonitor_Private_Proxy() {
+  monitors_->AssertEmpty();
+}
+
+// static
+PP_Resource PPB_NetworkMonitor_Private_Proxy::CreateProxyResource(
+    PP_Instance instance,
+    PPB_NetworkMonitor_Callback callback,
+    void* user_data) {
+  if (!callback)
+    return 0;
+
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return 0;
+  PPB_NetworkMonitor_Private_Proxy* proxy =
+      static_cast<PPB_NetworkMonitor_Private_Proxy*>(
+          dispatcher->GetInterfaceProxy(kApiID));
+  if (!proxy)
+    return 0;
+
+  scoped_ptr<NetworkMonitor> result(
+      new NetworkMonitor(instance, proxy, callback, user_data));
+  proxy->monitors_->AddObserver(result.get());
+
+  proxy->monitors_count_++;
+  if (proxy->monitors_count_ == 1) {
+    // If that is the first network monitor then send Start message.
+    PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+        new PpapiHostMsg_PPBNetworkMonitor_Start(
+            dispatcher->plugin_dispatcher_id()));
+  } else if (proxy->current_list_.get()) {
+    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+        &NetworkMonitor::OnNetworkListReceived,
+        result->AsWeakPtr(), proxy->current_list_));
+  }
+
+  return result.release()->GetReference();
+}
+
+bool PPB_NetworkMonitor_Private_Proxy::OnMessageReceived(
+    const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PPB_NetworkMonitor_Private_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBNetworkMonitor_NetworkList,
+                        OnPluginMsgNetworkList)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PPB_NetworkMonitor_Private_Proxy::OnPluginMsgNetworkList(
+    uint32 plugin_dispatcher_id,
+    const ppapi::NetworkList& list) {
+  scoped_refptr<NetworkListStorage> list_storage(new NetworkListStorage(list));
+  current_list_ = list_storage;
+  monitors_->Notify(&NetworkMonitor::OnNetworkListReceived, list_storage);

[dmichael (off chromium), 2012/03/16 19:55:22]

Have you thought about corner cases due to the asynchronous nature of the
Start/Stop/NetworkList messages?

E.g., it seems there's a bug if you have a sequence of events like this:
0) Suppose you have 1 NetworkMonitor.
1) The browser sends a message that the NetworkList was updated.
2) Before that message is received, the 1 NetworkMonitor goes away, so we send
"Stop" to the browser.
3) The OnPluginMsgNetworkList message arrives here, so we set current_list_ to
this new list. The Notify does nothing, since there are no observers.
4) Some time later, another NetworkMonitor is created. Because current_list_ is
valid, we send that to the NetworkMonitor. So before it gets the "real" network
list, it gets one that's possibly out-of-date.

I guess you do need to set proxy->current_list_ to NULL above. (It probably
makes sense to NULL it in both). Sorry about that.

You also could have a slightly weird situation if the first NetworkMonitor is
created and destroyed quickly, before it receives its network list. Another one
might register afterwards and receive the NetworkList that was intended for the
first NetworkMonitor. I can't really see the harm in this case, though. (it
would matter if we had to make sure that we never got non-consecutive
"updates").

Basically, I want to make sure you've thought through the cases. Doing an
observer distributed across processes gets tricky.

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

Heh, that scenario is the reason I initially had the code that would resets
|current_list_| when sending Start() message (patch set 1). I've put it back
with comments.
Yes, I thought about these cases. Because the interface is asynchronous it is
never possible to guarantee that the NetworkList we receive here represents the
current state of network configuration. More than that, it is not possible to
make this interface synchronous because there is no way for an application to
lock network interfaces configuration. It can change the moment getifaddrs()
returns, so NetworkList may be already stale even when the message is sent by
the browser. What's import for that interface is that (1) we get first
notification after NetworkMonitor instance is created, and (2) whenever network
configuration changes it gets notification about it. The current approach meets
these two requirements. In the scenario you described the worst that would
happen is that the plugin gets two notifications after NetworkMonitor is created
- but that's not a problem as long as the second notification correctly reflects
current network configuration.

+}
+
+void PPB_NetworkMonitor_Private_Proxy::OnNetworkMonitorDeleted(
+    NetworkMonitor* monitor,
+    PP_Instance instance) {
+  monitors_->RemoveObserver(monitor);
+  monitors_count_--;
+  if (monitors_count_ == 0) {
+    // Send Stop message if that was the last NetworkMonitor.
+    PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+    if (dispatcher) {
+      current_list_ = NULL;
+      PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+          new PpapiHostMsg_PPBNetworkMonitor_Stop(
+              dispatcher->plugin_dispatcher_id()));
+    }
+  }
+}
+
+}  // namespace proxy
+}  // namespace ppapi