Refactor PPB_NetworkMonitor_Private interface to use CompletionCallback.

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/ppapi_messages.h"
 #include "ppapi/shared_impl/proxy_lock.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)
+                 PPB_NetworkMonitor_Private_Proxy* proxy)
       : Resource(OBJECT_IS_PROXY, instance),
         proxy_(proxy),
-        callback_(callback),
-        user_data_(user_data) {
+        initial_list_sent_(false),
+        network_list_(NULL) {
   }
 
   virtual ~NetworkMonitor() {
+    if (TrackedCallback::IsPending(update_callback_))
+      update_callback_->PostAbort();
     proxy_->OnNetworkMonitorDeleted(this, pp_instance());
   }
 
+  // thunk::PPB_NetworkMonitor_Private_API interface.
+  virtual int32_t UpdateNetworkList(
+        PP_Resource* network_list,
+        scoped_refptr<TrackedCallback> callback) OVERRIDE {
+    if (!network_list)
+      return PP_ERROR_BADARGUMENT;
+    if (TrackedCallback::IsPending(update_callback_))
+      return PP_ERROR_INPROGRESS;
+
+    if (current_list_ && !initial_list_sent_) {
+      initial_list_sent_ = true;
+      thunk::EnterResourceCreation enter(pp_instance());

[yzshen1, 2013/09/04 19:52:01]

Please use EnterResourceCreationNoLock. At this point, the lock has been
acquired.

[Sergey Ulanov, 2013/09/04 22:22:32]

Done. Thanks for catching this.

+      *network_list = PPB_NetworkList_Private_Shared::Create(
+          OBJECT_IS_PROXY, pp_instance(), current_list_);
+      return PP_OK;
+    }
+
+    network_list_ = network_list;
+    update_callback_ = callback;
+    return PP_OK_COMPLETIONPENDING;
+  }
 
   // Resource overrides.
   virtual ppapi::thunk::PPB_NetworkMonitor_Private_API*
   AsPPB_NetworkMonitor_Private_API() OVERRIDE {
     return this;
   }
 
   // This is invoked when a network list is received for this monitor (either
   // initially or on a change). It acquires the ProxyLock inside because
   // ObserverListThreadSafe does not support Bind/Closure, otherwise we would
   // wrap the call with a lock using RunWhileLocked.
   void OnNetworkListReceivedLocks(
       const scoped_refptr<NetworkListStorage>& list) {
     ProxyAutoLock lock;
-    PP_Resource list_resource =
-        PPB_NetworkList_Private_Shared::Create(
+
+    current_list_ = list;
+
+    if (TrackedCallback::IsPending(update_callback_)) {
+      initial_list_sent_ = true;
+      {
+        thunk::EnterResourceCreationNoLock enter(pp_instance());
+        *network_list_ = PPB_NetworkList_Private_Shared::Create(
             OBJECT_IS_PROXY, pp_instance(), list);

[yzshen1, 2013/09/04 19:52:01]

nit: please consider setting network_list_ to NULL.

[Sergey Ulanov, 2013/09/04 22:22:32]

Done.

-    CallWhileUnlocked(callback_, user_data_, list_resource);
+      }
+      update_callback_->Run(PP_OK);
+    }
   }
 
  private:
   PPB_NetworkMonitor_Private_Proxy* proxy_;
-  PPB_NetworkMonitor_Callback callback_;
-  void* user_data_;
+  scoped_refptr<NetworkListStorage> current_list_;
+  bool initial_list_sent_;
+
+  // Parameters passed to UpdateNetworkList();
+  PP_Resource* network_list_;
+  scoped_refptr<TrackedCallback> update_callback_;
 
   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) {
+    PP_Instance instance) {
   // TODO(dmichael): Check that this thread has a valid message loop associated
   //                 with it.
-  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_refptr<NetworkMonitor> result(
-      new NetworkMonitor(instance, proxy, callback, user_data));
+  scoped_refptr<NetworkMonitor> result(new NetworkMonitor(instance, proxy));
   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()->GetBrowserSender()->Send(
         new PpapiHostMsg_PPBNetworkMonitor_Start(
             dispatcher->plugin_dispatcher_id()));
 
     // We could have received network list message after sending the
@@ skipping 42 matching lines @@
       PluginGlobals::Get()->GetBrowserSender()->Send(
           new PpapiHostMsg_PPBNetworkMonitor_Stop(
               dispatcher->plugin_dispatcher_id()));
     }
     current_list_ = NULL;
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi