Convert iOS to use X509CertificateBytes.

ios/web/web_state/wk_web_view_security_util_unittest.mm

 // 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.
 
 #import "ios/web/web_state/wk_web_view_security_util.h"
 
 #import <Foundation/Foundation.h>
 #include <Security/Security.h>
 
 #include <memory>
 
 #include "base/mac/scoped_cftyperef.h"
 #include "crypto/rsa_private_key.h"
 #include "net/cert/x509_cert_types.h"
 #include "net/cert/x509_certificate.h"
 #include "net/cert/x509_util.h"
+#include "net/cert/x509_util_ios.h"
 #include "net/ssl/ssl_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 
 namespace web {
 namespace {
 // Subject for testing self-signed certificate.
 const char kTestSubject[] = "self-signed";
 // Hostname for testing SecTrustRef objects.
 NSString* const kTestHost = @"www.example.com";
 
 // Returns an autoreleased certificate chain for testing. Chain will contain a
 // single self-signed cert with |subject| as a subject.
 NSArray* MakeTestCertChain(const std::string& subject) {
   std::unique_ptr<crypto::RSAPrivateKey> private_key;
   std::string der_cert;
   net::x509_util::CreateKeyAndSelfSignedCert(
       "CN=" + subject, 1, base::Time::Now(),
       base::Time::Now() + base::TimeDelta::FromDays(1), &private_key,
       &der_cert);
 
   base::ScopedCFTypeRef<SecCertificateRef> cert(
-      net::X509Certificate::CreateOSCertHandleFromBytes(der_cert.data(),
-                                                        der_cert.size()));
+      net::x509_util::CreateSecCertificateFromBytes(
+          reinterpret_cast<const uint8_t*>(der_cert.data()), der_cert.size()));
+  if (!cert)
+    return nullptr;
   NSArray* result = @[ reinterpret_cast<id>(cert.get()) ];
   return result;
 }
 
 // Returns an autoreleased dictionary, which represents NSError's user info for
 // testing.
 NSDictionary* MakeTestSSLCertErrorUserInfo() {
   return @{
     web::kNSErrorPeerCertificateChainKey : MakeTestCertChain(kTestSubject),
   };
 }
 
 // Returns SecTrustRef object for testing.
 base::ScopedCFTypeRef<SecTrustRef> CreateTestTrust(NSArray* cert_chain) {
   base::ScopedCFTypeRef<SecPolicyRef> policy(SecPolicyCreateBasicX509());
   SecTrustRef trust = nullptr;
   SecTrustCreateWithCertificates(cert_chain, policy, &trust);
   return base::ScopedCFTypeRef<SecTrustRef>(trust);
 }
 
 }  // namespace
 
 // Test class for wk_web_view_security_util functions.
 typedef PlatformTest WKWebViewSecurityUtilTest;
 
 // Tests CreateCertFromChain with self-signed cert.
 TEST_F(WKWebViewSecurityUtilTest, CreationCertFromChain) {
   scoped_refptr<net::X509Certificate> cert =
       CreateCertFromChain(MakeTestCertChain(kTestSubject));
+  ASSERT_TRUE(cert);
   EXPECT_TRUE(cert->subject().GetDisplayName() == kTestSubject);
 }
 
 // Tests CreateCertFromChain with nil chain.
 TEST_F(WKWebViewSecurityUtilTest, CreationCertFromNilChain) {
   EXPECT_FALSE(CreateCertFromChain(nil));
 }
 
 // Tests CreateCertFromChain with empty chain.
 TEST_F(WKWebViewSecurityUtilTest, CreationCertFromEmptyChain) {
@@ skipping 15 matching lines @@
   EnsureFutureTrustEvaluationSucceeds(trust);
   SecTrustEvaluate(trust, &result);
   EXPECT_EQ(kSecTrustResultProceed, result);
 }
 
 // Tests CreateCertFromTrust.
 TEST_F(WKWebViewSecurityUtilTest, CreationCertFromTrust) {
   base::ScopedCFTypeRef<SecTrustRef> trust =
       CreateTestTrust(MakeTestCertChain(kTestSubject));
   scoped_refptr<net::X509Certificate> cert = CreateCertFromTrust(trust);
+  ASSERT_TRUE(cert);
   EXPECT_TRUE(cert->subject().GetDisplayName() == kTestSubject);
 }
 
 // Tests CreateCertFromTrust with nil trust.
 TEST_F(WKWebViewSecurityUtilTest, CreationCertFromNilTrust) {
   EXPECT_FALSE(CreateCertFromTrust(nil));
 }
 
 // Tests CreateServerTrustFromChain with valid input.
 TEST_F(WKWebViewSecurityUtilTest, CreationServerTrust) {
@@ skipping 160 matching lines @@
             GetSecurityStyleFromTrustResult(kSecTrustResultUnspecified));
 }
 
 // Tests GetSecurityStyleFromTrustResult with invalid SecTrustResultType result.
 TEST_F(WKWebViewSecurityUtilTest, GetSecurityStyleFromInvalidResult) {
   EXPECT_EQ(SECURITY_STYLE_UNKNOWN,
             GetSecurityStyleFromTrustResult(kSecTrustResultInvalid));
 }
 
 }  // namespace web