WebSocket Pepper API: allow to release in completion callbacks

ppapi/tests/test_websocket.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_websocket.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppb_var_array_buffer.h"
 #include "ppapi/c/ppb_websocket.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/websocket.h"
-#include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 #include "ppapi/utility/websocket/websocket_api.h"
 
 // These servers are provided by pywebsocket server side handlers in
 // LayoutTests/http/tests/websocket/tests/hybi/*_wsh.
 // pywebsocket server itself is launched in ppapi_ui_test.cc.
 const char kEchoServerURL[] = "websocket/tests/hybi/echo-with-no-extension";
 
 const char kCloseServerURL[] = "websocket/tests/hybi/close";
 
@@ skipping 124 matching lines @@
   bool wait_for_connected_;
   bool wait_for_received_;
   bool wait_for_closed_;
   PP_Instance instance_;
 };
 
 }  // namespace
 
 REGISTER_TEST_CASE(WebSocket);
 
+void TestWebSocket::OnCallback(void* user_data, int32_t result) {
+  if (resource_)
+    core_interface_->ReleaseResource(resource_);
+}
+
 bool TestWebSocket::Init() {
+  resource_ = 0;
   websocket_interface_ = static_cast<const PPB_WebSocket*>(
       pp::Module::Get()->GetBrowserInterface(PPB_WEBSOCKET_INTERFACE));
   var_interface_ = static_cast<const PPB_Var*>(
       pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
   arraybuffer_interface_ = static_cast<const PPB_VarArrayBuffer*>(
       pp::Module::Get()->GetBrowserInterface(
           PPB_VAR_ARRAY_BUFFER_INTERFACE));
   core_interface_ = static_cast<const PPB_Core*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
   if (!websocket_interface_ || !var_interface_ || !arraybuffer_interface_ ||
@@ skipping 381 matching lines @@
   ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
       callback.GetCallback().pp_completion_callback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
   core_interface_->ReleaseResource(ws);
 
+  // Release the resource before completion callback invoked.

[dmichael (off chromium), 2012/06/25 15:50:51]

nit: before +the+ completion callback +is+ invoked

[Takashi Toyoshima, 2012/06/26 09:19:10]

Done.

+  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, result);
+  result = websocket_interface_->Close(
+      ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
+      callback.GetCallback().pp_completion_callback());
+  core_interface_->ReleaseResource(ws);
+  callback.WaitForResult(result);
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
+
+  // Release the resource in the completion callback.
+  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, result);
+  result = websocket_interface_->Close(
+      ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
+      callback.GetCallback().pp_completion_callback());
+  resource_ = ws;
+  callback.SetDelegate(this);
+  callback.WaitForResult(result);
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
   // Close in connecting.
   // The ongoing connect failed with PP_ERROR_ABORTED, then the close is done
   // successfully.
   ws = websocket_interface_->Create(instance_->pp_instance());
   result = websocket_interface_->Connect(
       ws, url, protocols, 0U, callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       another_callback.GetCallback().pp_completion_callback());
@@ skipping 820 matching lines @@
   size_t last_event = events_on_closed - 1;
   for (uint32_t i = 1; i < last_event; ++i) {
     ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[i].event_type);
     ASSERT_TRUE(AreEqualWithString(events[i].var.pp_var(), message));
   }
   ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[last_event].event_type);
   ASSERT_TRUE(events[last_event].was_clean);
 
   PASS();
 }