WebSocket Pepper API: unit test must use close code defined by API

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 <string.h>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
@@ skipping 24 matching lines @@
 const char kProtocolTestServerURL[] =
     "ws://localhost:8880/websocket/tests/hybi/protocol-test?protocol=";
 
 const char* const kInvalidURLs[] = {
   "http://www.google.com/invalid_scheme",
   "ws://www.google.com/invalid#fragment",
   "ws://www.google.com:65535/invalid_port",
   NULL
 };
 
-// Connection close code is defined in WebSocket protocol specification.
-// The magic number 1000 means gracefull closure without any error.
-// See section 7.4.1. of RFC 6455.
-const uint16_t kCloseCodeNormalClosure = 1000U;
-
 // Internal packet sizes.
 const uint64_t kCloseFrameSize = 6;
 const uint64_t kMessageFrameOverhead = 6;
 
 namespace {
 
 struct WebSocketEvent {
   enum EventType {
     EVENT_OPEN,
     EVENT_MESSAGE,
@@ skipping 366 matching lines @@
   PASS();
 }
 
 std::string TestWebSocket::TestInvalidClose() {
   PP_Var reason = CreateVarString("close for test");
   TestCompletionCallback callback(instance_->pp_instance());
 
   // Close before connect.
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   int32_t result = websocket_interface_->Close(
-      ws, kCloseCodeNormalClosure, reason,
+      ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_ERROR_FAILED, result);
   core_interface_->ReleaseResource(ws);
 
   // Close with bad arguments.
   ws = Connect(kEchoServerURL, &result, NULL);
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(ws, 1U, reason,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
@@ skipping 10 matching lines @@
   PP_Var url = CreateVarString(kEchoServerURL);
   PP_Var protocols[] = { PP_MakeUndefined() };
   TestCompletionCallback callback(instance_->pp_instance());
   TestCompletionCallback another_callback(instance_->pp_instance());
 
   // Close.
   int32_t result;
   PP_Resource ws = Connect(kEchoServerURL, &result, NULL);
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
-  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(callback).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,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
-  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(
           another_callback).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 in closing.
   // The first close will be done successfully, then the second one failed with
   // with PP_ERROR_INPROGRESS immediately.
   ws = Connect(kEchoServerURL, &result, NULL);
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
-  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
-  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(
           another_callback).pp_completion_callback());
   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
   // Close with ongoing receive message.
   ws = Connect(kEchoServerURL, &result, NULL);
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var receive_message_var;
   result = websocket_interface_->ReceiveMessage(ws, &receive_message_var,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
-  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(
           another_callback).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);
@@ skipping 111 matching lines @@
     buffered_amount = websocket_interface_->GetBufferedAmount(ws);
     // Buffered amount size 262144 is too big for the internal buffer size.
     if (buffered_amount > 262144)
       break;
   }
 
   // Close connection.
   std::string reason_str = "close while busy";
   PP_Var reason = CreateVarString(reason_str.c_str());
   TestCompletionCallback callback(instance_->pp_instance());
-  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+  result = websocket_interface_->Close(ws,
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING,
       websocket_interface_->GetReadyState(ws));
 
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED,
       websocket_interface_->GetReadyState(ws));
 
@@ skipping 70 matching lines @@
   TestCompletionCallback binary_receive_callback(instance_->pp_instance());
   result = ws.ReceiveMessage(&binary_receive_var, binary_receive_callback);
   if (result == PP_OK_COMPLETIONPENDING)
     result = binary_receive_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   ASSERT_TRUE(AreEqualWithBinary(
       binary_receive_var.pp_var(), binary_message, binary_length));
 
   TestCompletionCallback close_callback(instance_->pp_instance());
   std::string reason("bye");
-  result = ws.Close(kCloseCodeNormalClosure, pp::Var(reason), close_callback);
+  result = ws.Close(
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason), close_callback);
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = close_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
 
   // Check initialized properties access.
   ASSERT_EQ(0, ws.GetBufferedAmount());
-  ASSERT_EQ(kCloseCodeNormalClosure, ws.GetCloseCode());
+  ASSERT_EQ(PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, ws.GetCloseCode());
   ASSERT_TRUE(AreEqualWithString(ws.GetCloseReason().pp_var(), reason.c_str()));
   ASSERT_EQ(true, ws.GetCloseWasClean());
   ASSERT_TRUE(AreEqualWithString(ws.GetExtensions().pp_var(), ""));
   ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), ""));
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, ws.GetReadyState());
   ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), kCloseServerURL));
 
   PASS();
 }
 
