Apps v2 in Pepper: Add C/C++ definition for chrome.socket.

BUG=226303
TEST=None


Review URL: https://chromiumcodereview.appspot.com/13490003

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

4 files changed, 883 insertions, 4 deletions

diff --git a/ppapi/cpp/extensions/dev/socket_dev.cc b/ppapi/cpp/extensions/dev/socket_dev.cc
new file mode 100644
index 0000000..a2e8830
--- /dev/null
+++ b/ppapi/cpp/extensions/dev/socket_dev.cc
@@ -0,0 +1,479 @@
+// Copyright (c) 2013 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/cpp/extensions/dev/socket_dev.h"
+
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/extensions/optional.h"
+#include "ppapi/cpp/extensions/to_var_converter.h"
+#include "ppapi/cpp/logging.h"
+#include "ppapi/cpp/module_impl.h"
+
+namespace pp {
+
+namespace {
+
+template <> const char* interface_name<PPB_Ext_Socket_Dev_0_1>() {
+  return PPB_EXT_SOCKET_DEV_INTERFACE_0_1;
+}
+
+}  // namespace
+
+namespace ext {
+namespace socket {
+
+const char* const SocketType_Dev::kTcp = "tcp";
+const char* const SocketType_Dev::kUdp = "udp";
+
+SocketType_Dev::SocketType_Dev() : value(NONE) {
+}
+
+SocketType_Dev::SocketType_Dev(ValueType in_value) : value(in_value) {
+}
+
+SocketType_Dev::~SocketType_Dev() {
+}
+
+bool SocketType_Dev::Populate(const PP_Var& var_value) {
+  if (var_value.type != PP_VARTYPE_STRING)
+    return false;
+
+  std::string string_value = Var(var_value).AsString();
+  if (string_value == kTcp) {
+    value = TCP;
+  } else if (string_value == kUdp) {
+    value = UDP;
+  } else {
+    value = NONE;
+    return false;
+  }
+  return true;
+}
+
+Var SocketType_Dev::CreateVar() const {
+  switch (value) {
+    case TCP:
+      return Var(kTcp);
+    case UDP:
+      return Var(kUdp);
+    default:
+      PP_NOTREACHED();
+      return Var(std::string());
+  }
+}
+
+const char* const CreateInfo_Dev::kSocketId = "socketId";
+
+CreateInfo_Dev::CreateInfo_Dev()
+    : socket_id(kSocketId) {
+}
+
+CreateInfo_Dev::~CreateInfo_Dev() {
+}
+
+bool CreateInfo_Dev::Populate(const PP_Ext_Socket_CreateInfo_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = socket_id.Populate(dict);
+
+  return result;
+}
+
+Var CreateInfo_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = socket_id.AddTo(&dict);
+  // Suppress unused variable warnings.
+  static_cast<void>(result);
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+const char* const AcceptInfo_Dev::kResultCode = "resultCode";
+const char* const AcceptInfo_Dev::kSocketId = "socketId";
+
+AcceptInfo_Dev::AcceptInfo_Dev()
+    : result_code(kResultCode),
+      socket_id(kSocketId) {
+}
+
+AcceptInfo_Dev::~AcceptInfo_Dev() {
+}
+
+bool AcceptInfo_Dev::Populate(const PP_Ext_Socket_AcceptInfo_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = result_code.Populate(dict);
+  result = socket_id.Populate(dict) && result;
+
+  return result;
+}
+
+Var AcceptInfo_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = result_code.AddTo(&dict);
+  result = socket_id.MayAddTo(&dict) && result;
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+const char* const ReadInfo_Dev::kResultCode = "resultCode";
+const char* const ReadInfo_Dev::kData = "data";
+
+ReadInfo_Dev::ReadInfo_Dev()
+    : result_code(kResultCode),
+      data(kData) {
+}
+
+ReadInfo_Dev::~ReadInfo_Dev() {
+}
+
+bool ReadInfo_Dev::Populate(const PP_Ext_Socket_ReadInfo_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = result_code.Populate(dict);
+  result = data.Populate(dict) && result;
+
+  return result;
+}
+
+Var ReadInfo_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = result_code.AddTo(&dict);
+  result = data.AddTo(&dict) && result;
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+const char* const WriteInfo_Dev::kBytesWritten = "bytesWritten";
+
+WriteInfo_Dev::WriteInfo_Dev()
+    : bytes_written(kBytesWritten) {
+}
+
+WriteInfo_Dev::~WriteInfo_Dev() {
+}
+
+bool WriteInfo_Dev::Populate(const PP_Ext_Socket_WriteInfo_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = bytes_written.Populate(dict);
+
+  return result;
+}
+
+Var WriteInfo_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = bytes_written.AddTo(&dict);
+  // Suppress unused variable warnings.
+  static_cast<void>(result);
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+const char* const RecvFromInfo_Dev::kResultCode = "resultCode";
+const char* const RecvFromInfo_Dev::kData = "data";
+const char* const RecvFromInfo_Dev::kAddress = "address";
+const char* const RecvFromInfo_Dev::kPort = "port";
+
+RecvFromInfo_Dev::RecvFromInfo_Dev()
+    : result_code(kResultCode),
+      data(kData),
+      address(kAddress),
+      port(kPort) {
+}
+
+RecvFromInfo_Dev::~RecvFromInfo_Dev() {
+}
+
+bool RecvFromInfo_Dev::Populate(const PP_Ext_Socket_RecvFromInfo_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = result_code.Populate(dict);
+  result = data.Populate(dict) && result;
+  result = address.Populate(dict) && result;
+  result = port.Populate(dict) && result;
+
+  return result;
+}
+
+Var RecvFromInfo_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = result_code.AddTo(&dict);
+  result = data.AddTo(&dict) && result;
+  result = address.AddTo(&dict) && result;
+  result = port.AddTo(&dict) && result;
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+const char* const SocketInfo_Dev::kSocketType = "socketType";
+const char* const SocketInfo_Dev::kConnected = "connected";
+const char* const SocketInfo_Dev::kPeerAddress = "peerAddress";
+const char* const SocketInfo_Dev::kPeerPort = "peerPort";
+const char* const SocketInfo_Dev::kLocalAddress = "localAddress";
+const char* const SocketInfo_Dev::kLocalPort = "localPort";
+
+SocketInfo_Dev::SocketInfo_Dev()
+    : socket_type(kSocketType),
+      connected(kConnected),
+      peer_address(kPeerAddress),
+      peer_port(kPeerPort),
+      local_address(kLocalAddress),
+      local_port(kLocalPort) {
+}
+
+SocketInfo_Dev::~SocketInfo_Dev() {
+}
+
+bool SocketInfo_Dev::Populate(const PP_Ext_Socket_SocketInfo_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = socket_type.Populate(dict);
+  result = connected.Populate(dict) && result;
+  result = peer_address.Populate(dict) && result;
+  result = peer_port.Populate(dict) && result;
+  result = local_address.Populate(dict) && result;
+  result = local_port.Populate(dict) && result;
+
+  return result;
+}
+
+Var SocketInfo_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = socket_type.AddTo(&dict);
+  result = connected.AddTo(&dict) && result;
+  result = peer_address.MayAddTo(&dict) && result;
+  result = peer_port.MayAddTo(&dict) && result;
+  result = local_address.MayAddTo(&dict) && result;
+  result = local_port.MayAddTo(&dict) && result;
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+const char* const NetworkInterface_Dev::kName = "name";
+const char* const NetworkInterface_Dev::kAddress = "address";
+
+NetworkInterface_Dev::NetworkInterface_Dev()
+    : name(kName),
+      address(kAddress) {
+}
+
+NetworkInterface_Dev::~NetworkInterface_Dev() {
+}
+
+bool NetworkInterface_Dev::Populate(
+    const PP_Ext_Socket_NetworkInterface_Dev& value) {
+  if (value.type != PP_VARTYPE_DICTIONARY)
+    return false;
+
+  VarDictionary_Dev dict(value);
+  bool result = name.Populate(dict);
+  result = address.Populate(dict) && result;
+
+  return result;
+}
+
+Var NetworkInterface_Dev::CreateVar() const {
+  VarDictionary_Dev dict;
+
+  bool result = name.AddTo(&dict);
+  result = address.AddTo(&dict) && result;
+  PP_DCHECK(result);
+
+  return dict;
+}
+
+Socket_Dev::Socket_Dev(const InstanceHandle& instance) : instance_(instance) {
+}
+
+Socket_Dev::~Socket_Dev() {
+}
+
+int32_t Socket_Dev::Create(
+    const SocketType_Dev& type,
+    const Optional<CreateOptions_Dev>& options,
+    const CompletionCallbackWithOutput<CreateInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<SocketType_Dev> type_var(type);
+  internal::ToVarConverter<Optional<CreateOptions_Dev> > options_var(options);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->Create(
+      instance_.pp_instance(),
+      type_var.pp_var(),
+      options_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+void Socket_Dev::Destroy(int32_t socket_id) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return;
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->Destroy(
+      instance_.pp_instance(),
+      socket_id_var.pp_var());
+}
+
+void Socket_Dev::Disconnect(int32_t socket_id) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return;
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->Disconnect(
+      instance_.pp_instance(),
+      socket_id_var.pp_var());
+}
+
+int32_t Socket_Dev::Read(
+    int32_t socket_id,
+    const Optional<int32_t>& buffer_size,
+    const CompletionCallbackWithOutput<ReadInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+  internal::ToVarConverter<Optional<int32_t> > buffer_size_var(buffer_size);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->Read(
+      instance_.pp_instance(),
+      socket_id_var.pp_var(),
+      buffer_size_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+int32_t Socket_Dev::Write(
+    int32_t socket_id,
+    const Var& data,
+    const CompletionCallbackWithOutput<WriteInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+  internal::ToVarConverter<Var> data_var(data);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->Write(
+      instance_.pp_instance(),
+      socket_id_var.pp_var(),
+      data_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+int32_t Socket_Dev::RecvFrom(
+    int32_t socket_id,
+    const Optional<int32_t>& buffer_size,
+    const CompletionCallbackWithOutput<RecvFromInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+  internal::ToVarConverter<Optional<int32_t> > buffer_size_var(buffer_size);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->RecvFrom(
+      instance_.pp_instance(),
+      socket_id_var.pp_var(),
+      buffer_size_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+int32_t Socket_Dev::SendTo(
+    int32_t socket_id,
+    const Var& data,
+    const std::string& address,
+    int32_t port,
+    const CompletionCallbackWithOutput<WriteInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+  internal::ToVarConverter<Var> data_var(data);
+  internal::ToVarConverter<std::string> address_var(address);
+  internal::ToVarConverter<int32_t> port_var(port);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->SendTo(
+      instance_.pp_instance(),
+      socket_id_var.pp_var(),
+      data_var.pp_var(),
+      address_var.pp_var(),
+      port_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+int32_t Socket_Dev::Accept(
+    int32_t socket_id,
+    const CompletionCallbackWithOutput<AcceptInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->Accept(
+      instance_.pp_instance(),
+      socket_id_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+int32_t Socket_Dev::GetInfo(
+    int32_t socket_id,
+    const CompletionCallbackWithOutput<SocketInfo_Dev>& callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  internal::ToVarConverter<int32_t> socket_id_var(socket_id);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->GetInfo(
+      instance_.pp_instance(),
+      socket_id_var.pp_var(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+int32_t Socket_Dev::GetNetworkList(
+    const CompletionCallbackWithOutput<std::vector<NetworkInterface_Dev> >&
+        callback) {
+  if (!has_interface<PPB_Ext_Socket_Dev_0_1>())
+    return callback.MayForce(PP_ERROR_NOINTERFACE);
+
+  return get_interface<PPB_Ext_Socket_Dev_0_1>()->GetNetworkList(
+      instance_.pp_instance(),
+      callback.output(),
+      callback.pp_completion_callback());
+}
+
+}  // namespace socket
+}  // namespace ext
+}  // namespace pp
diff --git a/ppapi/cpp/extensions/dev/socket_dev.h b/ppapi/cpp/extensions/dev/socket_dev.h
new file mode 100644
index 0000000..5d2e5be
--- /dev/null
+++ b/ppapi/cpp/extensions/dev/socket_dev.h
@@ -0,0 +1,243 @@
+// Copyright (c) 2013 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_CPP_EXTENSIONS_DEV_SOCKET_DEV_H_
+#define PPAPI_CPP_EXTENSIONS_DEV_SOCKET_DEV_H_
+
+#include <string>
+#include <vector>
+
+#include "ppapi/c/extensions/dev/ppb_ext_socket_dev.h"
+#include "ppapi/cpp/dev/var_dictionary_dev.h"
+#include "ppapi/cpp/extensions/dict_field.h"
+#include "ppapi/cpp/extensions/ext_output_traits.h"
+#include "ppapi/cpp/instance_handle.h"
+#include "ppapi/cpp/var.h"
+#include "ppapi/cpp/var_array_buffer.h"
+
+namespace pp {
+
+template <class T>
+class CompletionCallbackWithOutput;
+
+namespace ext {
+
+template <class T>
+class Optional;
+
+namespace socket {
+
+// Data types ------------------------------------------------------------------
+class SocketType_Dev {
+ public:
+  enum ValueType {
+    NONE,
+    TCP,
+    UDP
+  };
+
+  SocketType_Dev();
+  SocketType_Dev(ValueType in_value);
+  ~SocketType_Dev();
+
+  bool Populate(const PP_Var& var_value);
+
+  Var CreateVar() const;
+
+  ValueType value;
+
+  static const char* const kTcp;
+  static const char* const kUdp;
+};
+
+typedef VarDictionary_Dev CreateOptions_Dev;
+
+class CreateInfo_Dev : public internal::OutputObjectBase {
+ public:
+  CreateInfo_Dev();
+  ~CreateInfo_Dev();
+
+  bool Populate(const PP_Ext_Socket_CreateInfo_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kSocketId;
+
+  DictField<int32_t> socket_id;
+};
+
+class AcceptInfo_Dev : public internal::OutputObjectBase {
+ public:
+  AcceptInfo_Dev();
+  ~AcceptInfo_Dev();
+
+  bool Populate(const PP_Ext_Socket_AcceptInfo_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kResultCode;
+  static const char* const kSocketId;
+
+  DictField<int32_t> result_code;
+  OptionalDictField<int32_t> socket_id;
+};
+
+class ReadInfo_Dev : public internal::OutputObjectBase {
+ public:
+  ReadInfo_Dev();
+  ~ReadInfo_Dev();
+
+  bool Populate(const PP_Ext_Socket_ReadInfo_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kResultCode;
+  static const char* const kData;
+
+  DictField<int32_t> result_code;
+  // TODO(yzshen): It is more natural to use VarArrayBuffer, but it doesn't have
+  // a default constructor currently.
+  DictField<Var> data;
+};
+
+class WriteInfo_Dev : public internal::OutputObjectBase {
+ public:
+  WriteInfo_Dev();
+  ~WriteInfo_Dev();
+
+  bool Populate(const PP_Ext_Socket_WriteInfo_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kBytesWritten;
+
+  DictField<int32_t> bytes_written;
+};
+
+class RecvFromInfo_Dev : public internal::OutputObjectBase {
+ public:
+  RecvFromInfo_Dev();
+  ~RecvFromInfo_Dev();
+
+  bool Populate(const PP_Ext_Socket_RecvFromInfo_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kResultCode;
+  static const char* const kData;
+  static const char* const kAddress;
+  static const char* const kPort;
+
+  DictField<int32_t> result_code;
+  DictField<Var> data;
+  DictField<std::string> address;
+  DictField<int32_t> port;
+};
+
+class SocketInfo_Dev : public internal::OutputObjectBase {
+ public:
+  SocketInfo_Dev();
+  ~SocketInfo_Dev();
+
+  bool Populate(const PP_Ext_Socket_SocketInfo_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kSocketType;
+  static const char* const kConnected;
+  static const char* const kPeerAddress;
+  static const char* const kPeerPort;
+  static const char* const kLocalAddress;
+  static const char* const kLocalPort;
+
+  DictField<SocketType_Dev> socket_type;
+  DictField<bool> connected;
+  OptionalDictField<std::string> peer_address;
+  OptionalDictField<int32_t> peer_port;
+  OptionalDictField<std::string> local_address;
+  OptionalDictField<int32_t> local_port;
+};
+
+class NetworkInterface_Dev : public internal::OutputObjectBase {
+ public:
+  NetworkInterface_Dev();
+  ~NetworkInterface_Dev();
+
+  bool Populate(const PP_Ext_Socket_NetworkInterface_Dev& value);
+
+  Var CreateVar() const;
+
+  static const char* const kName;
+  static const char* const kAddress;
+
+  DictField<std::string> name;
+  DictField<std::string> address;
+};
+
+// Functions -------------------------------------------------------------------
+class Socket_Dev {
+ public:
+  explicit Socket_Dev(const InstanceHandle& instance);
+  ~Socket_Dev();
+
+  int32_t Create(const SocketType_Dev& type,
+                 const Optional<CreateOptions_Dev>& options,
+                 const CompletionCallbackWithOutput<CreateInfo_Dev>& callback);
+  void Destroy(int32_t socket_id);
+  // TODO(yzshen): Support more powerful traits.
+  //int32_t Connect(int32_t socket_id,
+  //                const std::string& hostname,
+  //                int32_t port,
+  //                const CompletionCallbackWithOutput<int32_t>& callback);
+  //int32_t Bind(int32_t socket_id,
+  //             const std::string& address,
+  //             int32_t port,
+  //             const CompletionCallbackWithOutput<int32_t>& callback);
+  void Disconnect(int32_t socket_id);
+  int32_t Read(int32_t socket_id,
+               const Optional<int32_t>& buffer_size,
+               const CompletionCallbackWithOutput<ReadInfo_Dev>& callback);
+  int32_t Write(int32_t socket_id,
+                const Var& data,
+                const CompletionCallbackWithOutput<WriteInfo_Dev>& callback);
+  int32_t RecvFrom(
+      int32_t socket_id,
+      const Optional<int32_t>& buffer_size,
+      const CompletionCallbackWithOutput<RecvFromInfo_Dev>& callback);
+  int32_t SendTo(int32_t socket_id,
+                 const Var& data,
+                 const std::string& address,
+                 int32_t port,
+                 const CompletionCallbackWithOutput<WriteInfo_Dev>& callback);
+  // TODO(yzshen): Support more powerful traits.
+  //int32_t Listen(int32_t socket_id,
+  //               const std::string& address,
+  //               int32_t port,
+  //               const Optional<int32_t>& backlog,
+  //               const CompletionCallbackWithOutput<int32_t>& callback);
+  int32_t Accept(int32_t socket_id,
+                 const CompletionCallbackWithOutput<AcceptInfo_Dev>& callback);
+  // TODO(yzshen): Support more powerful traits.
+  //int32_t SetKeepAlive(int32_t socket_id,
+  //                     bool enable,
+  //                     const Optional<int32_t>& delay,
+  //                     const CompletionCallbackWithOutput<bool>& callback);
+  //int32_t SetNoDelay(int32_t socket_id,
+  //                   bool no_delay,
+  //                   const CompletionCallbackWithOutput<bool>& callback);
+  int32_t GetInfo(int32_t socket_id,
+                  const CompletionCallbackWithOutput<SocketInfo_Dev>& callback);
+  int32_t GetNetworkList(
+      const CompletionCallbackWithOutput<std::vector<NetworkInterface_Dev> >&
+          callback);
+
+ private:
+  InstanceHandle instance_;
+};
+
+}  // namespace socket
+}  // namespace ext
+}  // namespace pp
+
+#endif  // PPAPI_CPP_EXTENSIONS_DEV_SOCKET_DEV_H_
diff --git a/ppapi/cpp/extensions/from_var_converter.h b/ppapi/cpp/extensions/from_var_converter.h
index 6fb8a32..ddafe1d 100644
--- a/ppapi/cpp/extensions/from_var_converter.h
+++ b/ppapi/cpp/extensions/from_var_converter.h
@@ -8,6 +8,8 @@
 #include <string>
 
 #include "ppapi/c/pp_var.h"
+#include "ppapi/cpp/dev/var_array_dev.h"
+#include "ppapi/cpp/dev/var_dictionary_dev.h"
 #include "ppapi/cpp/extensions/optional.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/var.h"
@@ -80,7 +82,7 @@ class FromVarConverter<Optional<T> >
 };
 
 template <>
-class FromVarConverter<std::string> : public FromVarConverterBase<std::string> {
+class FromVarConverter<bool> : public FromVarConverterBase<bool> {
  public:
   FromVarConverter() {
   }
@@ -93,7 +95,25 @@ class FromVarConverter<std::string> : public FromVarConverterBase<std::string> {
   }
 
   void Set(const PP_Var& var) {
-    FromVarConverterBase<std::string>::value_ = Var(var).AsString();
+    FromVarConverterBase<bool>::value_ = Var(var).AsBool();
+  }
+};
+
+template <>
+class FromVarConverter<int32_t> : public FromVarConverterBase<int32_t> {
+ public:
+  FromVarConverter() {
+  }
+
+  FromVarConverter(const PP_Var& var) {
+    Set(var);
+  }
+
+  ~FromVarConverter() {
+  }
+
+  void Set(const PP_Var& var) {
+    FromVarConverterBase<int32_t>::value_ = Var(var).AsInt();
   }
 };
 
@@ -115,6 +135,80 @@ class FromVarConverter<double> : public FromVarConverterBase<double> {
   }
 };
 
+template <>
+class FromVarConverter<std::string> : public FromVarConverterBase<std::string> {
+ public:
+  FromVarConverter() {
+  }
+
+  FromVarConverter(const PP_Var& var) {
+    Set(var);
+  }
+
+  ~FromVarConverter() {
+  }
+
+  void Set(const PP_Var& var) {
+    FromVarConverterBase<std::string>::value_ = Var(var).AsString();
+  }
+};
+
+template <>
+class FromVarConverter<Var> : public FromVarConverterBase<Var> {
+ public:
+  FromVarConverter() {
+  }
+
+  FromVarConverter(const PP_Var& var) {
+    Set(var);
+  }
+
+  ~FromVarConverter() {
+  }
+
+  void Set(const PP_Var& var) {
+    FromVarConverterBase<Var>::value_ = Var(var);
+  }
+};
+
+template <>
+class FromVarConverter<VarArray_Dev>
+    : public FromVarConverterBase<VarArray_Dev> {
+ public:
+  FromVarConverter() {
+  }
+
+  FromVarConverter(const PP_Var& var) {
+    Set(var);
+  }
+
+  ~FromVarConverter() {
+  }
+
+  void Set(const PP_Var& var) {
+    FromVarConverterBase<VarArray_Dev>::value_ = Var(var);
+  }
+};
+
+template <>
+class FromVarConverter<VarDictionary_Dev>
+    : public FromVarConverterBase<VarDictionary_Dev> {
+ public:
+  FromVarConverter() {
+  }
+
+  FromVarConverter(const PP_Var& var) {
+    Set(var);
+  }
+
+  ~FromVarConverter() {
+  }
+
+  void Set(const PP_Var& var) {
+    FromVarConverterBase<VarDictionary_Dev>::value_ = Var(var);
+  }
+};
+
 }  // namespace internal
 }  // namespace ext
 }  // namespace pp
diff --git a/ppapi/cpp/extensions/to_var_converter.h b/ppapi/cpp/extensions/to_var_converter.h
index ba05064..5913652 100644
--- a/ppapi/cpp/extensions/to_var_converter.h
+++ b/ppapi/cpp/extensions/to_var_converter.h
@@ -8,8 +8,11 @@
 #include <string>
 
 #include "ppapi/c/pp_var.h"
+#include "ppapi/cpp/dev/var_array_dev.h"
+#include "ppapi/cpp/dev/var_dictionary_dev.h"
 #include "ppapi/cpp/extensions/optional.h"
 #include "ppapi/cpp/var.h"
+#include "ppapi/cpp/var_array_buffer.h"
 
 namespace pp {
 namespace ext {
@@ -66,6 +69,36 @@ class ToVarConverter<Optional<T> > : public ToVarConverterBase {
 };
 
 template <>
+class ToVarConverter<bool> : public ToVarConverterBase {
+ public:
+  explicit ToVarConverter(bool object) : ToVarConverterBase(Var(object)) {
+  }
+
+  ~ToVarConverter() {
+  }
+};
+
+template <>
+class ToVarConverter<int32_t> : public ToVarConverterBase {
+ public:
+  explicit ToVarConverter(int32_t object) : ToVarConverterBase(Var(object)) {
+  }
+
+  ~ToVarConverter() {
+  }
+};
+
+template <>
+class ToVarConverter<double> : public ToVarConverterBase {
+ public:
+  explicit ToVarConverter(double object) : ToVarConverterBase(Var(object)) {
+  }
+
+  ~ToVarConverter() {
+  }
+};
+
+template <>
 class ToVarConverter<std::string> : public ToVarConverterBase {
  public:
   explicit ToVarConverter(const std::string& object)
@@ -77,9 +110,39 @@ class ToVarConverter<std::string> : public ToVarConverterBase {
 };
 
 template <>
-class ToVarConverter<double> : public ToVarConverterBase {
+class ToVarConverter<Var> : public ToVarConverterBase {
  public:
-  explicit ToVarConverter(double object) : ToVarConverterBase(Var(object)) {
+  explicit ToVarConverter(const Var& object) : ToVarConverterBase(object) {
+  }
+
+  ~ToVarConverter() {
+  }
+};
+
+template <>
+class ToVarConverter<VarArray_Dev> : public ToVarConverterBase {
+ public:
+  explicit ToVarConverter(const Var& object) : ToVarConverterBase(object) {
+  }
+
+  ~ToVarConverter() {
+  }
+};
+
+template <>
+class ToVarConverter<VarDictionary_Dev> : public ToVarConverterBase {
+ public:
+  explicit ToVarConverter(const Var& object) : ToVarConverterBase(object) {
+  }
+
+  ~ToVarConverter() {
+  }
+};
+
+template <>
+class ToVarConverter<VarArrayBuffer> : public ToVarConverterBase {
+ public:
+  explicit ToVarConverter(const Var& object) : ToVarConverterBase(object) {
   }
 
   ~ToVarConverter() {