Refactor PPB_NetworkMonitor_Private interface to use CompletionCallback.

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/completion_callback.h"
 #include "ppapi/cpp/instance_handle.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/net_address.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),
-        delete_monitor(false),
-        monitor(NULL) {
+class CallbackHandler {
+ public:
+  explicit CallbackHandler(PP_Instance instance)
+      : event_(instance),
+        call_counter_(0),
+        monitor_to_delete_(NULL),
+        result_(PP_ERROR_FAILED),
+        callback_factory_(this) {
   }
-  ~CallbackData() {
-  }
-  NestedEvent event;
-  int call_counter;
-  pp::NetworkListPrivate network_list;
-  bool delete_monitor;
-  pp::NetworkMonitorPrivate* monitor;
-};
-
-void TestCallback(void* user_data, PP_Resource pp_network_list) {
-  CallbackData* data = static_cast<CallbackData*>(user_data);
-  data->call_counter++;
-
-  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()) {
-  }
-  virtual void OnNetworkListChanged(const pp::NetworkListPrivate& list) {
-    current_list = list;
-    event.Signal();
+  ~CallbackHandler() {
   }
 
-  pp::NetworkListPrivate current_list;
-  NestedEvent event;
+  void DeleteMonitorWhenCalled(pp::NetworkMonitorPrivate* monitor) {
+    monitor_to_delete_ = monitor;
+  }
+
+  pp::CompletionCallbackWithOutput<pp::NetworkListPrivate> GetCallback() {
+    return callback_factory_.NewCallbackWithOutput(
+        &CallbackHandler::OnNetworkList);
+  }
+
+  void Wait() {
+    event_.Wait();
+  }
+
+  int call_counter() const { return call_counter_; }
+  int result() const { return result_; }
+  const pp::NetworkListPrivate& list() const { return list_; }
+
+ private:
+  void OnNetworkList(int32_t result, const pp::NetworkListPrivate& list) {
+    call_counter_++;
+
+    result_ = result;
+    list_ = list;
+
+    if (monitor_to_delete_) {
+      delete monitor_to_delete_;
+      monitor_to_delete_ = NULL;
+    }
+
+    if (call_counter_ == 1)
+      event_.Signal();
+  }
+
+  NestedEvent event_;
+  int call_counter_;
+  pp::NetworkListPrivate list_;
+  pp::NetworkMonitorPrivate* monitor_to_delete_;
+  int32_t result_;
+
+  pp::CompletionCallbackFactory<CallbackHandler> callback_factory_;
 };
 
 }  // namespace
 
 TestNetworkMonitorPrivate::TestNetworkMonitorPrivate(TestingInstance* instance)
     : TestCase(instance) {
 }
 
 bool TestNetworkMonitorPrivate::Init() {
   if (!pp::NetworkMonitorPrivate::IsAvailable())
     return false;
 
   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::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) {
@@ skipping 59 matching lines @@
 
     PP_NetworkListState_Private state = network_list.GetState(iface);
     ASSERT_TRUE(state >= PP_NETWORKLIST_DOWN);
     ASSERT_TRUE(state <= PP_NETWORKLIST_UP);
   }
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::TestBasic() {
-  CallbackData callback_data(instance_->pp_instance());
+  CallbackHandler callback_handler(instance_->pp_instance());

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

Please consider using TestCompletionCallbackWithOutput.

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

Done.

+  pp::NetworkMonitorPrivate network_monitor(instance_);
+  network_monitor.UpdateNetworkList(callback_handler.GetCallback());
+  callback_handler.Wait();
 
-  pp::NetworkMonitorPrivate network_monitor(
-      instance_, &TestCallback, &callback_data);
-  callback_data.event.Wait();
-  ASSERT_EQ(callback_data.call_counter, 1);
-
-  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.network_list));
+  ASSERT_EQ(callback_handler.call_counter(), 1);
+  ASSERT_EQ(callback_handler.result(), PP_OK);
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_handler.list()));
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::Test2Monitors() {
-  CallbackData callback_data(instance_->pp_instance());
+  CallbackHandler callback_handler(instance_->pp_instance());
+  pp::NetworkMonitorPrivate network_monitor(instance_);
+  network_monitor.UpdateNetworkList(callback_handler.GetCallback());
+  callback_handler.Wait();
 
-  pp::NetworkMonitorPrivate network_monitor(
-      instance_, &TestCallback, &callback_data);
-  callback_data.event.Wait();
-  ASSERT_EQ(callback_data.call_counter, 1);
+  ASSERT_EQ(callback_handler.call_counter(), 1);
+  ASSERT_EQ(callback_handler.result(), PP_OK);
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_handler.list()));
 
-  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.network_list));
+  CallbackHandler callback_handler_2(instance_->pp_instance());
+  pp::NetworkMonitorPrivate network_monitor_2(instance_);
+  network_monitor_2.UpdateNetworkList(callback_handler_2.GetCallback());
+  callback_handler_2.Wait();
 
-  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(VerifyNetworkList(callback_data_2.network_list));
+  ASSERT_EQ(callback_handler_2.call_counter(), 1);
+  ASSERT_EQ(callback_handler_2.result(), PP_OK);
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_handler_2.list()));
 
   PASS();
 }
 
 std::string TestNetworkMonitorPrivate::TestDeleteInCallback() {
-  CallbackData callback_data(instance_->pp_instance());
+  CallbackHandler callback_handler(instance_->pp_instance());
+  pp::NetworkMonitorPrivate* network_monitor =
+      new pp::NetworkMonitorPrivate(instance_);
+  callback_handler.DeleteMonitorWhenCalled(network_monitor);
+  network_monitor->UpdateNetworkList(callback_handler.GetCallback());
+  callback_handler.Wait();
 
-  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(VerifyNetworkList(callback_data.network_list));
+  ASSERT_EQ(callback_handler.call_counter(), 1);
+  ASSERT_EQ(callback_handler.result(), PP_OK);
+  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_handler.list()));
 
   PASS();
 }
-
-std::string TestNetworkMonitorPrivate::TestListObserver() {
-  TestNetworkListObserver observer(instance_);
-  observer.event.Wait();
-  ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(observer.current_list));
-  PASS();
-}