Home | History | Annotate | Download | only in tests 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ppapi/tests/test_websocket.h"
      6 
      7 #include <stdio.h>
      8 #include <string.h>
      9 
     10 #include <algorithm>
     11 #include <memory>
     12 #include <string>
     13 #include <vector>
     14 
     15 #include "ppapi/c/pp_bool.h"
     16 #include "ppapi/c/pp_completion_callback.h"
     17 #include "ppapi/c/pp_errors.h"
     18 #include "ppapi/c/pp_instance.h"
     19 #include "ppapi/c/pp_resource.h"
     20 #include "ppapi/c/pp_var.h"
     21 #include "ppapi/c/ppb_core.h"
     22 #include "ppapi/c/ppb_var.h"
     23 #include "ppapi/c/ppb_var_array_buffer.h"
     24 #include "ppapi/c/ppb_websocket.h"
     25 #include "ppapi/c/private/ppb_testing_private.h"
     26 #include "ppapi/cpp/instance.h"
     27 #include "ppapi/cpp/module.h"
     28 #include "ppapi/cpp/var_array_buffer.h"
     29 #include "ppapi/cpp/websocket.h"
     30 #include "ppapi/tests/test_utils.h"
     31 #include "ppapi/tests/testing_instance.h"
     32 #include "ppapi/utility/websocket/websocket_api.h"
     33 
     34 // net::SpawnedTestServer serves WebSocket service for testing.
     35 // Following URLs are handled by pywebsocket handlers in
     36 // net/data/websocket/*_wsh.py.
     37 const char kEchoServerURL[] = "echo-with-no-extension";
     38 const char kCloseServerURL[] = "close";
     39 const char kCloseWithCodeAndReasonServerURL[] = "close-code-and-reason";
     40 const char kProtocolTestServerURL[] = "protocol-test?protocol=";
     41 
     42 const char* const kInvalidURLs[] = {
     43   "http://www.google.com/invalid_scheme",
     44   "ws://www.google.com/invalid#fragment",
     45   "ws://www.google.com:65535/invalid_port",
     46   NULL
     47 };
     48 
     49 // Internal packet sizes.
     50 const uint64_t kMessageFrameOverhead = 6;
     51 
     52 namespace {
     53 
     54 struct WebSocketEvent {
     55   enum EventType {
     56     EVENT_OPEN,
     57     EVENT_MESSAGE,
     58     EVENT_ERROR,
     59     EVENT_CLOSE
     60   };
     61 
     62   WebSocketEvent(EventType type,
     63                  bool was_clean,
     64                  uint16_t close_code,
     65                  const pp::Var& var)
     66       : event_type(type),
     67         was_clean(was_clean),
     68         close_code(close_code),
     69         var(var) {
     70   }
     71   EventType event_type;
     72   bool was_clean;
     73   uint16_t close_code;
     74   pp::Var var;
     75 };
     76 
     77 class ReleaseResourceDelegate : public TestCompletionCallback::Delegate {
     78  public:
     79   explicit ReleaseResourceDelegate(const PPB_Core* core_interface,
     80                                    PP_Resource resource)
     81       : core_interface_(core_interface),
     82         resource_(resource) {
     83   }
     84 
     85   // TestCompletionCallback::Delegate implementation.
     86   virtual void OnCallback(void* user_data, int32_t result) {
     87     if (resource_)
     88       core_interface_->ReleaseResource(resource_);
     89   }
     90 
     91  private:
     92   const PPB_Core* core_interface_;
     93   PP_Resource resource_;
     94 };
     95 
     96 class TestWebSocketAPI : public pp::WebSocketAPI {
     97  public:
     98   explicit TestWebSocketAPI(pp::Instance* instance)
     99       : pp::WebSocketAPI(instance),
    100         connected_(false),
    101         received_(false),
    102         closed_(false),
    103         wait_for_connected_(false),
    104         wait_for_received_(false),
    105         wait_for_closed_(false),
    106         instance_(instance->pp_instance()) {
    107   }
    108 
    109   virtual void WebSocketDidOpen() {
    110     events_.push_back(
    111         WebSocketEvent(WebSocketEvent::EVENT_OPEN, true, 0U, pp::Var()));
    112     connected_ = true;
    113     if (wait_for_connected_) {
    114       GetTestingInterface()->QuitMessageLoop(instance_);
    115       wait_for_connected_ = false;
    116     }
    117   }
    118 
    119   virtual void WebSocketDidClose(
    120       bool was_clean, uint16_t code, const pp::Var& reason) {
    121     events_.push_back(
    122         WebSocketEvent(WebSocketEvent::EVENT_CLOSE, was_clean, code, reason));
    123     connected_ = true;
    124     closed_ = true;
    125     if (wait_for_connected_ || wait_for_closed_) {
    126       GetTestingInterface()->QuitMessageLoop(instance_);
    127       wait_for_connected_ = false;
    128       wait_for_closed_ = false;
    129     }
    130   }
    131 
    132   virtual void HandleWebSocketMessage(const pp::Var &message) {
    133     events_.push_back(
    134         WebSocketEvent(WebSocketEvent::EVENT_MESSAGE, true, 0U, message));
    135     received_ = true;
    136     if (wait_for_received_) {
    137       GetTestingInterface()->QuitMessageLoop(instance_);
    138       wait_for_received_ = false;
    139       received_ = false;
    140     }
    141   }
    142 
    143   virtual void HandleWebSocketError() {
    144     events_.push_back(
    145         WebSocketEvent(WebSocketEvent::EVENT_ERROR, true, 0U, pp::Var()));
    146   }
    147 
    148   void WaitForConnected() {
    149     if (!connected_) {
    150       wait_for_connected_ = true;
    151       GetTestingInterface()->RunMessageLoop(instance_);
    152     }
    153   }
    154 
    155   void WaitForReceived() {
    156     if (!received_) {
    157       wait_for_received_ = true;
    158       GetTestingInterface()->RunMessageLoop(instance_);
    159     }
    160   }
    161 
    162   void WaitForClosed() {
    163     if (!closed_) {
    164       wait_for_closed_ = true;
    165       GetTestingInterface()->RunMessageLoop(instance_);
    166     }
    167   }
    168 
    169   const std::vector<WebSocketEvent>& GetSeenEvents() const {
    170     return events_;
    171   }
    172 
    173  private:
    174   std::vector<WebSocketEvent> events_;
    175   bool connected_;
    176   bool received_;
    177   bool closed_;
    178   bool wait_for_connected_;
    179   bool wait_for_received_;
    180   bool wait_for_closed_;
    181   PP_Instance instance_;
    182 };
    183 
    184 }  // namespace
    185 
    186 REGISTER_TEST_CASE(WebSocket);
    187 
    188 bool TestWebSocket::Init() {
    189   websocket_interface_ = static_cast<const PPB_WebSocket*>(
    190       pp::Module::Get()->GetBrowserInterface(PPB_WEBSOCKET_INTERFACE));
    191   var_interface_ = static_cast<const PPB_Var*>(
    192       pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
    193   arraybuffer_interface_ = static_cast<const PPB_VarArrayBuffer*>(
    194       pp::Module::Get()->GetBrowserInterface(
    195           PPB_VAR_ARRAY_BUFFER_INTERFACE));
    196   core_interface_ = static_cast<const PPB_Core*>(
    197       pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
    198   if (!websocket_interface_ || !var_interface_ || !arraybuffer_interface_ ||
    199       !core_interface_)
    200     return false;
    201 
    202   return CheckTestingInterface();
    203 }
    204 
    205 void TestWebSocket::RunTests(const std::string& filter) {
    206   RUN_TEST_WITH_REFERENCE_CHECK(IsWebSocket, filter);
    207   RUN_TEST_WITH_REFERENCE_CHECK(UninitializedPropertiesAccess, filter);
    208   RUN_TEST_WITH_REFERENCE_CHECK(InvalidConnect, filter);
    209   RUN_TEST_WITH_REFERENCE_CHECK(Protocols, filter);
    210   RUN_TEST_WITH_REFERENCE_CHECK(GetURL, filter);
    211   RUN_TEST_WITH_REFERENCE_CHECK(ValidConnect, filter);
    212   RUN_TEST_WITH_REFERENCE_CHECK(InvalidClose, filter);
    213   RUN_TEST_WITH_REFERENCE_CHECK(ValidClose, filter);
    214   RUN_TEST_WITH_REFERENCE_CHECK(GetProtocol, filter);
    215   RUN_TEST_WITH_REFERENCE_CHECK(TextSendReceive, filter);
    216   RUN_TEST_BACKGROUND(TestWebSocket, TextSendReceiveTwice, filter);
    217   RUN_TEST_WITH_REFERENCE_CHECK(BinarySendReceive, filter);
    218   RUN_TEST_WITH_REFERENCE_CHECK(StressedSendReceive, filter);
    219   RUN_TEST_WITH_REFERENCE_CHECK(BufferedAmount, filter);
    220   // PP_Resource for WebSocket may be released later because of an internal
    221   // reference for asynchronous IPC handling. So, suppress reference check on
    222   // the following AbortCallsWithCallback test.
    223   RUN_TEST(AbortCallsWithCallback, filter);
    224   RUN_TEST_WITH_REFERENCE_CHECK(AbortSendMessageCall, filter);
    225   RUN_TEST_WITH_REFERENCE_CHECK(AbortCloseCall, filter);
    226   RUN_TEST_WITH_REFERENCE_CHECK(AbortReceiveMessageCall, filter);
    227   RUN_TEST_WITH_REFERENCE_CHECK(ClosedFromServerWhileSending, filter);
    228 
    229   RUN_TEST_WITH_REFERENCE_CHECK(CcInterfaces, filter);
    230 
    231   RUN_TEST_WITH_REFERENCE_CHECK(UtilityInvalidConnect, filter);
    232   RUN_TEST_WITH_REFERENCE_CHECK(UtilityProtocols, filter);
    233   RUN_TEST_WITH_REFERENCE_CHECK(UtilityGetURL, filter);
    234   RUN_TEST_WITH_REFERENCE_CHECK(UtilityValidConnect, filter);
    235   RUN_TEST_WITH_REFERENCE_CHECK(UtilityInvalidClose, filter);
    236   RUN_TEST_WITH_REFERENCE_CHECK(UtilityValidClose, filter);
    237   RUN_TEST_WITH_REFERENCE_CHECK(UtilityGetProtocol, filter);
    238   RUN_TEST_WITH_REFERENCE_CHECK(UtilityTextSendReceive, filter);
    239   RUN_TEST_WITH_REFERENCE_CHECK(UtilityBinarySendReceive, filter);
    240   RUN_TEST_WITH_REFERENCE_CHECK(UtilityBufferedAmount, filter);
    241 }
    242 
    243 std::string TestWebSocket::GetFullURL(const char* url) {
    244   std::string rv = "ws://";
    245   // Some WebSocket tests don't start the server so there'll be no host and
    246   // port.
    247   if (instance_->websocket_host().empty())
    248     rv += "127.0.0.1";
    249   else
    250     rv += instance_->websocket_host();
    251   if (instance_->websocket_port() != -1) {
    252     char buffer[10];
    253     sprintf(buffer, ":%d", instance_->websocket_port());
    254     rv += std::string(buffer);
    255   }
    256   rv += "/";
    257   rv += url;
    258   return rv;
    259 }
    260 
    261 PP_Var TestWebSocket::CreateVarString(const std::string& string) {
    262   return var_interface_->VarFromUtf8(string.c_str(), string.size());
    263 }
    264 
    265 PP_Var TestWebSocket::CreateVarBinary(const std::vector<uint8_t>& binary) {
    266   PP_Var var = arraybuffer_interface_->Create(binary.size());
    267   uint8_t* var_data = static_cast<uint8_t*>(arraybuffer_interface_->Map(var));
    268   std::copy(binary.begin(), binary.end(), var_data);
    269   return var;
    270 }
    271 
    272 void TestWebSocket::ReleaseVar(const PP_Var& var) {
    273   var_interface_->Release(var);
    274 }
    275 
    276 bool TestWebSocket::AreEqualWithString(const PP_Var& var,
    277                                        const std::string& string) {
    278   if (var.type != PP_VARTYPE_STRING)
    279     return false;
    280   uint32_t utf8_length;
    281   const char* utf8 = var_interface_->VarToUtf8(var, &utf8_length);
    282   if (utf8_length != string.size())
    283     return false;
    284   if (string.compare(utf8))
    285     return false;
    286   return true;
    287 }
    288 
    289 bool TestWebSocket::AreEqualWithBinary(const PP_Var& var,
    290                                        const std::vector<uint8_t>& binary) {
    291   uint32_t buffer_size = 0;
    292   PP_Bool success = arraybuffer_interface_->ByteLength(var, &buffer_size);
    293   if (!success || buffer_size != binary.size())
    294     return false;
    295   if (!std::equal(binary.begin(), binary.end(),
    296       static_cast<uint8_t*>(arraybuffer_interface_->Map(var))))
    297     return false;
    298   return true;
    299 }
    300 
    301 PP_Resource TestWebSocket::Connect(const std::string& url,
    302                                    int32_t* result,
    303                                    const std::string& protocol) {
    304   PP_Var protocols[] = { PP_MakeUndefined() };
    305   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    306   if (!ws)
    307     return 0;
    308   PP_Var url_var = CreateVarString(url);
    309   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    310   uint32_t protocol_count = 0U;
    311   if (protocol.size()) {
    312     protocols[0] = CreateVarString(protocol);
    313     protocol_count = 1U;
    314   }
    315   callback.WaitForResult(websocket_interface_->Connect(
    316       ws, url_var, protocols, protocol_count,
    317       callback.GetCallback().pp_completion_callback()));
    318   ReleaseVar(url_var);
    319   if (protocol.size())
    320     ReleaseVar(protocols[0]);
    321   *result = callback.result();
    322   return ws;
    323 }
    324 
    325 void TestWebSocket::Send(int32_t /* result */, PP_Resource ws,
    326                          const std::string& message) {
    327   PP_Var message_var = CreateVarString(message);
    328   websocket_interface_->SendMessage(ws, message_var);
    329   ReleaseVar(message_var);
    330 }
    331 
    332 std::string TestWebSocket::TestIsWebSocket() {
    333   // Test that a NULL resource isn't a websocket.
    334   pp::Resource null_resource;
    335   PP_Bool result =
    336       websocket_interface_->IsWebSocket(null_resource.pp_resource());
    337   ASSERT_FALSE(result);
    338 
    339   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    340   ASSERT_TRUE(ws);
    341 
    342   result = websocket_interface_->IsWebSocket(ws);
    343   ASSERT_TRUE(result);
    344 
    345   core_interface_->ReleaseResource(ws);
    346 
    347   PASS();
    348 }
    349 
    350 std::string TestWebSocket::TestUninitializedPropertiesAccess() {
    351   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    352   ASSERT_TRUE(ws);
    353 
    354   uint64_t bufferedAmount = websocket_interface_->GetBufferedAmount(ws);
    355   ASSERT_EQ(0U, bufferedAmount);
    356 
    357   uint16_t close_code = websocket_interface_->GetCloseCode(ws);
    358   ASSERT_EQ(0U, close_code);
    359 
    360   PP_Var close_reason = websocket_interface_->GetCloseReason(ws);
    361   ASSERT_TRUE(AreEqualWithString(close_reason, std::string()));
    362   ReleaseVar(close_reason);
    363 
    364   PP_Bool close_was_clean = websocket_interface_->GetCloseWasClean(ws);
    365   ASSERT_EQ(PP_FALSE, close_was_clean);
    366 
    367   PP_Var extensions = websocket_interface_->GetExtensions(ws);
    368   ASSERT_TRUE(AreEqualWithString(extensions, std::string()));
    369   ReleaseVar(extensions);
    370 
    371   PP_Var protocol = websocket_interface_->GetProtocol(ws);
    372   ASSERT_TRUE(AreEqualWithString(protocol, std::string()));
    373   ReleaseVar(protocol);
    374 
    375   PP_WebSocketReadyState ready_state =
    376       websocket_interface_->GetReadyState(ws);
    377   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ready_state);
    378 
    379   PP_Var url = websocket_interface_->GetURL(ws);
    380   ASSERT_TRUE(AreEqualWithString(url, std::string()));
    381   ReleaseVar(url);
    382 
    383   core_interface_->ReleaseResource(ws);
    384 
    385   PASS();
    386 }
    387 
    388 std::string TestWebSocket::TestInvalidConnect() {
    389   PP_Var protocols[] = { PP_MakeUndefined() };
    390 
    391   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    392   ASSERT_TRUE(ws);
    393 
    394   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    395   callback.WaitForResult(websocket_interface_->Connect(
    396       ws, PP_MakeUndefined(), protocols, 1U,
    397       callback.GetCallback().pp_completion_callback()));
    398   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
    399 
    400   callback.WaitForResult(websocket_interface_->Connect(
    401       ws, PP_MakeUndefined(), protocols, 1U,
    402       callback.GetCallback().pp_completion_callback()));
    403   ASSERT_EQ(PP_ERROR_INPROGRESS, callback.result());
    404 
    405   core_interface_->ReleaseResource(ws);
    406 
    407   for (int i = 0; kInvalidURLs[i]; ++i) {
    408     int32_t result;
    409     ws = Connect(kInvalidURLs[i], &result, std::string());
    410     ASSERT_TRUE(ws);
    411     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
    412 
    413     core_interface_->ReleaseResource(ws);
    414   }
    415 
    416   PASS();
    417 }
    418 
    419 std::string TestWebSocket::TestProtocols() {
    420   PP_Var url = CreateVarString(GetFullURL(kEchoServerURL).c_str());
    421   PP_Var bad_protocols[] = {
    422     CreateVarString("x-test"),
    423     CreateVarString("x-test")
    424   };
    425   PP_Var good_protocols[] = {
    426     CreateVarString("x-test"),
    427     CreateVarString("x-yatest")
    428   };
    429 
    430   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    431   ASSERT_TRUE(ws);
    432   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    433   callback.WaitForResult(websocket_interface_->Connect(
    434       ws, url, bad_protocols, 2U,
    435       callback.GetCallback().pp_completion_callback()));
    436   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
    437   core_interface_->ReleaseResource(ws);
    438 
    439   ws = websocket_interface_->Create(instance_->pp_instance());
    440   ASSERT_TRUE(ws);
    441   int32_t result = websocket_interface_->Connect(
    442       ws, url, good_protocols, 2U, PP_BlockUntilComplete());
    443   ASSERT_EQ(PP_ERROR_BLOCKS_MAIN_THREAD, result);
    444   core_interface_->ReleaseResource(ws);
    445 
    446   ReleaseVar(url);
    447   for (int i = 0; i < 2; ++i) {
    448     ReleaseVar(bad_protocols[i]);
    449     ReleaseVar(good_protocols[i]);
    450   }
    451   core_interface_->ReleaseResource(ws);
    452 
    453   PASS();
    454 }
    455 
    456 std::string TestWebSocket::TestGetURL() {
    457   for (int i = 0; kInvalidURLs[i]; ++i) {
    458     int32_t result;
    459     PP_Resource ws = Connect(kInvalidURLs[i], &result, std::string());
    460     ASSERT_TRUE(ws);
    461     PP_Var url = websocket_interface_->GetURL(ws);
    462     ASSERT_TRUE(AreEqualWithString(url, kInvalidURLs[i]));
    463     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
    464 
    465     ReleaseVar(url);
    466     core_interface_->ReleaseResource(ws);
    467   }
    468 
    469   PASS();
    470 }
    471 
    472 std::string TestWebSocket::TestValidConnect() {
    473   int32_t result;
    474   PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    475   ASSERT_TRUE(ws);
    476   ASSERT_EQ(PP_OK, result);
    477   PP_Var extensions = websocket_interface_->GetExtensions(ws);
    478   ASSERT_TRUE(AreEqualWithString(extensions, std::string()));
    479   core_interface_->ReleaseResource(ws);
    480   ReleaseVar(extensions);
    481 
    482   PASS();
    483 }
    484 
    485 std::string TestWebSocket::TestInvalidClose() {
    486   PP_Var reason = CreateVarString("close for test");
    487   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    488   TestCompletionCallback async_callback(instance_->pp_instance(), PP_REQUIRED);
    489 
    490   // Close before connect.
    491   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    492   callback.WaitForResult(websocket_interface_->Close(
    493       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    494       callback.GetCallback().pp_completion_callback()));
    495   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
    496   core_interface_->ReleaseResource(ws);
    497 
    498   // Close with bad arguments.
    499   int32_t result;
    500   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    501   ASSERT_TRUE(ws);
    502   ASSERT_EQ(PP_OK, result);
    503   callback.WaitForResult(websocket_interface_->Close(
    504       ws, 1U, reason, callback.GetCallback().pp_completion_callback()));
    505   ASSERT_EQ(PP_ERROR_NOACCESS, callback.result());
    506   core_interface_->ReleaseResource(ws);
    507 
    508   // Close with PP_VARTYPE_NULL.
    509   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    510   ASSERT_TRUE(ws);
    511   ASSERT_EQ(PP_OK, result);
    512   callback.WaitForResult(websocket_interface_->Close(
    513       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeNull(),
    514       callback.GetCallback().pp_completion_callback()));
    515   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
    516   core_interface_->ReleaseResource(ws);
    517 
    518   // Close with PP_VARTYPE_NULL and ongoing receive message.
    519   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    520   ASSERT_TRUE(ws);
    521   ASSERT_EQ(PP_OK, result);
    522   PP_Var receive_message_var;
    523   result = websocket_interface_->ReceiveMessage(
    524       ws, &receive_message_var,
    525       async_callback.GetCallback().pp_completion_callback());
    526   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    527   callback.WaitForResult(websocket_interface_->Close(
    528       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeNull(),
    529       callback.GetCallback().pp_completion_callback()));
    530   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
    531   const char* send_message = "hi";
    532   PP_Var send_message_var = CreateVarString(send_message);
    533   result = websocket_interface_->SendMessage(ws, send_message_var);
    534   ReleaseVar(send_message_var);
    535   ASSERT_EQ(PP_OK, result);
    536   async_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    537   ASSERT_EQ(PP_OK, async_callback.result());
    538   ASSERT_TRUE(AreEqualWithString(receive_message_var, send_message));
    539   ReleaseVar(receive_message_var);
    540   core_interface_->ReleaseResource(ws);
    541 
    542   // Close twice.
    543   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    544   ASSERT_TRUE(ws);
    545   ASSERT_EQ(PP_OK, result);
    546   result = websocket_interface_->Close(
    547       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    548       async_callback.GetCallback().pp_completion_callback());
    549   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    550   // Call another Close() before previous one is in progress.
    551   result = websocket_interface_->Close(
    552       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    553       callback.GetCallback().pp_completion_callback());
    554   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
    555   async_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    556   ASSERT_EQ(PP_OK, async_callback.result());
    557   // Call another Close() after previous one is completed.
    558   // This Close() must do nothing and reports no error.
    559   callback.WaitForResult(websocket_interface_->Close(
    560       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    561       callback.GetCallback().pp_completion_callback()));
    562   ASSERT_EQ(PP_OK, callback.result());
    563   core_interface_->ReleaseResource(ws);
    564 
    565   ReleaseVar(reason);
    566 
    567   PASS();
    568 }
    569 
    570 // TODO(tyoshino): Consider splitting this test into smaller ones.
    571 // http://crbug.com/397035
    572 std::string TestWebSocket::TestValidClose() {
    573   PP_Var reason = CreateVarString("close for test");
    574   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    575   TestCompletionCallback another_callback(
    576       instance_->pp_instance(), callback_type());
    577 
    578   // Close.
    579   int32_t result;
    580   PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    581   ASSERT_TRUE(ws);
    582   ASSERT_EQ(PP_OK, result);
    583   callback.WaitForResult(websocket_interface_->Close(
    584       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    585       callback.GetCallback().pp_completion_callback()));
    586   CHECK_CALLBACK_BEHAVIOR(callback);
    587   ASSERT_EQ(PP_OK, callback.result());
    588   core_interface_->ReleaseResource(ws);
    589 
    590   // Close without code and reason.
    591   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    592   ASSERT_TRUE(ws);
    593   ASSERT_EQ(PP_OK, result);
    594   callback.WaitForResult(websocket_interface_->Close(
    595       ws, PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED, reason,
    596       callback.GetCallback().pp_completion_callback()));
    597   CHECK_CALLBACK_BEHAVIOR(callback);
    598   ASSERT_EQ(PP_OK, callback.result());
    599   core_interface_->ReleaseResource(ws);
    600 
    601   // Close with PP_VARTYPE_UNDEFINED.
    602   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    603   ASSERT_TRUE(ws);
    604   ASSERT_EQ(PP_OK, result);
    605   callback.WaitForResult(websocket_interface_->Close(
    606       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
    607       callback.GetCallback().pp_completion_callback()));
    608   CHECK_CALLBACK_BEHAVIOR(callback);
    609   ASSERT_EQ(PP_OK, callback.result());
    610   core_interface_->ReleaseResource(ws);
    611 
    612   // Close in CONNECTING state.
    613   // The ongoing Connect() fails with PP_ERROR_ABORTED, then the Close()
    614   // completes successfully.
    615   ws = websocket_interface_->Create(instance_->pp_instance());
    616   PP_Var url = CreateVarString(GetFullURL(kEchoServerURL).c_str());
    617   PP_Var protocols[] = { PP_MakeUndefined() };
    618   result = websocket_interface_->Connect(
    619       ws, url, protocols, 0U, callback.GetCallback().pp_completion_callback());
    620   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    621   result = websocket_interface_->Close(
    622       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    623       another_callback.GetCallback().pp_completion_callback());
    624   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    625   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    626   ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
    627   another_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    628   ASSERT_EQ(PP_OK, another_callback.result());
    629   core_interface_->ReleaseResource(ws);
    630   ReleaseVar(url);
    631 
    632   // Close while already closing.
    633   // The first Close will succeed, and the second one will synchronously fail
    634   // with PP_ERROR_INPROGRESS.
    635   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    636   ASSERT_TRUE(ws);
    637   ASSERT_EQ(PP_OK, result);
    638   result = websocket_interface_->Close(
    639       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    640       callback.GetCallback().pp_completion_callback());
    641   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    642   result = websocket_interface_->Close(
    643       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    644       another_callback.GetCallback().pp_completion_callback());
    645   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
    646   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    647   ASSERT_EQ(PP_OK, callback.result());
    648   core_interface_->ReleaseResource(ws);
    649 
    650   // Close with ongoing ReceiveMessage.
    651   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    652   ASSERT_TRUE(ws);
    653   ASSERT_EQ(PP_OK, result);
    654   PP_Var receive_message_var;
    655   result = websocket_interface_->ReceiveMessage(
    656       ws, &receive_message_var,
    657       callback.GetCallback().pp_completion_callback());
    658   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    659   result = websocket_interface_->Close(
    660       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    661       another_callback.GetCallback().pp_completion_callback());
    662   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    663   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    664   ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
    665   another_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    666   ASSERT_EQ(PP_OK, another_callback.result());
    667   core_interface_->ReleaseResource(ws);
    668 
    669   // Close with PP_VARTYPE_UNDEFINED for reason and ongoing ReceiveMessage.
    670   ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
    671   ASSERT_TRUE(ws);
    672   ASSERT_EQ(PP_OK, result);
    673   result = websocket_interface_->ReceiveMessage(
    674       ws, &receive_message_var,
    675       callback.GetCallback().pp_completion_callback());
    676   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    677   result = websocket_interface_->Close(
    678       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
    679       another_callback.GetCallback().pp_completion_callback());
    680   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    681   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    682   ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
    683   another_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
    684   ASSERT_EQ(PP_OK, another_callback.result());
    685   core_interface_->ReleaseResource(ws);
    686 
    687   // Server initiated closing handshake.
    688   ws = Connect(
    689       GetFullURL(kCloseWithCodeAndReasonServerURL), &result, std::string());
    690   ASSERT_TRUE(ws);
    691   ASSERT_EQ(PP_OK, result);
    692   // Text messsage "1000 bye" requests the server to initiate closing handshake
    693   // with code being 1000 and reason being "bye".
    694   PP_Var close_request_var = CreateVarString("1000 bye");
    695   result = websocket_interface_->SendMessage(ws, close_request_var);
    696   ReleaseVar(close_request_var);
    697   callback.WaitForResult(websocket_interface_->ReceiveMessage(
    698       ws, &receive_message_var,
    699       callback.GetCallback().pp_completion_callback()));
    700   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
    701   core_interface_->ReleaseResource(ws);
    702 
    703   ReleaseVar(reason);
    704 
    705   PASS();
    706 }
    707 
    708 std::string TestWebSocket::TestGetProtocol() {
    709   const char* expected_protocols[] = {
    710     "x-chat",
    711     "hoehoe",
    712     NULL
    713   };
    714   for (int i = 0; expected_protocols[i]; ++i) {
    715     std::string url(GetFullURL(kProtocolTestServerURL));
    716     url += expected_protocols[i];
    717     int32_t result;
    718     PP_Resource ws = Connect(url.c_str(), &result, expected_protocols[i]);
    719     ASSERT_TRUE(ws);
    720     ASSERT_EQ(PP_OK, result);
    721 
    722     PP_Var protocol = websocket_interface_->GetProtocol(ws);
    723     ASSERT_TRUE(AreEqualWithString(protocol, expected_protocols[i]));
    724 
    725     ReleaseVar(protocol);
    726     core_interface_->ReleaseResource(ws);
    727   }
    728 
    729   PASS();
    730 }
    731 
    732 std::string TestWebSocket::TestTextSendReceive() {
    733   // Connect to test echo server.
    734   int32_t connect_result;
    735   PP_Resource ws =
    736       Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
    737   ASSERT_TRUE(ws);
    738   ASSERT_EQ(PP_OK, connect_result);
    739 
    740   // Send 'hello pepper' text message.
    741   const char* message = "hello pepper";
    742   PP_Var message_var = CreateVarString(message);
    743   int32_t result = websocket_interface_->SendMessage(ws, message_var);
    744   ReleaseVar(message_var);
    745   ASSERT_EQ(PP_OK, result);
    746 
    747   // Receive echoed 'hello pepper'.
    748   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    749   PP_Var received_message;
    750   callback.WaitForResult(websocket_interface_->ReceiveMessage(
    751       ws, &received_message, callback.GetCallback().pp_completion_callback()));
    752   ASSERT_EQ(PP_OK, callback.result());
    753   ASSERT_TRUE(AreEqualWithString(received_message, message));
    754   ReleaseVar(received_message);
    755   core_interface_->ReleaseResource(ws);
    756 
    757   PASS();
    758 }
    759 
    760 // Run as a BACKGROUND test.
    761 std::string TestWebSocket::TestTextSendReceiveTwice() {
    762   // Connect to test echo server.
    763   int32_t connect_result;
    764   PP_Resource ws =
    765       Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
    766   ASSERT_TRUE(ws);
    767   ASSERT_EQ(PP_OK, connect_result);
    768   pp::MessageLoop message_loop = pp::MessageLoop::GetCurrent();
    769   pp::CompletionCallbackFactory<TestWebSocket> factory(this);
    770 
    771   message_loop.PostWork(factory.NewCallback(&TestWebSocket::Send,
    772                                             ws, std::string("hello")));
    773   // When the server receives 'Goodbye', it closes the session.
    774   message_loop.PostWork(factory.NewCallback(&TestWebSocket::Send,
    775                                             ws, std::string("Goodbye")));
    776   message_loop.PostQuit(false);
    777   message_loop.Run();
    778 
    779   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    780   PP_Var received_message;
    781   int32_t result = websocket_interface_->ReceiveMessage(
    782       ws, &received_message, callback.GetCallback().pp_completion_callback());
    783   ASSERT_EQ(PP_OK, result);
    784   // Since we don't run the message loop, the callback will stay
    785   // "pending and scheduled to run" state.
    786 
    787   // Waiting for the connection close which will be done by the server.
    788   while (true) {
    789     PP_WebSocketReadyState ready_state =
    790         websocket_interface_->GetReadyState(ws);
    791     if (ready_state != PP_WEBSOCKETREADYSTATE_CONNECTING &&
    792         ready_state != PP_WEBSOCKETREADYSTATE_OPEN) {
    793       break;
    794     }
    795     PlatformSleep(100);  // 100ms
    796   }
    797 
    798   // Cleanup the message loop
    799   message_loop.PostQuit(false);
    800   message_loop.Run();
    801 
    802   ASSERT_EQ(PP_OK, callback.result());
    803   ASSERT_TRUE(AreEqualWithString(received_message, "hello"));
    804   ReleaseVar(received_message);
    805   core_interface_->ReleaseResource(ws);
    806   PASS();
    807 }
    808 
    809 std::string TestWebSocket::TestBinarySendReceive() {
    810   // Connect to test echo server.
    811   int32_t connect_result;
    812   PP_Resource ws =
    813       Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
    814   ASSERT_TRUE(ws);
    815   ASSERT_EQ(PP_OK, connect_result);
    816 
    817   // Send binary message.
    818   std::vector<uint8_t> binary(256);
    819   for (uint32_t i = 0; i < binary.size(); ++i)
    820     binary[i] = i;
    821   PP_Var message_var = CreateVarBinary(binary);
    822   int32_t result = websocket_interface_->SendMessage(ws, message_var);
    823   ReleaseVar(message_var);
    824   ASSERT_EQ(PP_OK, result);
    825 
    826   // Receive echoed binary.
    827   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    828   PP_Var received_message;
    829   callback.WaitForResult(websocket_interface_->ReceiveMessage(
    830       ws, &received_message, callback.GetCallback().pp_completion_callback()));
    831   ASSERT_EQ(PP_OK, callback.result());
    832   ASSERT_TRUE(AreEqualWithBinary(received_message, binary));
    833   ReleaseVar(received_message);
    834   core_interface_->ReleaseResource(ws);
    835 
    836   PASS();
    837 }
    838 
    839 std::string TestWebSocket::TestStressedSendReceive() {
    840   // Connect to test echo server.
    841   int32_t connect_result;
    842   PP_Resource ws =
    843       Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
    844   ASSERT_TRUE(ws);
    845   ASSERT_EQ(PP_OK, connect_result);
    846 
    847   // Prepare PP_Var objects to send.
    848   const char* text = "hello pepper";
    849   PP_Var text_var = CreateVarString(text);
    850   std::vector<uint8_t> binary(256);
    851   for (uint32_t i = 0; i < binary.size(); ++i)
    852     binary[i] = i;
    853   PP_Var binary_var = CreateVarBinary(binary);
    854   // Prepare very large binary data over 64KiB. Object serializer in
    855   // ppapi_proxy has a limitation of 64KiB as maximum return PP_Var data size
    856   // to SRPC. In case received data over 64KiB exists, a specific code handles
    857   // this large data via asynchronous callback from main thread. This data
    858   // intends to test the code.
    859   std::vector<uint8_t> large_binary(65 * 1024);
    860   for (uint32_t i = 0; i < large_binary.size(); ++i)
    861     large_binary[i] = i & 0xff;
    862   PP_Var large_binary_var = CreateVarBinary(large_binary);
    863 
    864   // Send many messages.
    865   int32_t result;
    866   for (int i = 0; i < 256; ++i) {
    867     result = websocket_interface_->SendMessage(ws, text_var);
    868     ASSERT_EQ(PP_OK, result);
    869     result = websocket_interface_->SendMessage(ws, binary_var);
    870     ASSERT_EQ(PP_OK, result);
    871   }
    872   result = websocket_interface_->SendMessage(ws, large_binary_var);
    873   ASSERT_EQ(PP_OK, result);
    874   ReleaseVar(text_var);
    875   ReleaseVar(binary_var);
    876   ReleaseVar(large_binary_var);
    877 
    878   // Receive echoed data.
    879   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    880   for (int i = 0; i <= 512; ++i) {
    881     PP_Var received_message;
    882     callback.WaitForResult(websocket_interface_->ReceiveMessage(
    883         ws, &received_message,
    884         callback.GetCallback().pp_completion_callback()));
    885     ASSERT_EQ(PP_OK, callback.result());
    886     if (i == 512) {
    887       ASSERT_TRUE(AreEqualWithBinary(received_message, large_binary));
    888     } else if (i & 1) {
    889       ASSERT_TRUE(AreEqualWithBinary(received_message, binary));
    890     } else {
    891       ASSERT_TRUE(AreEqualWithString(received_message, text));
    892     }
    893     ReleaseVar(received_message);
    894   }
    895   core_interface_->ReleaseResource(ws);
    896 
    897   PASS();
    898 }
    899 
    900 std::string TestWebSocket::TestBufferedAmount() {
    901   // Connect to test echo server.
    902   int32_t connect_result;
    903   PP_Resource ws =
    904       Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
    905   ASSERT_TRUE(ws);
    906   ASSERT_EQ(PP_OK, connect_result);
    907 
    908   // Prepare a large message that is not aligned with the internal buffer
    909   // sizes.
    910   std::string message(8193, 'x');
    911   PP_Var message_var = CreateVarString(message);
    912 
    913   uint64_t buffered_amount = 0;
    914   int32_t result;
    915   for (int i = 0; i < 100; i++) {
    916     result = websocket_interface_->SendMessage(ws, message_var);
    917     ASSERT_EQ(PP_OK, result);
    918     buffered_amount = websocket_interface_->GetBufferedAmount(ws);
    919     // Buffered amount size 262144 is too big for the internal buffer size.
    920     if (buffered_amount > 262144)
    921       break;
    922   }
    923 
    924   // Close connection.
    925   std::string reason_str = "close while busy";
    926   PP_Var reason = CreateVarString(reason_str.c_str());
    927   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    928   result = websocket_interface_->Close(
    929       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
    930       callback.GetCallback().pp_completion_callback());
    931   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    932   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING,
    933       websocket_interface_->GetReadyState(ws));
    934 
    935   callback.WaitForResult(result);
    936   ASSERT_EQ(PP_OK, callback.result());
    937   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED,
    938       websocket_interface_->GetReadyState(ws));
    939 
    940   uint64_t base_buffered_amount = websocket_interface_->GetBufferedAmount(ws);
    941 
    942   // After connection closure, all sending requests fail and just increase
    943   // the bufferedAmount property.
    944   PP_Var empty_string = CreateVarString(std::string());
    945   result = websocket_interface_->SendMessage(ws, empty_string);
    946   ASSERT_EQ(PP_ERROR_FAILED, result);
    947   buffered_amount = websocket_interface_->GetBufferedAmount(ws);
    948   ASSERT_EQ(base_buffered_amount + kMessageFrameOverhead, buffered_amount);
    949   base_buffered_amount = buffered_amount;
    950 
    951   result = websocket_interface_->SendMessage(ws, reason);
    952   ASSERT_EQ(PP_ERROR_FAILED, result);
    953   buffered_amount = websocket_interface_->GetBufferedAmount(ws);
    954   uint64_t reason_frame_size = kMessageFrameOverhead + reason_str.length();
    955   ASSERT_EQ(base_buffered_amount + reason_frame_size, buffered_amount);
    956 
    957   ReleaseVar(message_var);
    958   ReleaseVar(reason);
    959   ReleaseVar(empty_string);
    960   core_interface_->ReleaseResource(ws);
    961 
    962   PASS();
    963 }
    964 
    965 // Test abort behaviors where a WebSocket PP_Resource is released while each
    966 // function is in-flight on the WebSocket PP_Resource.
    967 std::string TestWebSocket::TestAbortCallsWithCallback() {
    968   // Following tests make sure the behavior for functions which require a
    969   // callback. The callback must get a PP_ERROR_ABORTED.
    970 
    971   // Test the behavior for Connect().
    972   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
    973   ASSERT_TRUE(ws);
    974   std::string url = GetFullURL(kEchoServerURL);
    975   PP_Var url_var = CreateVarString(url);
    976   TestCompletionCallback connect_callback(
    977       instance_->pp_instance(), callback_type());
    978   int32_t result = websocket_interface_->Connect(
    979       ws, url_var, NULL, 0,
    980       connect_callback.GetCallback().pp_completion_callback());
    981   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    982   core_interface_->ReleaseResource(ws);
    983   connect_callback.WaitForResult(result);
    984   ASSERT_EQ(PP_ERROR_ABORTED, connect_callback.result());
    985 
    986   // Test the behavior for Close().
    987   ws = Connect(url, &result, std::string());
    988   ASSERT_TRUE(ws);
    989   ASSERT_EQ(PP_OK, result);
    990   PP_Var reason_var = CreateVarString("abort");
    991   TestCompletionCallback close_callback(
    992       instance_->pp_instance(), callback_type());
    993   result = websocket_interface_->Close(
    994       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason_var,
    995       close_callback.GetCallback().pp_completion_callback());
    996   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    997   core_interface_->ReleaseResource(ws);
    998   close_callback.WaitForResult(result);
    999   ASSERT_EQ(PP_ERROR_ABORTED, close_callback.result());
   1000   ReleaseVar(reason_var);
   1001 
   1002   // Test the behavior for ReceiveMessage().
   1003   // Make sure the simplest case to wait for data which never arrives, here.
   1004   ws = Connect(url, &result, std::string());
   1005   ASSERT_TRUE(ws);
   1006   ASSERT_EQ(PP_OK, result);
   1007   PP_Var receive_var;
   1008   TestCompletionCallback receive_callback(
   1009       instance_->pp_instance(), callback_type());
   1010   result = websocket_interface_->ReceiveMessage(
   1011       ws, &receive_var,
   1012       receive_callback.GetCallback().pp_completion_callback());
   1013   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1014   core_interface_->ReleaseResource(ws);
   1015   receive_callback.WaitForResult(result);
   1016   ASSERT_EQ(PP_ERROR_ABORTED, receive_callback.result());
   1017 
   1018   // Release the resource in the aborting receive completion callback which is
   1019   // introduced by calling Close().
   1020   ws = Connect(url, &result, std::string());
   1021   ASSERT_TRUE(ws);
   1022   ASSERT_EQ(PP_OK, result);
   1023   result = websocket_interface_->ReceiveMessage(
   1024       ws, &receive_var,
   1025       receive_callback.GetCallback().pp_completion_callback());
   1026   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1027   ReleaseResourceDelegate receive_delegate(core_interface_, ws);
   1028   receive_callback.SetDelegate(&receive_delegate);
   1029   result = websocket_interface_->Close(
   1030       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
   1031       close_callback.GetCallback().pp_completion_callback());
   1032   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1033   receive_callback.WaitForResult(result);
   1034   CHECK_CALLBACK_BEHAVIOR(receive_callback);
   1035   ASSERT_EQ(PP_ERROR_ABORTED, receive_callback.result());
   1036   close_callback.WaitForResult(result);
   1037   CHECK_CALLBACK_BEHAVIOR(close_callback);
   1038   ASSERT_EQ(PP_ERROR_ABORTED, close_callback.result());
   1039 
   1040   ReleaseVar(url_var);
   1041 
   1042   PASS();
   1043 }
   1044 
   1045 std::string TestWebSocket::TestAbortSendMessageCall() {
   1046   // Test the behavior for SendMessage().
   1047   // This function doesn't require a callback, but operation will be done
   1048   // asynchronously in WebKit and browser process.
   1049   std::vector<uint8_t> large_binary(65 * 1024);
   1050   PP_Var large_var = CreateVarBinary(large_binary);
   1051 
   1052   int32_t result;
   1053   std::string url = GetFullURL(kEchoServerURL);
   1054   PP_Resource ws = Connect(url, &result, std::string());
   1055   ASSERT_TRUE(ws);
   1056   ASSERT_EQ(PP_OK, result);
   1057   result = websocket_interface_->SendMessage(ws, large_var);
   1058   ASSERT_EQ(PP_OK, result);
   1059   core_interface_->ReleaseResource(ws);
   1060   ReleaseVar(large_var);
   1061 
   1062   PASS();
   1063 }
   1064 
   1065 std::string TestWebSocket::TestAbortCloseCall() {
   1066   // Release the resource in the close completion callback.
   1067   int32_t result;
   1068   std::string url = GetFullURL(kEchoServerURL);
   1069   PP_Resource ws = Connect(url, &result, std::string());
   1070   ASSERT_TRUE(ws);
   1071   ASSERT_EQ(PP_OK, result);
   1072   TestCompletionCallback close_callback(
   1073       instance_->pp_instance(), callback_type());
   1074   result = websocket_interface_->Close(
   1075       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
   1076       close_callback.GetCallback().pp_completion_callback());
   1077   ReleaseResourceDelegate close_delegate(core_interface_, ws);
   1078   close_callback.SetDelegate(&close_delegate);
   1079   close_callback.WaitForResult(result);
   1080   CHECK_CALLBACK_BEHAVIOR(close_callback);
   1081   ASSERT_EQ(PP_OK, close_callback.result());
   1082 
   1083   PASS();
   1084 }
   1085 
   1086 std::string TestWebSocket::TestAbortReceiveMessageCall() {
   1087   // Test the behavior where receive process might be in-flight.
   1088   std::vector<uint8_t> large_binary(65 * 1024);
   1089   PP_Var large_var = CreateVarBinary(large_binary);
   1090   const char* text = "yukarin";
   1091   PP_Var text_var = CreateVarString(text);
   1092 
   1093   std::string url = GetFullURL(kEchoServerURL);
   1094   int32_t result;
   1095   PP_Resource ws;
   1096 
   1097   // Each trial sends |trial_count| + 1 messages and receives just |trial|
   1098   // number of message(s) before releasing the WebSocket. The WebSocket is
   1099   // released while the next message is going to be received.
   1100   const int trial_count = 8;
   1101   for (int trial = 1; trial <= trial_count; trial++) {
   1102     ws = Connect(url, &result, std::string());
   1103     ASSERT_TRUE(ws);
   1104     ASSERT_EQ(PP_OK, result);
   1105     for (int i = 0; i <= trial_count; ++i) {
   1106       result = websocket_interface_->SendMessage(ws, text_var);
   1107       ASSERT_EQ(PP_OK, result);
   1108     }
   1109     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   1110     PP_Var var;
   1111     for (int i = 0; i < trial; ++i) {
   1112       callback.WaitForResult(websocket_interface_->ReceiveMessage(
   1113           ws, &var, callback.GetCallback().pp_completion_callback()));
   1114       ASSERT_EQ(PP_OK, callback.result());
   1115       ASSERT_TRUE(AreEqualWithString(var, text));
   1116       ReleaseVar(var);
   1117     }
   1118     result = websocket_interface_->ReceiveMessage(
   1119         ws, &var, callback.GetCallback().pp_completion_callback());
   1120     core_interface_->ReleaseResource(ws);
   1121     if (result != PP_OK) {
   1122       callback.WaitForResult(result);
   1123       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
   1124     }
   1125   }
   1126   // Same test, but the last receiving message is large message over 64KiB.
   1127   for (int trial = 1; trial <= trial_count; trial++) {
   1128     ws = Connect(url, &result, std::string());
   1129     ASSERT_TRUE(ws);
   1130     ASSERT_EQ(PP_OK, result);
   1131     for (int i = 0; i <= trial_count; ++i) {
   1132       if (i == trial)
   1133         result = websocket_interface_->SendMessage(ws, large_var);
   1134       else
   1135         result = websocket_interface_->SendMessage(ws, text_var);
   1136       ASSERT_EQ(PP_OK, result);
   1137     }
   1138     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   1139     PP_Var var;
   1140     for (int i = 0; i < trial; ++i) {
   1141       callback.WaitForResult(websocket_interface_->ReceiveMessage(
   1142           ws, &var, callback.GetCallback().pp_completion_callback()));
   1143       ASSERT_EQ(PP_OK, callback.result());
   1144       ASSERT_TRUE(AreEqualWithString(var, text));
   1145       ReleaseVar(var);
   1146     }
   1147     result = websocket_interface_->ReceiveMessage(
   1148         ws, &var, callback.GetCallback().pp_completion_callback());
   1149     core_interface_->ReleaseResource(ws);
   1150     if (result != PP_OK) {
   1151       callback.WaitForResult(result);
   1152       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
   1153     }
   1154   }
   1155 
   1156   ReleaseVar(large_var);
   1157   ReleaseVar(text_var);
   1158 
   1159   PASS();
   1160 }
   1161 
   1162 std::string TestWebSocket::TestClosedFromServerWhileSending() {
   1163   // Connect to test echo server.
   1164   const pp::Var protocols[] = { pp::Var() };
   1165   TestWebSocketAPI websocket(instance_);
   1166   int32_t result =
   1167       websocket.Connect(pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
   1168   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1169   websocket.WaitForConnected();
   1170 
   1171   result = websocket.Send(pp::Var("hello"));
   1172   ASSERT_EQ(PP_OK, result);
   1173   result = websocket.Send(pp::Var("Goodbye"));
   1174   // We send many messages so that PepperWebSocketHost::SendText is called
   1175   // after PepperWebSocketHost::didClose is called.
   1176   // Note: We must not wait for CLOSED event here because
   1177   // WebSocketResource::SendMessage doesn't call PepperWebSocketHost::SendText
   1178   // when its internal state is CLOSING or CLOSED. We want to test if the
   1179   // pepper WebSocket works well when WebSocketResource is OPEN and
   1180   // PepperWebSocketHost is CLOSED.
   1181   for (size_t i = 0; i < 10000; ++i) {
   1182     result = websocket.Send(pp::Var(""));
   1183     ASSERT_EQ(PP_OK, result);
   1184   }
   1185 
   1186   PASS();
   1187 }
   1188 
   1189 std::string TestWebSocket::TestCcInterfaces() {
   1190   // C++ bindings is simple straightforward, then just verifies interfaces work
   1191   // as a interface bridge fine.
   1192   pp::WebSocket ws(instance_);
   1193 
   1194   // Check uninitialized properties access.
   1195   ASSERT_EQ(0, ws.GetBufferedAmount());
   1196   ASSERT_EQ(0, ws.GetCloseCode());
   1197   ASSERT_TRUE(AreEqualWithString(ws.GetCloseReason().pp_var(), std::string()));
   1198   ASSERT_FALSE(ws.GetCloseWasClean());
   1199   ASSERT_TRUE(AreEqualWithString(ws.GetExtensions().pp_var(), std::string()));
   1200   ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), std::string()));
   1201   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ws.GetReadyState());
   1202   ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), std::string()));
   1203 
   1204   // Check communication interfaces (connect, send, receive, and close).
   1205   TestCompletionCallback connect_callback(
   1206       instance_->pp_instance(), callback_type());
   1207   connect_callback.WaitForResult(ws.Connect(
   1208       pp::Var(GetFullURL(kCloseServerURL)), NULL, 0U,
   1209               connect_callback.GetCallback()));
   1210   CHECK_CALLBACK_BEHAVIOR(connect_callback);
   1211   ASSERT_EQ(PP_OK, connect_callback.result());
   1212 
   1213   std::string text_message("hello C++");
   1214   int32_t result = ws.SendMessage(pp::Var(text_message));
   1215   ASSERT_EQ(PP_OK, result);
   1216 
   1217   std::vector<uint8_t> binary(256);
   1218   for (uint32_t i = 0; i < binary.size(); ++i)
   1219     binary[i] = i;
   1220   result = ws.SendMessage(
   1221       pp::Var(pp::PASS_REF, CreateVarBinary(binary)));
   1222   ASSERT_EQ(PP_OK, result);
   1223 
   1224   pp::Var text_receive_var;
   1225   TestCompletionCallback text_receive_callback(
   1226       instance_->pp_instance(), callback_type());
   1227   text_receive_callback.WaitForResult(
   1228       ws.ReceiveMessage(&text_receive_var,
   1229                         text_receive_callback.GetCallback()));
   1230   ASSERT_EQ(PP_OK, text_receive_callback.result());
   1231   ASSERT_TRUE(
   1232       AreEqualWithString(text_receive_var.pp_var(), text_message.c_str()));
   1233 
   1234   pp::Var binary_receive_var;
   1235   TestCompletionCallback binary_receive_callback(
   1236       instance_->pp_instance(), callback_type());
   1237   binary_receive_callback.WaitForResult(
   1238       ws.ReceiveMessage(&binary_receive_var,
   1239                         binary_receive_callback.GetCallback()));
   1240   ASSERT_EQ(PP_OK, binary_receive_callback.result());
   1241   ASSERT_TRUE(AreEqualWithBinary(binary_receive_var.pp_var(), binary));
   1242 
   1243   TestCompletionCallback close_callback(
   1244       instance_->pp_instance(), callback_type());
   1245   std::string reason("bye");
   1246   close_callback.WaitForResult(ws.Close(
   1247       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason),
   1248       close_callback.GetCallback()));
   1249   CHECK_CALLBACK_BEHAVIOR(close_callback);
   1250   ASSERT_EQ(PP_OK, close_callback.result());
   1251 
   1252   // Check initialized properties access.
   1253   ASSERT_EQ(0, ws.GetBufferedAmount());
   1254   ASSERT_EQ(PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, ws.GetCloseCode());
   1255   ASSERT_TRUE(
   1256       AreEqualWithString(ws.GetCloseReason().pp_var(), reason.c_str()));
   1257   ASSERT_EQ(true, ws.GetCloseWasClean());
   1258   ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), std::string()));
   1259   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, ws.GetReadyState());
   1260   ASSERT_TRUE(AreEqualWithString(
   1261       ws.GetURL().pp_var(), GetFullURL(kCloseServerURL).c_str()));
   1262 
   1263   PASS();
   1264 }
   1265 
   1266 std::string TestWebSocket::TestUtilityInvalidConnect() {
   1267   const pp::Var protocols[] = { pp::Var() };
   1268 
   1269   TestWebSocketAPI websocket(instance_);
   1270   int32_t result = websocket.Connect(pp::Var(), protocols, 1U);
   1271   ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
   1272   ASSERT_EQ(0U, websocket.GetSeenEvents().size());
   1273 
   1274   result = websocket.Connect(pp::Var(), protocols, 1U);
   1275   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
   1276   ASSERT_EQ(0U, websocket.GetSeenEvents().size());
   1277 
   1278   for (int i = 0; kInvalidURLs[i]; ++i) {
   1279     TestWebSocketAPI ws(instance_);
   1280     result = ws.Connect(pp::Var(std::string(kInvalidURLs[i])), protocols, 0U);
   1281     if (result == PP_OK_COMPLETIONPENDING) {
   1282       ws.WaitForClosed();
   1283       const std::vector<WebSocketEvent>& events = ws.GetSeenEvents();
   1284       ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[0].event_type);
   1285       ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[1].event_type);
   1286       ASSERT_EQ(2U, ws.GetSeenEvents().size());
   1287     } else {
   1288       ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
   1289       ASSERT_EQ(0U, ws.GetSeenEvents().size());
   1290     }
   1291   }
   1292 
   1293   PASS();
   1294 }
   1295 
   1296 std::string TestWebSocket::TestUtilityProtocols() {
   1297   const pp::Var bad_protocols[] = {
   1298       pp::Var(std::string("x-test")), pp::Var(std::string("x-test")) };
   1299   const pp::Var good_protocols[] = {
   1300       pp::Var(std::string("x-test")), pp::Var(std::string("x-yatest")) };
   1301 
   1302   {
   1303     TestWebSocketAPI websocket(instance_);
   1304     int32_t result = websocket.Connect(
   1305         pp::Var(GetFullURL(kEchoServerURL)), bad_protocols, 2U);
   1306     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
   1307     ASSERT_EQ(0U, websocket.GetSeenEvents().size());
   1308   }
   1309 
   1310   {
   1311     TestWebSocketAPI websocket(instance_);
   1312     int32_t result = websocket.Connect(
   1313         pp::Var(GetFullURL(kEchoServerURL)), good_protocols, 2U);
   1314     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1315     websocket.WaitForConnected();
   1316     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1317     // Protocol arguments are valid, but this test run without a WebSocket
   1318     // server. As a result, OnError() and OnClose() are invoked because of
   1319     // a connection establishment failure.
   1320     ASSERT_EQ(2U, events.size());
   1321     ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[0].event_type);
   1322     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[1].event_type);
   1323     ASSERT_FALSE(events[1].was_clean);
   1324   }
   1325 
   1326   PASS();
   1327 }
   1328 
   1329 std::string TestWebSocket::TestUtilityGetURL() {
   1330   const pp::Var protocols[] = { pp::Var() };
   1331 
   1332   for (int i = 0; kInvalidURLs[i]; ++i) {
   1333     TestWebSocketAPI websocket(instance_);
   1334     int32_t result = websocket.Connect(
   1335         pp::Var(std::string(kInvalidURLs[i])), protocols, 0U);
   1336     if (result == PP_OK_COMPLETIONPENDING) {
   1337       websocket.WaitForClosed();
   1338       const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1339       ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[0].event_type);
   1340       ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[1].event_type);
   1341       ASSERT_EQ(2U, events.size());
   1342     } else {
   1343       ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
   1344       ASSERT_EQ(0U, websocket.GetSeenEvents().size());
   1345     }
   1346     pp::Var url = websocket.GetURL();
   1347     ASSERT_TRUE(AreEqualWithString(url.pp_var(), kInvalidURLs[i]));
   1348   }
   1349 
   1350   PASS();
   1351 }
   1352 
   1353 std::string TestWebSocket::TestUtilityValidConnect() {
   1354   const pp::Var protocols[] = { pp::Var() };
   1355   TestWebSocketAPI websocket(instance_);
   1356   int32_t result = websocket.Connect(
   1357       pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
   1358   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1359   websocket.WaitForConnected();
   1360   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1361   ASSERT_EQ(1U, events.size());
   1362   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1363   ASSERT_TRUE(
   1364       AreEqualWithString(websocket.GetExtensions().pp_var(), std::string()));
   1365 
   1366   PASS();
   1367 }
   1368 
   1369 std::string TestWebSocket::TestUtilityInvalidClose() {
   1370   const pp::Var reason = pp::Var(std::string("close for test"));
   1371 
   1372   // Close before connect.
   1373   {
   1374     TestWebSocketAPI websocket(instance_);
   1375     int32_t result = websocket.Close(
   1376         PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason);
   1377     ASSERT_EQ(PP_ERROR_FAILED, result);
   1378     ASSERT_EQ(0U, websocket.GetSeenEvents().size());
   1379   }
   1380 
   1381   // Close with bad arguments.
   1382   {
   1383     TestWebSocketAPI websocket(instance_);
   1384     int32_t result = websocket.Connect(pp::Var(GetFullURL(kEchoServerURL)),
   1385         NULL, 0);
   1386     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1387     websocket.WaitForConnected();
   1388     result = websocket.Close(1U, reason);
   1389     ASSERT_EQ(PP_ERROR_NOACCESS, result);
   1390     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1391     ASSERT_EQ(1U, events.size());
   1392     ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1393   }
   1394 
   1395   PASS();
   1396 }
   1397 
   1398 std::string TestWebSocket::TestUtilityValidClose() {
   1399   std::string reason("close for test");
   1400   pp::Var url = pp::Var(GetFullURL(kCloseServerURL));
   1401 
   1402   // Close.
   1403   {
   1404     TestWebSocketAPI websocket(instance_);
   1405     int32_t result = websocket.Connect(url, NULL, 0U);
   1406     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1407     websocket.WaitForConnected();
   1408     result = websocket.Close(
   1409         PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
   1410     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1411     websocket.WaitForClosed();
   1412     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1413     ASSERT_EQ(2U, events.size());
   1414     ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1415     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[1].event_type);
   1416     ASSERT_TRUE(events[1].was_clean);
   1417     ASSERT_EQ(PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, events[1].close_code);
   1418     ASSERT_TRUE(AreEqualWithString(events[1].var.pp_var(), reason.c_str()));
   1419   }
   1420 
   1421   // Close in connecting.
   1422   // The ongoing connect failed with PP_ERROR_ABORTED, then the close is done
   1423   // successfully.
   1424   {
   1425     TestWebSocketAPI websocket(instance_);
   1426     int32_t result = websocket.Connect(url, NULL, 0U);
   1427     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1428     result = websocket.Close(
   1429         PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
   1430     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1431     websocket.WaitForClosed();
   1432     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1433     ASSERT_TRUE(events.size() == 2 || events.size() == 3);
   1434     int index = 0;
   1435     if (events.size() == 3)
   1436       ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[index++].event_type);
   1437     ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[index++].event_type);
   1438     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[index].event_type);
   1439     ASSERT_FALSE(events[index].was_clean);
   1440   }
   1441 
   1442   // Close in closing.
   1443   // The first close will be done successfully, then the second one failed with
   1444   // with PP_ERROR_INPROGRESS immediately.
   1445   {
   1446     TestWebSocketAPI websocket(instance_);
   1447     int32_t result = websocket.Connect(url, NULL, 0U);
   1448     result = websocket.Close(
   1449         PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
   1450     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1451     result = websocket.Close(
   1452         PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
   1453     ASSERT_EQ(PP_ERROR_INPROGRESS, result);
   1454     websocket.WaitForClosed();
   1455     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1456     ASSERT_TRUE(events.size() == 2 || events.size() == 3);
   1457     int index = 0;
   1458     if (events.size() == 3)
   1459       ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[index++].event_type);
   1460     ASSERT_EQ(WebSocketEvent::EVENT_ERROR, events[index++].event_type);
   1461     ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[index].event_type);
   1462     ASSERT_FALSE(events[index].was_clean);
   1463   }
   1464 
   1465   PASS();
   1466 }
   1467 
   1468 std::string TestWebSocket::TestUtilityGetProtocol() {
   1469   const std::string protocol("x-chat");
   1470   const pp::Var protocols[] = { pp::Var(protocol) };
   1471   std::string url(GetFullURL(kProtocolTestServerURL));
   1472   url += protocol;
   1473   TestWebSocketAPI websocket(instance_);
   1474   int32_t result = websocket.Connect(pp::Var(url), protocols, 1U);
   1475   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1476   websocket.WaitForReceived();
   1477   ASSERT_TRUE(AreEqualWithString(
   1478       websocket.GetProtocol().pp_var(), protocol.c_str()));
   1479   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1480   // The server to which this test connect returns the decided protocol as a
   1481   // text frame message. So the WebSocketEvent records EVENT_MESSAGE event
   1482   // after EVENT_OPEN event.
   1483   ASSERT_EQ(2U, events.size());
   1484   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1485   ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[1].event_type);
   1486   ASSERT_TRUE(AreEqualWithString(events[1].var.pp_var(), protocol.c_str()));
   1487 
   1488   PASS();
   1489 }
   1490 
   1491 std::string TestWebSocket::TestUtilityTextSendReceive() {
   1492   const pp::Var protocols[] = { pp::Var() };
   1493   TestWebSocketAPI websocket(instance_);
   1494   int32_t result =
   1495       websocket.Connect(pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
   1496   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1497   websocket.WaitForConnected();
   1498 
   1499   // Send 'hello pepper'.
   1500   std::string message1("hello pepper");
   1501   result = websocket.Send(pp::Var(std::string(message1)));
   1502   ASSERT_EQ(PP_OK, result);
   1503 
   1504   // Receive echoed 'hello pepper'.
   1505   websocket.WaitForReceived();
   1506 
   1507   // Send 'goodbye pepper'.
   1508   std::string message2("goodbye pepper");
   1509   result = websocket.Send(pp::Var(std::string(message2)));
   1510 
   1511   // Receive echoed 'goodbye pepper'.
   1512   websocket.WaitForReceived();
   1513 
   1514   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1515   ASSERT_EQ(3U, events.size());
   1516   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1517   ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[1].event_type);
   1518   ASSERT_TRUE(AreEqualWithString(events[1].var.pp_var(), message1.c_str()));
   1519   ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[2].event_type);
   1520   ASSERT_TRUE(AreEqualWithString(events[2].var.pp_var(), message2.c_str()));
   1521 
   1522   PASS();
   1523 }
   1524 
   1525 std::string TestWebSocket::TestUtilityBinarySendReceive() {
   1526   const pp::Var protocols[] = { pp::Var() };
   1527   TestWebSocketAPI websocket(instance_);
   1528   int32_t result =
   1529       websocket.Connect(pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
   1530   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1531   websocket.WaitForConnected();
   1532 
   1533   // Send binary message.
   1534   uint32_t len = 256;
   1535   std::vector<uint8_t> binary(len);
   1536   for (uint32_t i = 0; i < len; ++i)
   1537     binary[i] = i;
   1538   pp::VarArrayBuffer message(len);
   1539   uint8_t* var_data = static_cast<uint8_t*>(message.Map());
   1540   std::copy(binary.begin(), binary.end(), var_data);
   1541   result = websocket.Send(message);
   1542   ASSERT_EQ(PP_OK, result);
   1543 
   1544   // Receive echoed binary message.
   1545   websocket.WaitForReceived();
   1546 
   1547   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1548   ASSERT_EQ(2U, events.size());
   1549   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1550   ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[1].event_type);
   1551   ASSERT_TRUE(AreEqualWithBinary(events[1].var.pp_var(), binary));
   1552 
   1553   PASS();
   1554 }
   1555 
   1556 std::string TestWebSocket::TestUtilityBufferedAmount() {
   1557   // Connect to test echo server.
   1558   const pp::Var protocols[] = { pp::Var() };
   1559   TestWebSocketAPI websocket(instance_);
   1560   int32_t result =
   1561       websocket.Connect(pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
   1562   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   1563   websocket.WaitForConnected();
   1564 
   1565   // Prepare a large message that is not aligned with the internal buffer
   1566   // sizes.
   1567   std::string message(8193, 'x');
   1568   uint64_t buffered_amount = 0;
   1569   uint32_t sent;
   1570   for (sent = 0; sent < 100; sent++) {
   1571     result = websocket.Send(pp::Var(message));
   1572     ASSERT_EQ(PP_OK, result);
   1573     buffered_amount = websocket.GetBufferedAmount();
   1574     // Buffered amount size 262144 is too big for the internal buffer size.
   1575     if (buffered_amount > 262144)
   1576       break;
   1577   }
   1578 
   1579   // Close connection.
   1580   std::string reason = "close while busy";
   1581   result = websocket.Close(
   1582       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
   1583   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING, websocket.GetReadyState());
   1584   websocket.WaitForClosed();
   1585   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, websocket.GetReadyState());
   1586 
   1587   uint64_t base_buffered_amount = websocket.GetBufferedAmount();
   1588   size_t events_on_closed = websocket.GetSeenEvents().size();
   1589 
   1590   // After connection closure, all sending requests fail and just increase
   1591   // the bufferedAmount property.
   1592   result = websocket.Send(pp::Var(std::string()));
   1593   ASSERT_EQ(PP_ERROR_FAILED, result);
   1594   buffered_amount = websocket.GetBufferedAmount();
   1595   ASSERT_EQ(base_buffered_amount + kMessageFrameOverhead, buffered_amount);
   1596   base_buffered_amount = buffered_amount;
   1597 
   1598   result = websocket.Send(pp::Var(reason));
   1599   ASSERT_EQ(PP_ERROR_FAILED, result);
   1600   buffered_amount = websocket.GetBufferedAmount();
   1601   uint64_t reason_frame_size = kMessageFrameOverhead + reason.length();
   1602   ASSERT_EQ(base_buffered_amount + reason_frame_size, buffered_amount);
   1603 
   1604   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   1605   ASSERT_EQ(events_on_closed, events.size());
   1606   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   1607   size_t last_event = events_on_closed - 1;
   1608   for (uint32_t i = 1; i < last_event; ++i) {
   1609     ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[i].event_type);
   1610     ASSERT_TRUE(AreEqualWithString(events[i].var.pp_var(), message));
   1611   }
   1612   ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[last_event].event_type);
   1613   ASSERT_TRUE(events[last_event].was_clean);
   1614 
   1615   PASS();
   1616 }
   1617