PepperWebSocketHost should not call blink::WebSocket APIs after closed.

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 206 matching lines @@
   RUN_TEST_WITH_REFERENCE_CHECK(BinarySendReceive, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(StressedSendReceive, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(BufferedAmount, filter);
   // PP_Resource for WebSocket may be released later because of an internal
   // reference for asynchronous IPC handling. So, suppress reference check on
   // the following AbortCallsWithCallback test.
   RUN_TEST(AbortCallsWithCallback, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(AbortSendMessageCall, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(AbortCloseCall, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(AbortReceiveMessageCall, filter);
+  RUN_TEST_WITH_REFERENCE_CHECK(ClosedFromServerWhileSending, filter);
 
   RUN_TEST_WITH_REFERENCE_CHECK(CcInterfaces, filter);
 
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityInvalidConnect, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityProtocols, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityGetURL, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityValidConnect, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityInvalidClose, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityValidClose, filter);
   RUN_TEST_WITH_REFERENCE_CHECK(UtilityGetProtocol, filter);
@@ skipping 914 matching lines @@
       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
     }
   }
 
   ReleaseVar(large_var);
   ReleaseVar(text_var);
 
   PASS();
 }
 
+std::string TestWebSocket::TestClosedFromServerWhileSending() {
+  // Connect to test echo server.
+  const pp::Var protocols[] = { pp::Var() };
+  TestWebSocketAPI websocket(instance_);
+  int32_t result =
+      websocket.Connect(pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
+  websocket.WaitForConnected();
+
+  result = websocket.Send(pp::Var("hello"));
+  ASSERT_EQ(PP_OK, result);
+  result = websocket.Send(pp::Var("Goodbye"));
+  // We send many messages so that PepperWebSocketHost::SendText is called
+  // after PepperWebSocketHost::didClose is called.
+  // Note: We must not wait for CLOSED event here because
+  // WebSocketResource::SendMessage doesn't call PepperWebSocketHost::SendText
+  // when its internal state is CLOSING or CLOSED. We want to test if the
+  // pepper WebSocket works well when WebSocketResource is OPEN and
+  // PepperWebSocketHost is CLOSED.
+  for (size_t i = 0; i < 10000; ++i) {

[Adam Rice, 2014/08/27 05:58:57]

Nit: this test could be flaky. However, I can't see a good way to de-flake it.

[yhirano, 2014/08/27 07:06:32]

me neither.

+    result = websocket.Send(pp::Var(""));
+    ASSERT_EQ(PP_OK, result);
+  }
+
+  PASS();
+}
+
 std::string TestWebSocket::TestCcInterfaces() {
   // C++ bindings is simple straightforward, then just verifies interfaces work
   // as a interface bridge fine.
   pp::WebSocket ws(instance_);
 
   // Check uninitialized properties access.
   ASSERT_EQ(0, ws.GetBufferedAmount());
   ASSERT_EQ(0, ws.GetCloseCode());
   ASSERT_TRUE(AreEqualWithString(ws.GetCloseReason().pp_var(), std::string()));
   ASSERT_FALSE(ws.GetCloseWasClean());
@@ skipping 408 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();
 }