Add PPAPI interface for secure sockets in flash

ppapi/shared_impl/private/ppb_flash_x509_certificate_shared.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/shared_impl/private/ppb_flash_x509_certificate_shared.h"
+
+#include "ppapi/cpp/var.h"
+#include "ppapi/cpp/var_array_buffer.h"
+#include "ppapi/proxy/dispatcher.h"
+#include "ppapi/proxy/ppapi_param_traits.h"
+#include "ppapi/proxy/serialized_var.h"
+
+namespace ppapi {
+
+PPB_X509Certificate_Fields::PPB_X509Certificate_Fields() :
+    data_(PP_FLASH_X509CERTIFICATE_FIELD_COUNT, pp::Var())
+{
+}
+
+PPB_X509Certificate_Fields::~PPB_X509Certificate_Fields() {
+}
+
+pp::Var& PPB_X509Certificate_Fields::operator[](
+    const PP_Flash_X509Certificate_Field field) {
+  uint32_t index = static_cast<uint32_t>(field);
+  CHECK(index < data_.size());
+  return data_[index];
+}
+
+enum VarType {
+  ARRAY_BUFFER,
+  STRING,
+  UNDEFINED
+};
+
+void PPB_X509Certificate_Fields::WriteToMessage(IPC::Message* m) const {
+  // TODO(raymes): AFAICT there is no mechanism for serializing Vars for
+  // transfer between the browser process and the plugin process, so we do
+  // serialization of the fields here manually. This isn't ideal but it still
+  // saves a ton of boilerplate for handling each field separately.
+  for (size_t i = 0; i < data_.size(); ++i) {
+    if (data_[i].is_array_buffer()) {
+      IPC::ParamTraits<uint16_t>::Write(m, static_cast<uint16_t>(ARRAY_BUFFER));
+      pp::VarArrayBuffer array_buffer(data_[i]);
+      char* bytes = static_cast<char*>(array_buffer.Map());
+      std::vector<char> bytes_vector(bytes, bytes + array_buffer.ByteLength());
+      array_buffer.Unmap();
+      IPC::ParamTraits<std::vector<char> >::Write(m, bytes_vector);
+    } else if(data_[i].is_string()) {
+      IPC::ParamTraits<uint16_t>::Write(m, static_cast<uint16_t>(STRING));
+      IPC::ParamTraits<std::string>::Write(m, data_[i].AsString());
+    }
+    else if(data_[i].is_undefined()) {
+      IPC::ParamTraits<uint16_t>::Write(m, static_cast<uint16_t>(UNDEFINED));
+    }
+    else {
+      // Not expecting any other variable types to be fields.
+      CHECK(false);
+    }
+  }
+}
+
+bool PPB_X509Certificate_Fields::ReadFromMessage(
+    const IPC::Message* m, void** iter) {
+  bool result;
+  for (size_t i = 0; i < data_.size(); ++i) {
+    uint16_t type;
+    result = IPC::ParamTraits<uint16_t>::Read(m, iter, &type);
+    if (!result)
+      return false;
+
+    if (static_cast<VarType>(type) == ARRAY_BUFFER) {
+      std::vector<char> bytes_vector;
+      result = IPC::ParamTraits<std::vector<char> >::Read(m, iter,
+                                                          &bytes_vector);
+      if (!result)
+        return false;
+      pp::VarArrayBuffer array_buffer(bytes_vector.size());
+      if (!bytes_vector.empty()) {
+        char* bytes = static_cast<char*>(array_buffer.Map());
+        memcpy(bytes, &bytes_vector[0], bytes_vector.size());
+      }
+      array_buffer.Unmap();
+      data_[i] = array_buffer;
+    } else if (type == STRING) {
+      std::string string;
+      result = IPC::ParamTraits<std::string>::Read(m, iter, &string);
+      if (!result)
+        return false;
+      data_[i] = pp::Var(string);
+    }
+    else if (type == UNDEFINED) {
+      data_[i] = pp::Var();
+    }
+    else {
+      // Not expecting any other variable types to be fields.
+      CHECK(false);
+    }
+  }
+  return true;
+}
+
+//------------------------------------------------------------------------------
+
+PPB_Flash_X509Certificate_Shared::PPB_Flash_X509Certificate_Shared(
+    ResourceObjectType type,
+    PP_Instance instance) :
+    Resource(type, instance),
+    fields_(NULL) {
+}
+
+PPB_Flash_X509Certificate_Shared::PPB_Flash_X509Certificate_Shared(
+    ResourceObjectType type,
+    PP_Instance instance,
+    const PPB_X509Certificate_Fields& fields) :
+    Resource(type, instance),
+    fields_(new PPB_X509Certificate_Fields(fields))
+    {
+}
+
+PPB_Flash_X509Certificate_Shared::~PPB_Flash_X509Certificate_Shared() {
+}
+
+thunk::PPB_Flash_X509Certificate_API*
+PPB_Flash_X509Certificate_Shared::AsPPB_Flash_X509Certificate_API() {
+  return this;
+}
+
+PP_Bool PPB_Flash_X509Certificate_Shared::Init(const char* bytes,
+                                               uint32_t length) {
+  if (fields_.get())
+      return PP_FALSE;
+
+  if (!bytes || length == 0)
+    return PP_FALSE;
+
+  std::vector<char> der(bytes, bytes + length);
+  fields_.reset(new PPB_X509Certificate_Fields());
+  return PP_FromBool(ParseDER(der, fields_.get()));
+}
+
+PP_Var PPB_Flash_X509Certificate_Shared::GetField(
+    PP_Flash_X509Certificate_Field field) {
+  if (!fields_.get())
+    return PP_MakeUndefined();
+
+  return (*fields_)[field].pp_var();
+}
+
+bool PPB_Flash_X509Certificate_Shared::ParseDER(
+    const std::vector<char>& der,
+    PPB_X509Certificate_Fields* result) {
+  // A concrete PPB_Flash_X509Certificate_Shared should only ever be constructed
+  // by passing in PPB_X509Certificate_Fields, in which case it is already
+  // initialized.
+  CHECK(false);
+  return false;
+}
+
+}  // namespace ppapi