ppapi: PPB_VpnProvider: Define API

ppapi/proxy/vpn_provider_resource.cc

+// Copyright 2015 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/proxy/vpn_provider_resource.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/proxy/dispatch_reply_message.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/array_var.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/proxy_lock.h"
+#include "ppapi/shared_impl/tracked_callback.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/shared_impl/var_tracker.h"
+
+namespace ppapi {
+namespace proxy {
+
+VpnProviderResource::VpnProviderResource(Connection connection,
+                                         PP_Instance instance)
+    : PluginResource(connection, instance),
+      get_unbind_event_callback_(NULL),
+      receive_packet_callback_var_(NULL) {
+  SendCreate(BROWSER, PpapiHostMsg_VpnProvider_Create());
+}
+
+VpnProviderResource::~VpnProviderResource() {}
+
+thunk::PPB_VpnProvider_API* VpnProviderResource::AsPPB_VpnProvider_API() {
+  return this;
+}
+
+void VpnProviderResource::OnReplyReceived(
+    const ResourceMessageReplyParams& params,
+    const IPC::Message& msg) {
+  PPAPI_BEGIN_MESSAGE_MAP(VpnProviderResource, msg)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(PpapiPluginMsg_VpnProvider_OnUnBind,
+                                        OnPluginMsgOnUnBindReceived)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_VpnProvider_OnPacketReceived,
+        OnPluginMsgOnPacketReceived)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
+        PluginResource::OnReplyReceived(params, msg))
+  PPAPI_END_MESSAGE_MAP()
+}
+
+int32_t VpnProviderResource::Bind(
+    const PP_Var& configuration_id,
+    const PP_Var& configuration_name,
+    const scoped_refptr<TrackedCallback>& callback) {
+  if (TrackedCallback::IsPending(bind_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  StringVar* configuration_id_var = StringVar::FromPPVar(configuration_id);
+  if (!configuration_id_var)
+    return PP_ERROR_BADARGUMENT;
+  StringVar* configuration_name_var = StringVar::FromPPVar(configuration_name);
+  if (!configuration_name_var)
+    return PP_ERROR_BADARGUMENT;
+
+  bind_callback_ = callback;
+
+  Call<PpapiPluginMsg_VpnProvider_BindReply>(
+      BROWSER, PpapiHostMsg_VpnProvider_Bind(configuration_id_var->value(),
+                                             configuration_name_var->value()),
+      base::Bind(&VpnProviderResource::OnPluginMsgBindReply, this));
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t VpnProviderResource::GetUnBindEvent(
+    const scoped_refptr<TrackedCallback>& callback) {
+  if (TrackedCallback::IsPending(get_unbind_event_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  // Or install |callback|.
+  get_unbind_event_callback_ = callback;
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t VpnProviderResource::SendPacket(
+    const PP_Var& data,
+    const scoped_refptr<TrackedCallback>& callback) {
+  if (!ArrayBufferVar::FromPPVar(data))
+    return PP_ERROR_BADARGUMENT;
+  if (TrackedCallback::IsPending(send_packet_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  uint32_t id;
+  if (send_packet_buffer_.get() && send_packet_buffer_->GetAvailable(&id)) {
+    // Send packet immeditatelly
+    send_packet_buffer_->SetAvailable(id, false);
+    return DoSendPacket(data, id);
+  } else {
+    // Packet will be sent later
+    send_packet_callback_ = callback;
+    PpapiGlobals::Get()->GetVarTracker()->AddRefVar(data);
+    send_packets_.push(data);
+
+    return PP_OK_COMPLETIONPENDING;
+  }
+}
+
+int32_t VpnProviderResource::DoSendPacket(const PP_Var& data, uint32_t id) {
+  // Convert data to std::vector<char>, then send it.
+  scoped_refptr<ArrayBufferVar> data_arraybuffer =
+      ArrayBufferVar::FromPPVar(data);
+  if (!data_arraybuffer.get())
+    return PP_ERROR_BADARGUMENT;
+
+  char* data_pointer = static_cast<char*>(data_arraybuffer->Map());
+  uint32_t data_length = data_arraybuffer->ByteLength();
+  memcpy(send_packet_buffer_->GetBuffer(id), data_pointer, data_length);
+  data_arraybuffer->Unmap();
+
+  Call<PpapiPluginMsg_VpnProvider_SendPacketReply>(
+      BROWSER, PpapiHostMsg_VpnProvider_SendPacket(data_length, id),
+      base::Bind(&VpnProviderResource::OnPluginMsgSendPacketReply, this));
+
+  return PP_OK;
+}
+
+int32_t VpnProviderResource::ReceivePacket(
+    PP_Var* data,
+    const scoped_refptr<TrackedCallback>& callback) {
+  if (TrackedCallback::IsPending(receive_packet_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  // Just return received packets if any received packet is queued.
+  if (!received_packets_.empty()) {
+    receive_packet_callback_var_ = data;
+    WritePacket();
+    return PP_OK;
+  }
+
+  // Or retain |packet| as buffer to store and install |callback|.
+  receive_packet_callback_var_ = data;
+  receive_packet_callback_ = callback;
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+// Responds to PpapiPluginMsg_VpnProvider_OnUnBind
+void VpnProviderResource::OnPluginMsgOnUnBindReceived(
+    const ResourceMessageReplyParams& params) {
+  if (!TrackedCallback::IsPending(get_unbind_event_callback_) ||
+      TrackedCallback::IsScheduledToRun(get_unbind_event_callback_)) {
+    return;
+  }
+
+  // The plugin may call GetUnBindEvent in its callback.
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(get_unbind_event_callback_);
+  callback->Run(PP_OK);
+}
+
+// Responds to PpapiPluginMsg_VpnProvider_OnPacketReceived
+void VpnProviderResource::OnPluginMsgOnPacketReceived(
+    const ResourceMessageReplyParams& params,
+    uint32_t data_length,
+    uint32_t id) {
+  // Append received packet to queue.
+  void* data_pointer = receive_packet_buffer_->GetBuffer(id);
+  scoped_refptr<Var> data_var(
+      PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferVar(data_length,
+                                                               data_pointer));
+  received_packets_.push(data_var);
+
+  // Mark shared memory as available for next packet
+  Post(BROWSER, PpapiHostMsg_VpnProvider_OnPacketReceivedReply(id));
+
+  if (!TrackedCallback::IsPending(receive_packet_callback_) ||
+      TrackedCallback::IsScheduledToRun(receive_packet_callback_)) {
+    return;
+  }
+
+  // The plugin may call GetPacket in its callback.
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(receive_packet_callback_);
+  WritePacket();
+  callback->Run(PP_OK);
+}
+
+// Responds to PpapiPluginMsg_VpnProvider_BindReply
+// Forwards to bind_callback_
+void VpnProviderResource::OnPluginMsgBindReply(
+    const ResourceMessageReplyParams& params,
+    uint32_t queue_depth,
+    uint32_t packet_size,
+    int32_t result) {
+  std::vector<base::SharedMemoryHandle> shm_handles;
+  params.TakeAllSharedMemoryHandles(&shm_handles);
+
+  std::unique_ptr<base::SharedMemory> send_shm(
+      new base::SharedMemory(shm_handles[0], false));
+  std::unique_ptr<base::SharedMemory> receive_shm(
+      new base::SharedMemory(shm_handles[1], false));
+  size_t buffer_size = queue_depth * packet_size;
+  if (!send_shm->Map(buffer_size))
+    return;
+  if (!receive_shm->Map(buffer_size))
+    return;
+  send_packet_buffer_ = base::WrapUnique(new ppapi::VpnProviderSharedBuffer(
+      queue_depth, packet_size, std::move(send_shm)));
+  receive_packet_buffer_ = base::WrapUnique(new ppapi::VpnProviderSharedBuffer(
+      queue_depth, packet_size, std::move(receive_shm)));
+
+  // The callback may have been aborted by Close().
+  if (TrackedCallback::IsPending(bind_callback_)) {
+    // The plugin may call DestroyConfig in its callback.
+    scoped_refptr<TrackedCallback> callback;
+    callback.swap(bind_callback_);
+    // On error:  Pass return code
+    // On succes: Pass message
+    callback->Run(params.result() ? params.result() : result);
+  }
+}
+
+// Responds to PpapiPluginMsg_VpnProvider_SendPacketReply
+// Forwards to send_packet_callback_
+void VpnProviderResource::OnPluginMsgSendPacketReply(
+    const ResourceMessageReplyParams& params,
+    int32_t id) {
+  if (!send_packets_.empty()) {
+    // Process remaining packets
+    DoSendPacket(send_packets_.front(), id);
+    PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(send_packets_.front());
+    send_packets_.pop();
+  } else {
+    send_packet_buffer_->SetAvailable(id, true);
+
+    // Avilable slots - Run callback to process new packets.
+    // The callback may have been aborted by Close().
+    if (TrackedCallback::IsPending(send_packet_callback_)) {
+      // The plugin may call SendPacket in its callback.
+      scoped_refptr<TrackedCallback> callback;
+      callback.swap(send_packet_callback_);
+      // On error:  Pass return code
+      // On succes: Pass message
+      callback->Run(PP_OK);
+    }
+  }
+}
+
+void VpnProviderResource::WritePacket() {
+  if (!receive_packet_callback_var_)
+    return;
+
+  *receive_packet_callback_var_ = received_packets_.front()->GetPPVar();
+  received_packets_.pop();
+  receive_packet_callback_var_ = NULL;
+}
+
+}  // namespace proxy
+}  // namespace ppapi