Add functionality to pppapi TCPSocket to support secure sockets in flash

ppapi/tests/test_x509_certificate_private.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/tests/test_x509_certificate_private.h"
 
 #include <cmath>
 #include <limits>
 
 #include "ppapi/cpp/private/x509_certificate_private.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(X509CertificatePrivate);
 
 namespace {
 
 bool FieldMatchesString(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field,
     const std::string& expected) {
   pp::Var field_value = certificate.GetField(field);
   if (!field_value.is_string())
     return false;
   return field_value.AsString() == expected;
 }
 
 bool FieldMatchesDouble(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field,
     double expected) {
   pp::Var field_value = certificate.GetField(field);
   if (!field_value.is_double())
     return false;
   return std::fabs(field_value.AsDouble() - expected) <=
       std::numeric_limits<double>::epsilon();
 }
 
 bool FieldMatchesBuffer(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field,
     const char* expected,
     uint32_t expected_length) {
   pp::Var field_value = certificate.GetField(field);
   if (!field_value.is_array_buffer())
     return false;
   pp::VarArrayBuffer array_buffer(field_value);
   char* bytes = static_cast<char*>(array_buffer.Map());
   uint32_t length = array_buffer.ByteLength();
   if (length != expected_length)
     return false;
   return std::equal(expected, expected + expected_length, bytes);
 }
 
 bool FieldIsNull(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field) {
   return certificate.GetField(field).is_null();
 }
 
 // Google's cert.
 const unsigned char kGoogleDer[] = {
   0x30, 0x82, 0x03, 0x21, 0x30, 0x82, 0x02, 0x8a, 0xa0, 0x03, 0x02, 0x01,
   0x02, 0x02, 0x10, 0x01, 0x2a, 0x39, 0x76, 0x0d, 0x3f, 0x4f, 0xc9, 0x0b,
   0xe7, 0xbd, 0x2b, 0xcf, 0x95, 0x2e, 0x7a, 0x30, 0x0d, 0x06, 0x09, 0x2a,
   0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x4c,
@@ skipping 64 matching lines @@
 };
 
 }  // namespace
 
 TestX509CertificatePrivate::TestX509CertificatePrivate(
     TestingInstance* instance)
     : TestCase(instance) {
 }
 
 bool TestX509CertificatePrivate::Init() {
-  if (!pp::X509Certificate::IsAvailable())
+  if (!pp::X509CertificatePrivate::IsAvailable())
     return false;
 
   return true;
 }
 
 void TestX509CertificatePrivate::RunTests(const std::string& filter) {
   RUN_TEST_FORCEASYNC_AND_NOT(ValidCertificate, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(InvalidCertificate, filter);
 }
 
 std::string TestX509CertificatePrivate::TestValidCertificate() {
-  pp::X509Certificate certificate(instance_);
+  pp::X509CertificatePrivate certificate(instance_);
   bool successful = certificate.Initialize(
       reinterpret_cast<const char*>(kGoogleDer), sizeof(kGoogleDer));
   ASSERT_TRUE(successful);
 
   ASSERT_TRUE(FieldMatchesString(certificate,
       PP_X509CERTIFICATE_PRIVATE_SUBJECT_COMMON_NAME, "www.google.com"));
   ASSERT_TRUE(FieldMatchesString(certificate,
       PP_X509CERTIFICATE_PRIVATE_SUBJECT_LOCALITY_NAME, "Mountain View"));
   ASSERT_TRUE(FieldMatchesString(certificate,
       PP_X509CERTIFICATE_PRIVATE_SUBJECT_STATE_OR_PROVINCE_NAME, "California"));
@@ skipping 40 matching lines @@
   ASSERT_TRUE(FieldIsNull(certificate,
       PP_X509CERTIFICATE_PRIVATE_ALGORITHM_PARAMATERS_RAW));
   ASSERT_TRUE(FieldIsNull(certificate,
       PP_X509CERTIFICATE_PRIVATE_SUBJECT_PUBLIC_KEY));
 
   PASS();
 }
 
 std::string TestX509CertificatePrivate::TestInvalidCertificate() {
   bool successful;
-  pp::X509Certificate null_certificate(instance_);
+  pp::X509CertificatePrivate null_certificate(instance_);
   successful = null_certificate.Initialize(NULL, 0);
   ASSERT_FALSE(successful);
 
-  pp::X509Certificate bad_certificate(instance_);
+  pp::X509CertificatePrivate bad_certificate(instance_);
   successful = bad_certificate.Initialize("acbde", 0);
   ASSERT_FALSE(successful);
 
   PASS();
 }