WebSocket Pepper API: validate redundant protocols in Connect()

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 "ppapi/c/dev/ppb_websocket_dev.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 15 matching lines @@
 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 = 1000;
+const uint16_t kCloseCodeNormalClosure = 1000U;
 
 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));
   core_interface_ = static_cast<const PPB_Core*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
   if (!websocket_interface_ || !var_interface_ || !core_interface_)
     return false;
 
   return true;
 }
 
 void TestWebSocket::RunTests(const std::string& filter) {
   RUN_TEST(IsWebSocket, filter);
   RUN_TEST(UninitializedPropertiesAccess, filter);
   RUN_TEST(InvalidConnect, filter);
+  RUN_TEST(Protocols, filter);
   RUN_TEST(GetURL, filter);
   RUN_TEST(ValidConnect, filter);
   RUN_TEST(InvalidClose, filter);
   RUN_TEST(ValidClose, filter);
   RUN_TEST(GetProtocol, filter);
   RUN_TEST(TextSendReceive, filter);
 }
 
 PP_Var TestWebSocket::CreateVar(const char* string) {
   return var_interface_->VarFromUtf8(
@@ skipping 18 matching lines @@
 }
 
 PP_Resource TestWebSocket::Connect(
     const char* url, int32_t* result, const char* protocol) {
   PP_Var protocols[] = { PP_MakeUndefined() };
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   if (!ws)
     return 0;
   PP_Var url_var = CreateVar(url);
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int protocol_count = 0;
+  uint32_t protocol_count = 0U;
   if (protocol) {
     protocols[0] = CreateVar(protocol);
-    protocol_count = 1;
+    protocol_count = 1U;
   }
   *result = websocket_interface_->Connect(
       ws, url_var, protocols, protocol_count,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ReleaseVar(url_var);
   if (protocol)
     ReleaseVar(protocols[0]);
   if (*result == PP_OK_COMPLETIONPENDING)
     *result = callback.WaitForResult();
   return ws;
@@ skipping 15 matching lines @@
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestUninitializedPropertiesAccess() {
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
 
   uint64_t bufferedAmount = websocket_interface_->GetBufferedAmount(ws);
-  ASSERT_EQ(0, bufferedAmount);
+  ASSERT_EQ(0U, bufferedAmount);
 
   uint16_t close_code = websocket_interface_->GetCloseCode(ws);
-  ASSERT_EQ(0, close_code);
+  ASSERT_EQ(0U, close_code);
 
   PP_Var close_reason = websocket_interface_->GetCloseReason(ws);
   ASSERT_TRUE(AreEqual(close_reason, ""));
 
   PP_Bool close_was_clean = websocket_interface_->GetCloseWasClean(ws);
   ASSERT_EQ(PP_FALSE, close_was_clean);
 
   PP_Var extensions = websocket_interface_->GetExtensions(ws);
   ASSERT_TRUE(AreEqual(extensions, ""));
 
@@ skipping 11 matching lines @@
 }
 
 std::string TestWebSocket::TestInvalidConnect() {
   PP_Var protocols[] = { PP_MakeUndefined() };
 
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t result = websocket_interface_->Connect(
-      ws, PP_MakeUndefined(), protocols, 1,
+      ws, PP_MakeUndefined(), protocols, 1U,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
 
   result = websocket_interface_->Connect(
-      ws, PP_MakeUndefined(), protocols, 1,
+      ws, PP_MakeUndefined(), protocols, 1U,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
 
   core_interface_->ReleaseResource(ws);
 
   for (int i = 0; kInvalidURLs[i]; ++i) {
     ws = Connect(kInvalidURLs[i], &result, NULL);
     ASSERT_TRUE(ws);
     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
 
     core_interface_->ReleaseResource(ws);
   }
 
-  // TODO(toyoshim): Add invalid protocols tests
+  PASS();
+}
+
+std::string TestWebSocket::TestProtocols() {
+  PP_Var url = CreateVar(kEchoServerURL);
+  PP_Var bad_protocols[] = { CreateVar("x-test"), CreateVar("x-test") };
+  PP_Var good_protocols[] = { CreateVar("x-test"), CreateVar("x-yatest") };
+
+  PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
+  ASSERT_TRUE(ws);
+  int32_t result = websocket_interface_->Connect(
+      ws, url, bad_protocols, 2U, PP_BlockUntilComplete());
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
+  core_interface_->ReleaseResource(ws);
+
+  ws = websocket_interface_->Create(instance_->pp_instance());
+  ASSERT_TRUE(ws);
+  result = websocket_interface_->Connect(
+      ws, url, good_protocols, 2U, PP_BlockUntilComplete());
+  ASSERT_EQ(PP_ERROR_BLOCKS_MAIN_THREAD, result);
+  core_interface_->ReleaseResource(ws);
+
+  ReleaseVar(url);
+  for (int i = 0; i < 2; ++i) {
+    ReleaseVar(bad_protocols[i]);
+    ReleaseVar(good_protocols[i]);
+  }
+  core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestGetURL() {
   for (int i = 0; kInvalidURLs[i]; ++i) {
     int32_t result;
     PP_Resource ws = Connect(kInvalidURLs[i], &result, NULL);
     ASSERT_TRUE(ws);
     PP_Var url = websocket_interface_->GetURL(ws);
@@ skipping 26 matching lines @@
   int32_t result = websocket_interface_->Close(
       ws, kCloseCodeNormalClosure, 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, 1, reason,
+  result = websocket_interface_->Close(ws, 1U, reason,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   ASSERT_EQ(PP_ERROR_NOACCESS, result);
   core_interface_->ReleaseResource(ws);
 
   ReleaseVar(reason);
 
   PASS();
 }
 
 std::string TestWebSocket::TestValidClose() {
@@ skipping 12 matching lines @@
       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, 0,
+  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,
       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);
@@ skipping 94 matching lines @@
   PASS();
 }
 
 // TODO(toyoshim): Add tests for GetBufferedAmount().
 // For now, the function doesn't work fine because update callback in WebKit is
 // not landed yet.
 
 // TODO(toyoshim): Add tests for didReceiveMessageError().
 
 // TODO(toyoshim): Add other function tests.