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

Add a unit test for the bufferedAmount property to verify its behaviors around
connection close.

BUG=87310
TEST=ui_test --gtest_filter='PPAPITest.WebSocket_BufferedAmount'

Review URL: http://codereview.chromium.org/8989047

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@117415 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 68 insertions, 5 deletions

diff --git a/ppapi/tests/test_websocket.cc b/ppapi/tests/test_websocket.cc
index 67c1ef0..da09d82 100644
--- a/ppapi/tests/test_websocket.cc
+++ b/ppapi/tests/test_websocket.cc
@@ -42,6 +42,10 @@ const char* const kInvalidURLs[] = {
 // 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() {
@@ -73,6 +77,7 @@ void TestWebSocket::RunTests(const std::string& 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);
 }
@@ -478,13 +483,70 @@ std::string TestWebSocket::TestBinarySendReceive() {
   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);
+
+  // Prepare a large message that is not aligned with the internal buffer
+  // sizes.
+  char message[8194];
+  memset(message, 'x', 8193);
+  message[8193] = 0;
+  PP_Var message_var = CreateVarString(message);
+
+  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);
+    // 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,
+      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);
 
-// TODO(toyoshim): Add tests for didReceiveMessageError().
+  // 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;
 
-// TODO(toyoshim): Add other function tests.
+  result = websocket_interface_->SendMessage(ws, reason);
+  ASSERT_EQ(PP_ERROR_FAILED, result);
+  buffered_amount = websocket_interface_->GetBufferedAmount(ws);
+  uint64_t reason_frame_size = kMessageFrameOverhead + reason_str.length();
+  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
diff --git a/ppapi/tests/test_websocket.h b/ppapi/tests/test_websocket.h
index a973ead..81773be 100644
--- a/ppapi/tests/test_websocket.h
+++ b/ppapi/tests/test_websocket.h
@@ -43,6 +43,7 @@ class TestWebSocket : public TestCase {
   std::string TestGetProtocol();
   std::string TestTextSendReceive();
   std::string TestBinarySendReceive();
+  std::string TestBufferedAmount();
 
   std::string TestCcInterfaces();