This adds the following to functions to the ppapi TCPSocket interface:

1) GetServer certificate, which returns the server X509Certificate if an SSL connection has been established.
2) AddChainBuilding certificate. This is currently unimplemented in Chrome but the interface and plumbing has been added so it can easily be hooked up. This should add a trusted/untrusted chain building certificate to be used by the client for a particular connection when performing the SSL handshake.

BUG=114626
TEST=out/Release/browser_tests --gtest_filter=*PPAPITest.*TCP*Trusted*


Review URL: http://codereview.chromium.org/9699100

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

3 files changed, 105 insertions, 8 deletions

diff --git a/ppapi/tests/test_tcp_socket_private_trusted.cc b/ppapi/tests/test_tcp_socket_private_trusted.cc
new file mode 100644
index 0000000..debb3ce
--- /dev/null
+++ b/ppapi/tests/test_tcp_socket_private_trusted.cc
@@ -0,0 +1,65 @@
+// 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_tcp_socket_private_trusted.h"
+
+#include "ppapi/cpp/private/tcp_socket_private.h"
+#include "ppapi/cpp/private/x509_certificate_private.h"
+#include "ppapi/tests/testing_instance.h"
+#include "ppapi/tests/test_utils.h"
+
+REGISTER_TEST_CASE(TCPSocketPrivateTrusted);
+
+TestTCPSocketPrivateTrusted::TestTCPSocketPrivateTrusted(
+    TestingInstance* instance)
+    : TestCase(instance) {
+}
+
+bool TestTCPSocketPrivateTrusted::Init() {
+  if (!pp::TCPSocketPrivate::IsAvailable())
+    return false;
+
+  // We need something to connect to, so we connect to the HTTP server whence we
+  // came. Grab the host and port.
+  if (!EnsureRunningOverHTTP())
+    return false;
+
+  if (!GetLocalHostPort(instance_->pp_instance(), &host_, &port_))
+    return false;
+
+  // Get the port for the SSL server.
+  ssl_port_ = instance_->ssl_server_port();
+
+  return true;
+}
+
+void TestTCPSocketPrivateTrusted::RunTests(const std::string& filter) {
+  RUN_TEST_FORCEASYNC_AND_NOT(GetServerCertificate, filter);
+}
+
+std::string TestTCPSocketPrivateTrusted::TestGetServerCertificate() {
+  pp::TCPSocketPrivate socket(instance_);
+  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+
+  int32_t rv = socket.Connect(host_.c_str(), ssl_port_, cb);
+  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = cb.WaitForResult();
+  ASSERT_EQ(PP_OK, rv);
+
+  rv = socket.SSLHandshake(host_.c_str(), ssl_port_, cb);
+  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = cb.WaitForResult();
+  ASSERT_EQ(PP_OK, rv);
+
+  const pp::X509CertificatePrivate& cert = socket.GetServerCertificate();
+  ASSERT_EQ(
+      cert.GetField(PP_X509CERTIFICATE_PRIVATE_ISSUER_COMMON_NAME).AsString(),
+      "Test CA");
+  ASSERT_EQ(
+      cert.GetField(PP_X509CERTIFICATE_PRIVATE_SUBJECT_COMMON_NAME).AsString(),
+      "127.0.0.1");
+  PASS();
+}
diff --git a/ppapi/tests/test_tcp_socket_private_trusted.h b/ppapi/tests/test_tcp_socket_private_trusted.h
new file mode 100644
index 0000000..364229a
--- /dev/null
+++ b/ppapi/tests/test_tcp_socket_private_trusted.h
@@ -0,0 +1,32 @@
+// 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.
+
+#ifndef PAPPI_TESTS_TEST_TCP_SOCKET_PRIVATE_TRUSTED_H_
+#define PAPPI_TESTS_TEST_TCP_SOCKET_PRIVATE_TRUSTED_H_
+
+#include <string>
+
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/tests/test_case.h"
+
+// This class is necessary to test the portions of TCP socket which are
+// not exposed to NaCl yet. In particular, functionality related to
+// X509 Certificates is tested here.
+class TestTCPSocketPrivateTrusted : public TestCase {
+ public:
+  explicit TestTCPSocketPrivateTrusted(TestingInstance* instance);
+
+  // TestCase implementation.
+  virtual bool Init();
+  virtual void RunTests(const std::string& filter);
+
+ private:
+  std::string TestGetServerCertificate();
+
+  std::string host_;
+  uint16_t port_;
+  uint16_t ssl_port_;
+};
+
+#endif  // PAPPI_TESTS_TEST_TCP_SOCKET_PRIVATE_TRUSTED_H_
diff --git a/ppapi/tests/test_x509_certificate_private.cc b/ppapi/tests/test_x509_certificate_private.cc
index 9bf950e..a8bf649 100644
--- a/ppapi/tests/test_x509_certificate_private.cc
+++ b/ppapi/tests/test_x509_certificate_private.cc
@@ -17,7 +17,7 @@ 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);
@@ -27,7 +27,7 @@ bool FieldMatchesString(
 }
 
 bool FieldMatchesDouble(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field,
     double expected) {
   pp::Var field_value = certificate.GetField(field);
@@ -38,7 +38,7 @@ bool FieldMatchesDouble(
 }
 
 bool FieldMatchesBuffer(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field,
     const char* expected,
     uint32_t expected_length) {
@@ -54,7 +54,7 @@ bool FieldMatchesBuffer(
 }
 
 bool FieldIsNull(
-    const pp::X509Certificate& certificate,
+    const pp::X509CertificatePrivate& certificate,
     PP_X509Certificate_Private_Field field) {
   return certificate.GetField(field).is_null();
 }
@@ -139,7 +139,7 @@ TestX509CertificatePrivate::TestX509CertificatePrivate(
 }
 
 bool TestX509CertificatePrivate::Init() {
-  if (!pp::X509Certificate::IsAvailable())
+  if (!pp::X509CertificatePrivate::IsAvailable())
     return false;
 
   return true;
@@ -151,7 +151,7 @@ void TestX509CertificatePrivate::RunTests(const std::string& 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);
@@ -212,11 +212,11 @@ std::string TestX509CertificatePrivate::TestValidCertificate() {
 
 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);