Out-of-process implementation of the PPB_NetworkMonitor_Private interface.

ppapi/tests/test_network_monitor_private.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/tests/test_network_monitor_private.h"
 
 #include <string.h>
 
 #include "ppapi/cpp/private/network_list_private.h"
 #include "ppapi/cpp/private/network_monitor_private.h"
 #include "ppapi/tests/testing_instance.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/cpp/module.h"
 
 REGISTER_TEST_CASE(NetworkMonitorPrivate);
 
 namespace {
 
 struct CallbackData {
   explicit CallbackData(PP_Instance instance)
       : call_counter(0),
         completion_callback(instance),
-        list_resource(0) {
+        list_resource(0),
+        delete_monitor(false),
+        monitor(NULL) {
   }
   ~CallbackData() {
     if (list_resource)
       pp::Module::Get()->core()->ReleaseResource(list_resource);
   }
   int call_counter;
   TestCompletionCallback completion_callback;
   PP_Resource list_resource;
+  bool delete_monitor;
+  pp::NetworkMonitorPrivate* monitor;
 };
 
 void TestCallback(void* user_data, PP_Resource network_list) {
   CallbackData* data = static_cast<CallbackData*>(user_data);
   data->call_counter++;
 
   if (data->list_resource)
     pp::Module::Get()->core()->ReleaseResource(data->list_resource);
   data->list_resource = network_list;
 
+  if (data->delete_monitor)
+    delete data->monitor;
+
   // Invoke completion callback only for the first change notification.
   if (data->call_counter == 1)
     static_cast<pp::CompletionCallback>(data->completion_callback).Run(PP_OK);
 }
 
 }  // namespace
 
 TestNetworkMonitorPrivate::TestNetworkMonitorPrivate(TestingInstance* instance)
     : TestCase(instance) {
 }
 
 bool TestNetworkMonitorPrivate::Init() {
   if (!pp::NetworkMonitorPrivate::IsAvailable())
     return false;
 
   return true;
 }
 
 void TestNetworkMonitorPrivate::RunTests(const std::string& filter) {
   RUN_TEST_FORCEASYNC_AND_NOT(Basic, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(2Monitors, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(DeleteInCallback, filter);
 }
 
 std::string TestNetworkMonitorPrivate::VerifyNetworkList(
     PP_Resource network_resource) {
   pp::NetworkListPrivate network_list(network_resource);
 
   // Verify that there is at least one network interface.
   size_t count = network_list.GetCount();
   ASSERT_TRUE(count >= 1U);
 
@@ skipping 86 matching lines @@
 
   pp::NetworkMonitorPrivate network_monitor_2(
       instance_, &TestCallback, reinterpret_cast<void*>(&callback_data_2));
   ASSERT_EQ(callback_data_2.completion_callback.WaitForResult(), PP_OK);
   ASSERT_EQ(callback_data_2.call_counter, 1);
 
   ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data_2.list_resource));
 
   PASS();
 }
+
+std::string TestNetworkMonitorPrivate::TestDeleteInCallback() {
+  CallbackData callback_data(instance_->pp_instance());
+
+  pp::NetworkMonitorPrivate* network_monitor = new pp::NetworkMonitorPrivate(
+      instance_, &TestCallback, reinterpret_cast<void*>(&callback_data));
+  callback_data.delete_monitor = true;
+  callback_data.monitor = network_monitor;
+
+  ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK);
+  ASSERT_EQ(callback_data.call_counter, 1);
+
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.list_resource));
+
+  PASS();
+}