Add NetworkListObserver utility class.

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/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"
+#include "ppapi/utility/network_list_observer.h"
 
 REGISTER_TEST_CASE(NetworkMonitorPrivate);
 
 namespace {
 
 struct CallbackData {
   explicit CallbackData(PP_Instance instance)
       : call_counter(0),
         completion_callback(instance),
         list_resource(0),
@@ skipping 20 matching lines @@
   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);
 }
 
+
+class TestNetworkListObserver : public pp::NetworkListObserver {
+ public:
+  TestNetworkListObserver(const pp::InstanceHandle& instance)
+      : pp::NetworkListObserver(instance),
+        completion_callback(instance.pp_instance()) {
+  }
+  virtual void OnNetworkList(const pp::NetworkListPrivate& list) {
+    current_list = list;
+    static_cast<pp::CompletionCallback>(completion_callback).Run(PP_OK);
+  }
+
+  pp::NetworkListPrivate current_list;
+  TestCompletionCallback completion_callback;
+};
+
 }  // 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);
+  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(
-    PP_Resource network_resource) {
-  pp::NetworkListPrivate network_list(network_resource);
-
+    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;
     network_list.GetIpAddresses(iface, &addresses);
     ASSERT_TRUE(addresses.size() >= 1U);
@@ skipping 31 matching lines @@
               PPB_NETWORKLIST_PRIVATE_INTERFACE));
   ASSERT_TRUE(interface);
   std::vector<PP_NetAddress_Private> addresses;
   network_list.GetIpAddresses(0, &addresses);
   size_t address_count = addresses.size();
   addresses.resize(addresses.size() + 3);
   for (size_t i = 0; i < addresses.size(); ++i) {
     const char kFillValue = 123;
     memset(&addresses.front(), kFillValue,
            addresses.size() * sizeof(PP_NetAddress_Private));
-    int result = interface->GetIpAddresses(network_resource, 0,
+    int result = interface->GetIpAddresses(network_list.pp_resource(), 0,
                                            &addresses.front(), i);
     ASSERT_EQ(result, static_cast<int>(address_count));
 
     // Verify that nothing outside the buffer was touched.
     for (char* pos = reinterpret_cast<char*>(&addresses[result]);
          pos != reinterpret_cast<char*>(&addresses[0] + addresses.size());
          ++pos) {
       ASSERT_TRUE(*pos == kFillValue);
     }
   }
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::TestBasic() {
   CallbackData callback_data(instance_->pp_instance());
 
   pp::NetworkMonitorPrivate network_monitor(
       instance_, &TestCallback, reinterpret_cast<void*>(&callback_data));
   ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK);
   ASSERT_EQ(callback_data.call_counter, 1);
 
-  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.list_resource));
+  ASSERT_SUBTEST_SUCCESS(
+      VerifyNetworkListResource(callback_data.list_resource));
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::Test2Monitors() {
   CallbackData callback_data(instance_->pp_instance());
 
   pp::NetworkMonitorPrivate network_monitor(
       instance_, &TestCallback, reinterpret_cast<void*>(&callback_data));
   ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK);
   ASSERT_EQ(callback_data.call_counter, 1);
 
-  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.list_resource));
+  ASSERT_SUBTEST_SUCCESS(
+      VerifyNetworkListResource(callback_data.list_resource));
 
   CallbackData callback_data_2(instance_->pp_instance());
 
   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));
+  ASSERT_SUBTEST_SUCCESS(
+      VerifyNetworkListResource(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));
+  ASSERT_SUBTEST_SUCCESS(
+      VerifyNetworkListResource(callback_data.list_resource));
 
   PASS();
 }
+
+std::string TestNetworkMonitorPrivate::TestListObserver() {
+  TestNetworkListObserver observer(instance_);
+  ASSERT_EQ(observer.completion_callback.WaitForResult(), PP_OK);
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(observer.current_list));
+  PASS();
+}