Add the PPAPI X509 Certificate interface and implementation.

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 "base/logging.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/shared_impl/var_tracker.h"
+
+namespace ppapi {
+
+PPB_X509Certificate_Fields::~PPB_X509Certificate_Fields() {
+}
+
+void PPB_X509Certificate_Fields::SetField(PP_Flash_X509Certificate_Field field,
+                                          base::Value* value) {
+  uint32_t index = static_cast<uint32_t>(field);
+  bool success = values_.Set(index, value);
+  DCHECK(success);
+}
+
+PP_Var PPB_X509Certificate_Fields::GetFieldAsPPVar(
+    PP_Flash_X509Certificate_Field field) const {
+  uint32_t index = static_cast<uint32_t>(field);
+  base::Value* value;
+  bool success = values_.Get(index, &value);
+  if (!success) {
+    // Our list received might be smaller than the number of fields, so just
+    // return null if the index is OOB.
+    return PP_MakeNull();
+  }
+
+  switch (value->GetType()) {
+    case Value::TYPE_NULL:
+      return PP_MakeNull();
+    case Value::TYPE_BOOLEAN: {
+      bool val;
+      value->GetAsBoolean(&val);
+      return PP_MakeBool(PP_FromBool(val));
+    }
+    case Value::TYPE_INTEGER: {
+      int val;
+      value->GetAsInteger(&val);
+      return PP_MakeInt32(val);
+    }
+    case Value::TYPE_DOUBLE: {
+      double val;
+      value->GetAsDouble(&val);
+      return PP_MakeDouble(val);
+    }
+    case Value::TYPE_STRING: {
+      std::string val;
+      value->GetAsString(&val);
+      return StringVar::StringToPPVar(val);
+    }
+    case Value::TYPE_BINARY: {
+      const base::BinaryValue* binary =
+          static_cast<const base::BinaryValue*>(value);
+      uint32_t size = static_cast<uint32_t>(binary->GetSize());
+      const char* buffer = binary->GetBuffer();
+      PP_Var array_buffer =
+          PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(size,
+                                                                     buffer);
+      return array_buffer;
+    }
+    case Value::TYPE_DICTIONARY:
+    case Value::TYPE_LIST:
+      // Not handled.
+      break;
+  }
+
+  // Should not reach here.
+  CHECK(false);
+  return PP_MakeUndefined();
+}
+
+//------------------------------------------------------------------------------
+
+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,
+    PPB_X509Certificate_Fields* fields) :
+    Resource(type, instance),
+    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) {
+  // The certificate should be immutable once initialized.
+  if (fields_.get())
+    return PP_FALSE;
+
+  if (!bytes || length == 0)
+    return PP_FALSE;
+
+  std::vector<char> der(bytes, bytes + length);
+  scoped_ptr<PPB_X509Certificate_Fields> fields(
+      new PPB_X509Certificate_Fields());
+  bool success = ParseDER(der, fields.get());
+  if (success) {
+    fields_.swap(fields);
+    return PP_TRUE;
+  }
+  return PP_FALSE;
+}
+
+PP_Var PPB_Flash_X509Certificate_Shared::GetField(
+    PP_Flash_X509Certificate_Field field) {
+  if (!fields_.get())
+    return PP_MakeUndefined();
+
+  return fields_->GetFieldAsPPVar(field);
+}
+
+bool PPB_Flash_X509Certificate_Shared::ParseDER(

[yzshen1, 2012/03/20 06:48:01]

Why not making it a pure virtual method?

[raymes, 2012/03/21 20:28:08]

ParseDER is only used when constructing an X509 certificate resource from the
byte array. In a subsequent CL, the TCP Socket resource can also construct an
X509 certificate resource to return the servers certificate. In this case it is
constructed from the shared implementation and there is no need to construct a
derived implementation as ParseDER will never be called. This unfinished CL
(http://codereview.chromium.org/9699100/diff/1059/ppapi/shared_impl/private/tc...)
might make it a bit more clear. Let me know if you want to discuss more or have
alternative suggestions on how it should work =)

+    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