- Implement internal API and thunk

- Implement base frame for in process API
- Add basic unit tests for in process API

BUG=87310
TEST=ui_tests --gtest_filter="PPAPITest.WebSocket*"

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

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

chrome/test/ui/ppapi_uitest.cc

@@ -342,3 +342,6 @@ TEST_PPAPI_OUT_OF_PROCESS(Flash_GetProxyForURL)
 TEST_PPAPI_OUT_OF_PROCESS(Flash_MessageLoop)
 TEST_PPAPI_OUT_OF_PROCESS(Flash_GetLocalTimeZoneOffset)
 TEST_PPAPI_OUT_OF_PROCESS(Flash_GetCommandLineArgs)
+
+TEST_PPAPI_IN_PROCESS(WebSocket_Create)
+TEST_PPAPI_IN_PROCESS(WebSocket_IsWebSocket)

ppapi/ppapi_shared.gypi

@@ -182,6 +182,8 @@
         'thunk/ppb_video_decoder_thunk.cc',
         'thunk/ppb_video_layer_api.h',
         'thunk/ppb_video_layer_thunk.cc',
+        'thunk/ppb_websocket_api.h',
+        'thunk/ppb_websocket_thunk.cc',
         'thunk/ppb_widget_api.h',
         'thunk/ppb_widget_thunk.cc',
         'thunk/ppb_zoom_thunk.cc',

ppapi/ppapi_tests.gypi

@@ -137,6 +137,8 @@
         'tests/test_var.h',
         'tests/test_video_decoder.cc',
         'tests/test_video_decoder.h',
+        'tests/test_websocket.cc',
+        'tests/test_websocket.h',
 
         # Deprecated test cases.
         'tests/test_instance_deprecated.cc',

ppapi/proxy/resource_creation_proxy.cc

@@ -346,6 +346,11 @@ PP_Resource ResourceCreationProxy::CreateVideoLayer(
   return 0;
 }
 
