Pepper: Make users of pp:NetworkMonitorPrivate less likely to leak resources.

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/instance_handle.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/net_address_private.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/utility/private/network_list_observer_private.h"
 
 REGISTER_TEST_CASE(NetworkMonitorPrivate);
 
 namespace {
 
 struct CallbackData {
   explicit CallbackData(PP_Instance instance)
       : event(instance),
         call_counter(0),
-        list_resource(0),
         delete_monitor(false),
         monitor(NULL) {
   }
   ~CallbackData() {
-    if (list_resource)
-      pp::Module::Get()->core()->ReleaseResource(list_resource);
   }
   NestedEvent event;
   int call_counter;
-  PP_Resource list_resource;
+  pp::NetworkListPrivate network_list;
   bool delete_monitor;
   pp::NetworkMonitorPrivate* monitor;
 };
 
-void TestCallback(void* user_data, PP_Resource network_list) {
+void TestCallback(void* user_data, PP_Resource pp_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;
+  data->network_list = pp::NetworkListPrivate(pp::PASS_REF, pp_network_list);
 
   if (data->delete_monitor)
     delete data->monitor;
 
-
   if (data->call_counter == 1)
     data->event.Signal();
 }
 
 
 class TestNetworkListObserver : public pp::NetworkListObserverPrivate {
  public:
   explicit TestNetworkListObserver(const pp::InstanceHandle& instance)
       : pp::NetworkListObserverPrivate(instance),
         event(instance.pp_instance()) {
@@ skipping 20 matching lines @@
   return CheckTestingInterface();
 }
 
 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);
   RUN_TEST_FORCEASYNC_AND_NOT(ListObserver, filter);
 }
 
-std::string TestNetworkMonitorPrivate::VerifyNetworkListResource(
-    PP_Resource network_list_resource) {
-  pp::NetworkListPrivate network_list(network_list_resource);
-  return VerifyNetworkList(network_list);
-}
-
 std::string TestNetworkMonitorPrivate::VerifyNetworkList(
     const pp::NetworkListPrivate& network_list) {
   // Verify that there is at least one network interface.
   size_t count = network_list.GetCount();
   ASSERT_TRUE(count >= 1U);
 
   // Iterate over all interfaces and verify their properties.
   for (size_t iface = 0; iface < count; ++iface) {
     // Verify that the first interface has at least one address.
     std::vector<PP_NetAddress_Private> addresses;
@@ skipping 67 matching lines @@
 }
 
 std::string TestNetworkMonitorPrivate::TestBasic() {
   CallbackData callback_data(instance_->pp_instance());
 
   pp::NetworkMonitorPrivate network_monitor(
       instance_, &TestCallback, &callback_data);
   callback_data.event.Wait();
   ASSERT_EQ(callback_data.call_counter, 1);
 
-  ASSERT_SUBTEST_SUCCESS(
-      VerifyNetworkListResource(callback_data.list_resource));
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.network_list));
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::Test2Monitors() {
   CallbackData callback_data(instance_->pp_instance());
 
   pp::NetworkMonitorPrivate network_monitor(
       instance_, &TestCallback, &callback_data);
   callback_data.event.Wait();
   ASSERT_EQ(callback_data.call_counter, 1);
 
-  ASSERT_SUBTEST_SUCCESS(
-      VerifyNetworkListResource(callback_data.list_resource));
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.network_list));
 
   CallbackData callback_data_2(instance_->pp_instance());
 
   pp::NetworkMonitorPrivate network_monitor_2(
       instance_, &TestCallback, &callback_data_2);
   callback_data_2.event.Wait();
   ASSERT_EQ(callback_data_2.call_counter, 1);
 
-  ASSERT_SUBTEST_SUCCESS(
-      VerifyNetworkListResource(callback_data_2.list_resource));
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data_2.network_list));
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::TestDeleteInCallback() {
   CallbackData callback_data(instance_->pp_instance());
 
   pp::NetworkMonitorPrivate* network_monitor = new pp::NetworkMonitorPrivate(
       instance_, &TestCallback, &callback_data);
   callback_data.delete_monitor = true;
   callback_data.monitor = network_monitor;
 
   callback_data.event.Wait();
   ASSERT_EQ(callback_data.call_counter, 1);
 
-  ASSERT_SUBTEST_SUCCESS(
-      VerifyNetworkListResource(callback_data.list_resource));
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.network_list));
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::TestListObserver() {
   TestNetworkListObserver observer(instance_);
   observer.event.Wait();
   ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(observer.current_list));
   PASS();
 }