WebSocket Pepper API: PPB_WebSocket::close must accept undefined reason

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>
@@ skipping 432 matching lines @@
   PP_Var extensions = websocket_interface_->GetExtensions(ws);
   ASSERT_TRUE(AreEqualWithString(extensions, ""));
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestInvalidClose() {
   PP_Var reason = CreateVarString("close for test");
   TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback another_callback(instance_->pp_instance());
 
   // Close before connect.
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
-  int32_t result = websocket_interface_->Close(
-      ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
+  int32_t result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_FAILED, result);
   core_interface_->ReleaseResource(ws);
 
   // Close with bad arguments.
   ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(ws, 1U, reason,
       callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_NOACCESS, result);
   core_interface_->ReleaseResource(ws);
 
+  // Close with PP_VARTYPE_NULL.
+  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, result);
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeNull(),
+      callback.GetCallback().pp_completion_callback());
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
+  core_interface_->ReleaseResource(ws);
+
+  // Close with PP_VARTYPE_NULL and ongoing receive message.
+  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, result);
+  PP_Var receive_message_var;
+  result = websocket_interface_->ReceiveMessage(ws, &receive_message_var,
+      callback.GetCallback().pp_completion_callback());
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeNull(),
+      another_callback.GetCallback().pp_completion_callback());
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
+  const char* send_message = "hi";
+  PP_Var send_message_var = CreateVarString(send_message);
+  result = websocket_interface_->SendMessage(ws, send_message_var);
+  ReleaseVar(send_message_var);
+  ASSERT_EQ(PP_OK, result);
+  result = callback.WaitForResult();
+  ASSERT_EQ(PP_OK, result);
+  ASSERT_TRUE(AreEqualWithString(receive_message_var, send_message));
+  ReleaseVar(receive_message_var);
+  core_interface_->ReleaseResource(ws);
+
   ReleaseVar(reason);
 
   PASS();
 }
 
 std::string TestWebSocket::TestValidClose() {
   PP_Var reason = CreateVarString("close for test");
   PP_Var url = CreateVarString(GetFullURL(kEchoServerURL).c_str());
   PP_Var protocols[] = { PP_MakeUndefined() };
   TestCompletionCallback callback(instance_->pp_instance());
   TestCompletionCallback another_callback(instance_->pp_instance());
 
   // Close.
   int32_t result;
   PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
+  // Close with PP_VARTYPE_UNDEFINED.
+  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());
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
+  result = callback.WaitForResult();
+  ASSERT_EQ(PP_OK, result);
+  core_interface_->ReleaseResource(ws);
+
   // 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 33 matching lines @@
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_ERROR_ABORTED, result);
   result = another_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
+  // Close with PP_VARTYPE_UNDEFINED and ongoing receive message.
+  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, result);
+  result = websocket_interface_->ReceiveMessage(ws, &receive_message_var,
+      callback.GetCallback().pp_completion_callback());
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
+      another_callback.GetCallback().pp_completion_callback());
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
+  result = callback.WaitForResult();
+  ASSERT_EQ(PP_ERROR_ABORTED, result);
+  result = another_callback.WaitForResult();
+  ASSERT_EQ(PP_OK, result);
+  core_interface_->ReleaseResource(ws);
+
   ReleaseVar(reason);
   ReleaseVar(url);
 
   PASS();
 }
 
 std::string TestWebSocket::TestGetProtocol() {
   const char* expected_protocols[] = {
     "x-chat",
     "hoehoe",
@@ skipping 745 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();
 }
-