@@ skipping 81 matching lines @@
 
   PASS();
 }
 
 std::string TestWebSocket::TestUtilityInvalidClose() {
   const pp::Var reason = pp::Var(std::string("close for test"));
 
   // Close before connect.
   {
     TestWebSocketAPI websocket(instance_);
-    int32_t result = websocket.Close(kCloseCodeNormalClosure, reason);
+    int32_t result = websocket.Close(
+        PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason);
     ASSERT_EQ(PP_ERROR_FAILED, result);
     ASSERT_EQ(0U, websocket.GetSeenEvents().size());
   }
 
   // Close with bad arguments.
   {
     TestWebSocketAPI websocket(instance_);
     int32_t result = websocket.Connect(pp::Var(std::string(kEchoServerURL)),
         NULL, 0);
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
@@ skipping 11 matching lines @@
 std::string TestWebSocket::TestUtilityValidClose() {
   std::string reason("close for test");
   pp::Var url = pp::Var(std::string(kCloseServerURL));
 
   // Close.
   {
     TestWebSocketAPI websocket(instance_);
     int32_t result = websocket.Connect(url, NULL, 0U);
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
     websocket.WaitForConnected();
-    result = websocket.Close(kCloseCodeNormalClosure, pp::Var(reason));
+    result = websocket.Close(
+        PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
     websocket.WaitForClosed();
     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
     ASSERT_EQ(2U, events.size());
     ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[1].event_type);
     ASSERT_TRUE(events[1].was_clean);
-    ASSERT_EQ(kCloseCodeNormalClosure, events[1].close_code);
+    ASSERT_EQ(PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, events[1].close_code);
     ASSERT_TRUE(AreEqualWithString(events[1].var.pp_var(), reason.c_str()));
   }
 
   // Close in connecting.
   // The ongoing connect failed with PP_ERROR_ABORTED, then the close is done
   // successfully.
   {
     TestWebSocketAPI websocket(instance_);
     int32_t result = websocket.Connect(url, NULL, 0U);
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
-    result = websocket.Close(kCloseCodeNormalClosure, pp::Var(reason));
+    result = websocket.Close(
+        PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
     websocket.WaitForClosed();
     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
     ASSERT_TRUE(events.size() == 2 || events.size() == 3);
     int index = 0;
     if (events.size() == 3)
       ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[index++].event_type);
     ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[index++].event_type);
     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[index].event_type);
     ASSERT_FALSE(events[index].was_clean);
   }
 
   // Close in closing.
   // The first close will be done successfully, then the second one failed with
   // with PP_ERROR_INPROGRESS immediately.
   {
     TestWebSocketAPI websocket(instance_);
     int32_t result = websocket.Connect(url, NULL, 0U);
-    result = websocket.Close(kCloseCodeNormalClosure, pp::Var(reason));
+    result = websocket.Close(
+        PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
-    result = websocket.Close(kCloseCodeNormalClosure, pp::Var(reason));
+    result = websocket.Close(
+        PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
     ASSERT_EQ(PP_ERROR_INPROGRESS, result);
     websocket.WaitForClosed();
     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
     ASSERT_TRUE(events.size() == 2 || events.size() == 3)
     int index = 0;
     if (events.size() == 3)
       ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[index++].event_type);
     ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[index++].event_type);
     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[index].event_type);
     ASSERT_FALSE(events[index].was_clean);
@@ skipping 111 matching lines @@
     result = websocket.Send(pp::Var(message_str));
     ASSERT_EQ(PP_OK, result);
     buffered_amount = websocket.GetBufferedAmount();
     // Buffered amount size 262144 is too big for the internal buffer size.
     if (buffered_amount > 262144)
       break;
   }
 
   // Close connection.
   std::string reason_str = "close while busy";
-  result = websocket.Close(kCloseCodeNormalClosure, pp::Var(reason_str));
+  result = websocket.Close(
+      PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason_str));
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING, websocket.GetReadyState());
   websocket.WaitForClosed();
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, websocket.GetReadyState());
 
   uint64_t base_buffered_amount = websocket.GetBufferedAmount();
   size_t events_on_closed = websocket.GetSeenEvents().size();
 
   // After connection closure, all sending requests fail and just increase
   // the bufferedAmount property.
   result = websocket.Send(pp::Var(std::string("")));
@@ skipping 14 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_char));
   }
   ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[last_event].event_type);
   ASSERT_TRUE(events[last_event].was_clean);
 
   PASS();
 }