WebSocket Pepper API: make the API out of dev

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 <string.h>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/dev/ppb_var_array_buffer_dev.h"
-#include "ppapi/c/dev/ppb_websocket_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_var.h"
-#include "ppapi/cpp/dev/websocket_dev.h"
+#include "ppapi/c/ppb_websocket.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
+#include "ppapi/cpp/websocket.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 const char kEchoServerURL[] =
     "ws://localhost:8880/websocket/tests/hybi/echo";
 
 const char kCloseServerURL[] =
     "ws://localhost:8880/websocket/tests/hybi/close";
 
 const char kProtocolTestServerURL[] =
@@ skipping 11 matching lines @@
 // 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));
+  websocket_interface_ = static_cast<const PPB_WebSocket*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_WEBSOCKET_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));
   core_interface_ = static_cast<const PPB_Core*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
   if (!websocket_interface_ || !var_interface_ || !arraybuffer_interface_ ||
       !core_interface_)
     return false;
@@ skipping 62 matching lines @@
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   if (!ws)
     return 0;
   PP_Var url_var = CreateVarString(url);
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   uint32_t protocol_count = 0U;
   if (protocol) {
     protocols[0] = CreateVarString(protocol);
     protocol_count = 1U;
   }
-  websocket_interface_->SetBinaryType(
-      ws, PP_WEBSOCKETBINARYTYPE_ARRAYBUFFER_DEV);
   *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 34 matching lines @@
   ASSERT_EQ(PP_FALSE, close_was_clean);
 
   PP_Var extensions = websocket_interface_->GetExtensions(ws);
   ASSERT_TRUE(AreEqualWithString(extensions, ""));
   ReleaseVar(extensions);
 
   PP_Var protocol = websocket_interface_->GetProtocol(ws);
   ASSERT_TRUE(AreEqualWithString(protocol, ""));
   ReleaseVar(protocol);
 
-  PP_WebSocketReadyState_Dev ready_state =
+  PP_WebSocketReadyState ready_state =
       websocket_interface_->GetReadyState(ws);
-  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID_DEV, ready_state);
+  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ready_state);
 
   PP_Var url = websocket_interface_->GetURL(ws);
   ASSERT_TRUE(AreEqualWithString(url, ""));
   ReleaseVar(url);
 
-  PP_WebSocketBinaryType_Dev binary_type =
-      websocket_interface_->GetBinaryType(ws);
-  ASSERT_EQ(PP_WEBSOCKETBINARYTYPE_BLOB_DEV, binary_type);
-
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestInvalidConnect() {
   PP_Var protocols[] = { PP_MakeUndefined() };
 
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
@@ skipping 302 matching lines @@
       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,
+  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING,
       websocket_interface_->GetReadyState(ws));
 
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
-  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED_DEV,
+  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED,
       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);
@@ skipping 10 matching lines @@
   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_);
+  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(), ""));
   ASSERT_EQ(false, ws.GetCloseWasClean());
   ASSERT_TRUE(AreEqualWithString(ws.GetExtensions().pp_var(), ""));
   ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), ""));
-  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID_DEV, ws.GetReadyState());
+  ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ws.GetReadyState());
   ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), ""));
 
   // Check communication interfaces (connect, send, receive, and close).
-  ASSERT_TRUE(ws.SetBinaryType(PP_WEBSOCKETBINARYTYPE_ARRAYBUFFER_DEV));
   TestCompletionCallback connect_callback(instance_->pp_instance());
   int32_t result = ws.Connect(pp::Var(std::string(kCloseServerURL)), NULL, 0U,
       connect_callback);
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = connect_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
 
   std::string text_message("hello C++");
   result = ws.SendMessage(pp::Var(text_message));
   ASSERT_EQ(PP_OK, result);
@@ skipping 31 matching lines @@
   result = close_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
 
   // Check initialized properties access.
   ASSERT_EQ(0, ws.GetBufferedAmount());
   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_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, ws.GetReadyState());
   ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), kCloseServerURL));
-  ASSERT_EQ(PP_WEBSOCKETBINARYTYPE_ARRAYBUFFER_DEV, ws.GetBinaryType());
 
   PASS();
 }