+PP_Resource ResourceCreationProxy::CreateWebSocket(PP_Instance instance) {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
 PP_Resource ResourceCreationProxy::CreateWheelInputEvent(
     PP_Instance instance,
     PP_TimeTicks time_stamp,

ppapi/proxy/resource_creation_proxy.h

@@ -129,6 +129,7 @@ class ResourceCreationProxy : public InterfaceProxy,
       PP_VideoDecoder_Profile profile) OVERRIDE;
   virtual PP_Resource CreateVideoLayer(PP_Instance instance,
                                        PP_VideoLayerMode_Dev mode) OVERRIDE;
+  virtual PP_Resource CreateWebSocket(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateWheelInputEvent(
       PP_Instance instance,
       PP_TimeTicks time_stamp,

ppapi/shared_impl/resource.h

@@ -51,6 +51,7 @@
   F(PPB_VideoCapture_API) \
   F(PPB_VideoDecoder_API) \
   F(PPB_VideoLayer_API) \
+  F(PPB_WebSocket_API) \
   F(PPB_Widget_API)
 
 namespace ppapi {

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 "ppapi/c/dev/ppb_websocket_dev.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/tests/testing_instance.h"
+
+REGISTER_TEST_CASE(WebSocket);
+
+bool TestWebSocket::Init() {
+  websocket_interface_ = reinterpret_cast<PPB_WebSocket_Dev const*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_WEBSOCKET_DEV_INTERFACE));
+  return !!websocket_interface_;
+}
+
+void TestWebSocket::RunTests(const std::string& filter) {
+  instance_->LogTest("Create", TestCreate());
+  instance_->LogTest("IsWebSocket", TestIsWebSocket());
+}
+
+std::string TestWebSocket::TestCreate() {
+  PP_Resource rsrc = websocket_interface_->Create(instance_->pp_instance());
+  if (!rsrc)
+    return "Could not create websocket via C interface";
+
+  PASS();
+}
+
+std::string TestWebSocket::TestIsWebSocket() {
+  // Test that a NULL resource isn't a websocket.
+  pp::Resource null_resource;
+  if (websocket_interface_->IsWebSocket(null_resource.pp_resource()))
+    return "Null resource was reported as a valid websocket";
+
+  PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
+  if (!websocket_interface_->IsWebSocket(ws))
+    return "websocket was reported as an invalid websocket";
+
+  PASS();
+}

ppapi/tests/test_websocket.h

+// 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.
+
+#ifndef PAPPI_TESTS_TEST_WEBSOCKET_H_
+#define PAPPI_TESTS_TEST_WEBSOCKET_H_
+
+#include <string>
+
+#include "ppapi/tests/test_case.h"
+
+struct PPB_WebSocket_Dev;
+
+class TestWebSocket : public TestCase {
+ public:
+  explicit TestWebSocket(TestingInstance* instance) : TestCase(instance) {}
+
+  // TestCase implementation.
+  virtual bool Init();
+  virtual void RunTests(const std::string& filter);
+
+ private:
+  std::string TestCreate();
+  std::string TestIsWebSocket();
+
+  // Used by the tests that access the C API directly.
+  const PPB_WebSocket_Dev* websocket_interface_;
+};
+
+#endif  // PAPPI_TESTS_TEST_WEBSOCKET_H_

ppapi/thunk/interfaces_ppb_public_dev.h

@@ -22,6 +22,7 @@ PROXIED_API(PPB_TextInput)
 UNPROXIED_API(PPB_Transport)
 PROXIED_API(PPB_VideoCapture)
 PROXIED_API(PPB_VideoDecoder)
+UNPROXIED_API(PPB_WebSocket)
 UNPROXIED_API(PPB_Widget)
 
 PROXIED_IFACE(PPB_AudioInput, PPB_AUDIO_INPUT_DEV_INTERFACE_0_1,
@@ -63,6 +64,8 @@ PROXIED_IFACE(PPB_VideoDecoder, PPB_VIDEODECODER_DEV_INTERFACE_0_16,
               PPB_VideoDecoder_Dev)
 UNPROXIED_IFACE(PPB_VideoLayer, PPB_VIDEOLAYER_DEV_INTERFACE,
                 PPB_VideoLayer_Dev)
+UNPROXIED_IFACE(PPB_WebSocket, PPB_WEBSOCKET_DEV_INTERFACE_0_1,
+                PPB_WebSocket_Dev)
 UNPROXIED_IFACE(PPB_Widget, PPB_WIDGET_DEV_INTERFACE_0_3, PPB_Widget_Dev)
 
 #include "ppapi/thunk/interfaces_postamble.h"

ppapi/thunk/ppb_websocket_api.h

+// 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.
+
+#ifndef PPAPI_THUNK_WEBSOCKET_API_H_
+#define PPAPI_THUNK_WEBSOCKET_API_H_
+
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/dev/ppb_websocket_dev.h"
+
+namespace ppapi {
+namespace thunk {
+
+class PPB_WebSocket_API {
+ public:
+  virtual ~PPB_WebSocket_API() {}
+
+  virtual int32_t Connect(PP_Var url,
+                          const PP_Var protocols[],
+                          uint32_t protocol_count,
+                          PP_CompletionCallback callback) = 0;
+  virtual int32_t Close(uint16_t code,
+                        PP_Var reason,
+                        PP_CompletionCallback callback) = 0;
+  virtual int32_t ReceiveMessage(PP_Var* message,
+                                 PP_CompletionCallback callback) = 0;
+  virtual int32_t SendMessage(PP_Var message) = 0;
+  virtual uint64_t GetBufferedAmount() = 0;
+  virtual uint16_t GetCloseCode() = 0;
+  virtual PP_Var GetCloseReason() = 0;
+  virtual PP_Bool GetCloseWasClean() = 0;
+  virtual PP_Var GetExtensions() = 0;
+  virtual PP_Var GetProtocol() = 0;
+  virtual PP_WebSocketReadyState_Dev GetReadyState() = 0;
+  virtual PP_Var GetURL() = 0;
+};
+
+}  // namespace thunk
+}  // namespace ppapi
+
+#endif  // PPAPI_THUNK_WEBSOCKET_API_H_

ppapi/thunk/ppb_websocket_thunk.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/c/pp_errors.h"
+#include "ppapi/c/pp_var.h"
+#include "ppapi/thunk/thunk.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_websocket_api.h"
+#include "ppapi/thunk/resource_creation_api.h"
+
+namespace ppapi {
+namespace thunk {
+
+namespace {
+
+PP_Resource Create(PP_Instance instance) {
+  EnterFunction<ResourceCreationAPI> enter(instance, true);
+  if (enter.failed())
+    return 0;
+  return enter.functions()->CreateWebSocket(instance);
+}
+
+PP_Bool IsWebSocket(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  return PP_FromBool(enter.succeeded());
+}
+
+int32_t Connect(PP_Resource resource,
+                PP_Var url,
+                const PP_Var protocols[],
+                uint32_t protocol_count,
+                PP_CompletionCallback callback) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->Connect(url, protocols, protocol_count, callback);
+}
+
+int32_t Close(PP_Resource resource,
+              uint16_t code,
+              PP_Var reason,
+              PP_CompletionCallback callback) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->Close(code, reason, callback);
+}
+
+int32_t ReceiveMessage(PP_Resource resource,
+                       PP_Var* message,
+                       PP_CompletionCallback callback) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->ReceiveMessage(message, callback);
+}
+
+int32_t SendMessage(PP_Resource resource, PP_Var message) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->SendMessage(message);
+}
+
+uint64_t GetBufferedAmount(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->GetBufferedAmount();
+}
+
+uint16_t GetCloseCode(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->GetCloseCode();
+}
+
+PP_Var GetCloseReason(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_MakeUndefined();
+  return enter.object()->GetCloseReason();
+}
+
+PP_Bool GetCloseWasClean(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_FALSE;
+  return enter.object()->GetCloseWasClean();
+}
+
+PP_Var GetExtensions(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_MakeUndefined();
+  return enter.object()->GetExtensions();
+}
+
+PP_Var GetProtocol(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_MakeUndefined();
+  return enter.object()->GetProtocol();
+}
+
+PP_WebSocketReadyState_Dev GetReadyState(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_WEBSOCKETREADYSTATE_INVALID_DEV;
+  return enter.object()->GetReadyState();
+}
+
+PP_Var GetURL(PP_Resource resource) {
+  EnterResource<PPB_WebSocket_API> enter(resource, false);
+  if (enter.failed())
+    return PP_MakeUndefined();
+  return enter.object()->GetURL();
+}
+
+
+const PPB_WebSocket_Dev g_ppb_websocket_thunk = {
+  &Create,
+  &IsWebSocket,
+  &Connect,
+  &Close,
+  &ReceiveMessage,
+  &SendMessage,
+  &GetBufferedAmount,
+  &GetCloseCode,
+  &GetCloseReason,
+  &GetCloseWasClean,
+  &GetExtensions,
+  &GetProtocol,
+  &GetReadyState,
+  &GetURL
+};
+
+}  // namespace
+
+const PPB_WebSocket_Dev* GetPPB_WebSocket_Dev_Thunk() {
+  return &g_ppb_websocket_thunk;
+}
+
+}  // namespace thunk
+}  // namespace ppapi

