WebSocket Pepper API: add a unit test for the bufferedAmount property

ppapi/tests/test_websocket.cc

 // Copyright (c) 2011 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 @@
   "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;
+
 REGISTER_TEST_CASE(WebSocket);
 
 bool TestWebSocket::Init() {
   websocket_interface_ = static_cast<const PPB_WebSocket_Dev*>(
       pp::Module::Get()->GetBrowserInterface(PPB_WEBSOCKET_DEV_INTERFACE));
   var_interface_ = static_cast<const PPB_Var*>(
       pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
   arraybuffer_interface_ = static_cast<const PPB_VarArrayBuffer_Dev*>(
       pp::Module::Get()->GetBrowserInterface(
           PPB_VAR_ARRAY_BUFFER_DEV_INTERFACE));
@@ skipping 11 matching lines @@
   RUN_TEST_WITH_REFERENCE_CHECK(UninitializedPropertiesAccess, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(InvalidConnect, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(Protocols, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(GetURL, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(ValidConnect, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(InvalidClose, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(ValidClose, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(GetProtocol, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(TextSendReceive, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(BinarySendReceive, filter);
+  RUN_TEST_WITH_REFERENCE_CHECK(BufferedAmount, filter);
 
   RUN_TEST_WITH_REFERENCE_CHECK(CcInterfaces, filter);
 }
 
 PP_Var TestWebSocket::CreateVarString(const char* string) {
   return var_interface_->VarFromUtf8(string, strlen(string));
 }
 
 PP_Var TestWebSocket::CreateVarBinary(const uint8_t* data, uint32_t size) {
   PP_Var var = arraybuffer_interface_->Create(size);
@@ skipping 383 matching lines @@
   if (result == PP_OK_COMPLETIONPENDING)
     result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   ASSERT_TRUE(AreEqualWithBinary(received_message, data, len));
   ReleaseVar(received_message);
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
-// TODO(toyoshim): Add tests for GetBufferedAmount().
-// For now, the function doesn't work fine because update callback in WebKit is
-// not landed yet.
+std::string TestWebSocket::TestBufferedAmount() {
+  // Connect to test echo server.
+  int32_t connect_result;
+  PP_Resource ws = Connect(kEchoServerURL, &connect_result, NULL);
+  ASSERT_TRUE(ws);
+  ASSERT_EQ(PP_OK, connect_result);
 
-// TODO(toyoshim): Add tests for didReceiveMessageError().
+  // Prepare a large message unfitting internal buffer sizes.

[dmichael (off chromium), 2012/01/11 05:01:57]

"unfitting" -> "that is too big for the"

[Takashi Toyoshima, 2012/01/11 05:50:29]

Actually, the internal buffer size is 32K, so 8K frames is not too big, here.
I meant 8193 is not aligned with power of 2.
I'll comment as too big in the following magic number 262144 description.

+  char message[8194];
+  memset(message, 'x', 8193);
+  message[8193] = 0;
+  PP_Var message_var = CreateVarString(message);
 
-// TODO(toyoshim): Add other function tests.
+  uint64_t buffered_amount = 0;
+  int32_t result;
+  for (int i = 0; i < 100; i++) {
+    result = websocket_interface_->SendMessage(ws, message_var);
+    ASSERT_EQ(PP_OK, result);
+    buffered_amount = websocket_interface_->GetBufferedAmount(ws);
+    if (buffered_amount > 262144)

[dmichael (off chromium), 2012/01/11 05:01:57]

Can you document this magic number?

[Takashi Toyoshima, 2012/01/11 05:50:29]

Done.

+      break;
+  }
+
+  // Close connection.
+  PP_Var reason = CreateVarString("close in busy");

[dmichael (off chromium), 2012/01/11 05:01:57]

Did you mean "close while busy"?

[Takashi Toyoshima, 2012/01/11 05:50:29]

Yes.
I fixed it.

+  TestCompletionCallback callback(instance_->pp_instance());
+  result = websocket_interface_->Close(ws, kCloseCodeNormalClosure, reason,
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
+  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING_DEV,
+      websocket_interface_->GetReadyState(ws));
+
+  result = callback.WaitForResult();
+  ASSERT_EQ(PP_OK, result);
+  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED_DEV,
+      websocket_interface_->GetReadyState(ws));
+
+  uint64_t base_buffered_amount = websocket_interface_->GetBufferedAmount(ws);
+
+  // After connection closure, all sending requests fail and just increase
+  // the bufferedAmount property.
+  PP_Var empty_string = CreateVarString("");
+  result = websocket_interface_->SendMessage(ws, empty_string);
+  ASSERT_EQ(PP_ERROR_FAILED, result);
+  buffered_amount = websocket_interface_->GetBufferedAmount(ws);
+  ASSERT_EQ(base_buffered_amount + kMessageFrameOverhead, buffered_amount);
+  base_buffered_amount = buffered_amount;
+
+  result = websocket_interface_->SendMessage(ws, reason);
+  ASSERT_EQ(PP_ERROR_FAILED, result);
+  buffered_amount = websocket_interface_->GetBufferedAmount(ws);
+  uint64_t reason_frame_size = kMessageFrameOverhead + 13;

[dmichael (off chromium), 2012/01/11 05:01:57]

Please determine the size programmatically. E.g. above use:
std::string reason_str;
PP_Var reason = CreateVarString(reaon_str.c_str());
So you can use reason_str.length() here.

[Takashi Toyoshima, 2012/01/11 05:50:29]

That's nice.
I fixed.

+  ASSERT_EQ(base_buffered_amount + reason_frame_size, buffered_amount);
+
+  ReleaseVar(message_var);
+  ReleaseVar(reason);
+  ReleaseVar(empty_string);
+  core_interface_->ReleaseResource(ws);
+
+  PASS();
+}
 
 std::string TestWebSocket::TestCcInterfaces() {
   // C++ bindings is simple straightforward, then just verifies interfaces work
   // as a interface bridge fine.
   pp::WebSocket_Dev ws(instance_);
 
   // Check uninitialized properties access.
   ASSERT_EQ(0, ws.GetBufferedAmount());
   ASSERT_EQ(0, ws.GetCloseCode());
   ASSERT_TRUE(AreEqualWithString(ws.GetCloseReason().pp_var(), ""));
@@ skipping 53 matching lines @@
   ASSERT_EQ(kCloseCodeNormalClosure, 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_DEV, ws.GetReadyState());
   ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), kCloseServerURL));
 
   PASS();
 }