WebSocket Pepper API: allow to close connection without code and 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 531 matching lines @@
       instance_->pp_instance(), callback_type());
 
   // Close.
   int32_t result;
   PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback()));
-  CHECK_CALLBACK_BEHAVIOR(callback);

[Takashi Toyoshima, 2012/05/14 12:05:04]

I'm afraid that these checks will not work in the future.

[dmichael (off chromium), 2012/05/14 16:10:49]

Can you elaborate on your concerns?

The check simply ensures that the callback followed expected PPAPI callback
behavior. I.e.:
- If the callback type is REQUIRED, and the PPAPI function happens
synchronously, that's an error.
- If the callback type is blocking, and the PPAPI function happens
asynchronously, that's an error.

The CHECK_CALLBACK_BEHAVIOR is safe. If it ever fails, it means you (or I) have
a bug. That said, we don't *have* to use it everywhere.

[Takashi Toyoshima, 2012/05/15 10:55:28]

Sorry, I misunderstood on CHECK_CALLBACK_BEHAVIOR macro as it always checked
callback being invoked asynchronously.
OK, I keep these macro here and around.

   ASSERT_EQ(PP_OK, callback.result());
   core_interface_->ReleaseResource(ws);
 
+  // Close without code and reason.
+  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, result);
+  callback.WaitForResult(websocket_interface_->Close(
+      ws, PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED, reason,
+      callback.GetCallback().pp_completion_callback()));
+  ASSERT_EQ(PP_OK, callback.result());
+  core_interface_->ReleaseResource(ws);
+
   // Close with PP_VARTYPE_UNDEFINED.
   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);
 
   // 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);
@@ skipping 435 matching lines @@
   ASSERT_TRUE(AreEqualWithString(ws.GetExtensions().pp_var(), ""));
   ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), ""));
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ws.GetReadyState());
   ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), ""));
 
   // Check communication interfaces (connect, send, receive, and close).
   TestCompletionCallback connect_callback(
       instance_->pp_instance(), callback_type());
   connect_callback.WaitForResult(ws.Connect(
       pp::Var(GetFullURL(kCloseServerURL)), NULL, 0U, connect_callback));
-  CHECK_CALLBACK_BEHAVIOR(connect_callback);
   ASSERT_EQ(PP_OK, connect_callback.result());
 
   std::string text_message("hello C++");
   int32_t result = ws.SendMessage(pp::Var(text_message));
   ASSERT_EQ(PP_OK, result);
 
   std::vector<uint8_t> binary(256);
   for (uint32_t i = 0; i < binary.size(); ++i)
     binary[i] = i;
   result = ws.SendMessage(
@@ skipping 367 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();
 }