ppapi/thunk/resource_creation_api.h

@@ -19,6 +19,7 @@
 #include "ppapi/c/ppb_input_event.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/dev/ppb_transport_dev.h"
+#include "ppapi/c/dev/ppb_websocket_dev.h"
 #include "ppapi/shared_impl/api_id.h"
 
 struct PP_Flash_Menu;
@@ -131,6 +132,7 @@ class ResourceCreationAPI {
       PP_VideoDecoder_Profile profile) = 0;
   virtual PP_Resource CreateVideoLayer(PP_Instance instance,
                                        PP_VideoLayerMode_Dev mode) = 0;
+  virtual PP_Resource CreateWebSocket(PP_Instance instance) = 0;
   virtual PP_Resource CreateWheelInputEvent(
       PP_Instance instance,
       PP_TimeTicks time_stamp,

webkit/glue/webkit_glue.gypi

@@ -307,6 +307,8 @@
         '../plugins/ppapi/ppb_video_layer_impl.h',
         '../plugins/ppapi/ppb_video_layer_software.cc',
         '../plugins/ppapi/ppb_video_layer_software.h',
+        '../plugins/ppapi/ppb_websocket_impl.cc',
+        '../plugins/ppapi/ppb_websocket_impl.h',
         '../plugins/ppapi/ppb_widget_impl.cc',
         '../plugins/ppapi/ppb_widget_impl.h',
         '../plugins/ppapi/quota_file_io.cc',

webkit/plugins/ppapi/ppb_websocket_impl.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 "webkit/plugins/ppapi/ppb_websocket_impl.h"
+
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/pp_var.h"
+
+using ppapi::thunk::PPB_WebSocket_API;
+
+namespace webkit {
+namespace ppapi {
+
+PPB_WebSocket_Impl::PPB_WebSocket_Impl(PP_Instance instance)
+    : Resource(instance) {
+}
+
+PPB_WebSocket_Impl::~PPB_WebSocket_Impl() {
+}
+
+// static
+PP_Resource PPB_WebSocket_Impl::Create(PP_Instance instance) {
+  scoped_refptr<PPB_WebSocket_Impl> ws(new PPB_WebSocket_Impl(instance));
+  return ws->GetReference();
+}
+
+PPB_WebSocket_API* PPB_WebSocket_Impl::AsPPB_WebSocket_API() {
+  return this;
+}
+
+int32_t PPB_WebSocket_Impl::Connect(PP_Var url,
+                                    const PP_Var protocols[],
+                                    uint32_t protocol_count,
+                                    PP_CompletionCallback callback) {
+  // TODO(toyoshim): Implement it.
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t PPB_WebSocket_Impl::Close(uint16_t code,
+                                  PP_Var reason,
+                                  PP_CompletionCallback callback) {
+  // TODO(toyoshim): Implement it.
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t PPB_WebSocket_Impl::ReceiveMessage(PP_Var* message,
+                                           PP_CompletionCallback callback) {
+  // TODO(toyoshim): Implement it.
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t PPB_WebSocket_Impl::SendMessage(PP_Var message) {
+  // TODO(toyoshim): Implement it.
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+uint64_t PPB_WebSocket_Impl::GetBufferedAmount() {
+  // TODO(toyoshim): Implement it.
+  return 0;
+}
+
+uint16_t PPB_WebSocket_Impl::GetCloseCode() {
+  // TODO(toyoshim): Implement it.
+  return 0;
+}
+
+PP_Var PPB_WebSocket_Impl::GetCloseReason() {
+  // TODO(toyoshim): Implement it.
+  return PP_MakeUndefined();
+}
+
+PP_Bool PPB_WebSocket_Impl::GetCloseWasClean() {
+  // TODO(toyoshim): Implement it.
+  return PP_FALSE;
+}
+
+PP_Var PPB_WebSocket_Impl::GetExtensions() {
+  // TODO(toyoshim): Implement it.
+  return PP_MakeUndefined();
+}
+
+PP_Var PPB_WebSocket_Impl::GetProtocol() {
+  // TODO(toyoshim): Implement it.
+  return PP_MakeUndefined();
+}
+
+PP_WebSocketReadyState_Dev PPB_WebSocket_Impl::GetReadyState() {
+  // TODO(toyoshim): Implement it.
+  return PP_WEBSOCKETREADYSTATE_INVALID_DEV;
+}
+
+PP_Var PPB_WebSocket_Impl::GetURL() {
+  // TODO(toyoshim): Implement it.
+  return PP_MakeUndefined();
+}
+
+}  // namespace ppapi
+}  // namespace webkit

webkit/plugins/ppapi/ppb_websocket_impl.h

+// 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.
+
+#ifndef WEBKIT_PLUGINS_PPAPI_PPB_WEBSOCKET_IMPL_H_
+#define WEBKIT_PLUGINS_PPAPI_PPB_WEBSOCKET_IMPL_H_
+
+#include "ppapi/shared_impl/resource.h"
+#include "ppapi/thunk/ppb_websocket_api.h"
+
+namespace webkit {
+namespace ppapi {
+
+// All implementation is in this class for now. We should move some common
+// implementation to shared_impl when we implement proxy interfaces.
+class PPB_WebSocket_Impl : public ::ppapi::Resource,
+                           public ::ppapi::thunk::PPB_WebSocket_API {
+ public:
+  explicit PPB_WebSocket_Impl(PP_Instance instance);
+  virtual ~PPB_WebSocket_Impl();
+
+  static PP_Resource Create(PP_Instance instance);
+
+  // Resource overrides.
+  virtual ::ppapi::thunk::PPB_WebSocket_API* AsPPB_WebSocket_API() OVERRIDE;
+
+  // PPB_WebSocket_API implementation.
+  virtual int32_t Connect(PP_Var url,
+                          const PP_Var protocols[],
+                          uint32_t protocol_count,
+                          PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t Close(uint16_t code,
+                        PP_Var reason,
+                        PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t ReceiveMessage(PP_Var* message,
+                                 PP_CompletionCallback callbac) OVERRIDE;
+  virtual int32_t SendMessage(PP_Var message) OVERRIDE;
+  virtual uint64_t GetBufferedAmount() OVERRIDE;
+  virtual uint16_t GetCloseCode() OVERRIDE;
+  virtual PP_Var GetCloseReason() OVERRIDE;
+  virtual PP_Bool GetCloseWasClean() OVERRIDE;
+  virtual PP_Var GetExtensions() OVERRIDE;
+  virtual PP_Var GetProtocol() OVERRIDE;
+  virtual PP_WebSocketReadyState_Dev GetReadyState() OVERRIDE;
+  virtual PP_Var GetURL() OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(PPB_WebSocket_Impl);
+};
+
+}  // namespace ppapi
+}  // namespace webkit
+
+#endif  // WEBKIT_PLUGINS_PPAPI_PPB_WEBSOCKET_IMPL_H_

webkit/plugins/ppapi/resource_creation_impl.cc

@@ -33,6 +33,7 @@
 #include "webkit/plugins/ppapi/ppb_video_capture_impl.h"
 #include "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 #include "webkit/plugins/ppapi/ppb_video_layer_impl.h"
+#include "webkit/plugins/ppapi/ppb_websocket_impl.h"
 
 using ppapi::InputEventData;
 using ppapi::InputEventImpl;
@@ -307,6 +308,10 @@ PP_Resource ResourceCreationImpl::CreateVideoLayer(PP_Instance instance,
   return PPB_VideoLayer_Impl::Create(instance, mode);
 }
 
+PP_Resource ResourceCreationImpl::CreateWebSocket(PP_Instance instance) {
+  return PPB_WebSocket_Impl::Create(instance);
+}
+
 PP_Resource ResourceCreationImpl::CreateWheelInputEvent(
     PP_Instance instance,
     PP_TimeTicks time_stamp,

webkit/plugins/ppapi/resource_creation_impl.h

@@ -116,6 +116,7 @@ class ResourceCreationImpl : public ::ppapi::FunctionGroupBase,
       PP_VideoDecoder_Profile profile) OVERRIDE;
   virtual PP_Resource CreateVideoLayer(PP_Instance instance,
                                        PP_VideoLayerMode_Dev mode) OVERRIDE;
+  virtual PP_Resource CreateWebSocket(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateWheelInputEvent(
       PP_Instance instance,
       PP_TimeTicks time_stamp,