WKWebView: Added cert verification API to web controller.

ios/web/net/cert_verifier_block_adapter_unittest.cc

Index: ios/web/net/cert_verifier_block_adapter_unittest.cc
diff --git a/ios/web/net/cert_verifier_block_adapter_unittest.cc b/ios/web/net/cert_verifier_block_adapter_unittest.cc
index 1380045e16e79eee8386043d1cbf9474262a776e..335a2c0b2772bffb90c4996d2ce66d9fab58b078 100644
--- a/ios/web/net/cert_verifier_block_adapter_unittest.cc
+++ b/ios/web/net/cert_verifier_block_adapter_unittest.cc
@@ -57,24 +57,20 @@ class CertVerifierBlockAdapterTest : public PlatformTest {
     PlatformTest::SetUp();
 
     cert_ = new X509Certificate("test", "test", base::Time(), base::Time());
-    scoped_ptr<CertVerifierMock> cert_verifier_mock(new CertVerifierMock());
-    cert_verifier_mock_ = cert_verifier_mock.get();
-    test_adapter_.reset(
-        new CertVerifierBlockAdapter(cert_verifier_mock.Pass()));
+    test_adapter_.reset(new CertVerifierBlockAdapter(&cert_verifier_mock_));
   }
 
   // Performs synchronous verification.
   void Verify(CertVerifierBlockAdapter::Params params,
-              scoped_ptr<net::CertVerifyResult>* result,
+              net::CertVerifyResult* result,
               int* status) {
     __block bool verification_completed = false;
-    test_adapter_->Verify(params,
-                          ^(scoped_ptr<net::CertVerifyResult> callback_result,
-                            int callback_status) {
-                            *result = callback_result.Pass();
-                            *status = callback_status;
-                            verification_completed = true;
-                          });
+    test_adapter_->Verify(
+        params, ^(net::CertVerifyResult callback_result, int callback_status) {
+          *result = callback_result;
+          *status = callback_status;
+          verification_completed = true;
+        });
     base::test::ios::WaitUntilCondition(^{
       return verification_completed;
     });
@@ -84,8 +80,8 @@ class CertVerifierBlockAdapterTest : public PlatformTest {
   scoped_refptr<X509Certificate> cert_;
   // Testable |CertVerifierBlockAdapter| object.
   scoped_ptr<CertVerifierBlockAdapter> test_adapter_;
-  // CertVerifier mock owned by |test_adapter_|.
-  CertVerifierMock* cert_verifier_mock_;
+  // CertVerifier mock.
+  CertVerifierMock cert_verifier_mock_;
 };
 
 // Tests |Verify| with default params and synchronous verification.
@@ -94,21 +90,21 @@ TEST_F(CertVerifierBlockAdapterTest, DefaultParamsAndSync) {
   net::CertVerifyResult expectedResult;
   expectedResult.cert_status = net::CERT_STATUS_AUTHORITY_INVALID;
   const int kExpectedStatus = 0;
-  EXPECT_CALL(*cert_verifier_mock_,
+  EXPECT_CALL(cert_verifier_mock_,
               Verify(cert_.get(), kHostName, "", 0, nullptr, _, _, _, _))
       .Times(1)
       .WillOnce(testing::DoAll(SetVerifyResult(expectedResult),
                                testing::Return(kExpectedStatus)));
 
   // Call |Verify|.
-  scoped_ptr<CertVerifyResult> actualResult;
+  CertVerifyResult actualResult;
   int actualStatus = -1;
   CertVerifierBlockAdapter::Params params(cert_.get(), kHostName);
   Verify(params, &actualResult, &actualStatus);
 
   // Ensure that Verification results are correct.
   EXPECT_EQ(kExpectedStatus, actualStatus);
-  EXPECT_EQ(expectedResult.cert_status, actualResult->cert_status);
+  EXPECT_EQ(expectedResult.cert_status, actualResult.cert_status);
 }
 
 // Tests |Verify| with default params and asynchronous verification.
@@ -117,14 +113,14 @@ TEST_F(CertVerifierBlockAdapterTest, DefaultParamsAndAsync) {
   net::CertVerifyResult expectedResult;
   expectedResult.is_issued_by_known_root = true;
   const int kExpectedStatus = 0;
-  EXPECT_CALL(*cert_verifier_mock_,
+  EXPECT_CALL(cert_verifier_mock_,
               Verify(cert_.get(), kHostName, "", 0, nullptr, _, _, _, _))
       .Times(1)
       .WillOnce(testing::DoAll(SetVerifyResult(expectedResult), RunCallback(),
                                testing::Return(ERR_IO_PENDING)));
 
   // Call |Verify|.
-  scoped_ptr<CertVerifyResult> actualResult;
+  CertVerifyResult actualResult;
   int actualStatus = -1;
   CertVerifierBlockAdapter::Params params(cert_.get(), kHostName);
   Verify(params, &actualResult, &actualStatus);
@@ -132,47 +128,50 @@ TEST_F(CertVerifierBlockAdapterTest, DefaultParamsAndAsync) {
   // Ensure that Verification results are correct.
   EXPECT_EQ(kExpectedStatus, actualStatus);
   EXPECT_EQ(expectedResult.is_issued_by_known_root,
-            actualResult->is_issued_by_known_root);
+            actualResult.is_issued_by_known_root);
 }
 
-// Tests |Verify| with invalid arguments.
-TEST_F(CertVerifierBlockAdapterTest, InvalidParamsAndError) {
-  // Set up expectation.
-  const int kExpectedStatus = ERR_INVALID_ARGUMENT;
-  EXPECT_CALL(*cert_verifier_mock_,
-              Verify(nullptr, "", "", 0, nullptr, _, _, _, _))
-      .Times(1)
-      .WillOnce(testing::Return(kExpectedStatus));
+// Tests |Verify| with invalid cert argument.
+TEST_F(CertVerifierBlockAdapterTest, InvalidCert) {
+  // Call |Verify|.
+  CertVerifyResult actualResult;
+  int actualStatus = -1;
+  CertVerifierBlockAdapter::Params params(nullptr, kHostName);
+  Verify(params, &actualResult, &actualStatus);
 
+  // Ensure that Verification results are correct.
+  EXPECT_EQ(ERR_INVALID_ARGUMENT, actualStatus);
+}
+
+// Tests |Verify| with invalid hostname argument.
+TEST_F(CertVerifierBlockAdapterTest, InvalidHostname) {
   // Call |Verify|.
-  scoped_ptr<CertVerifyResult> actualResult;
+  CertVerifyResult actualResult;
   int actualStatus = -1;
-  CertVerifierBlockAdapter::Params params(nullptr, "");
+  CertVerifierBlockAdapter::Params params(cert_.get(), "");
   Verify(params, &actualResult, &actualStatus);
 
   // Ensure that Verification results are correct.
-  EXPECT_EQ(kExpectedStatus, actualStatus);
-  EXPECT_FALSE(actualResult);
+  EXPECT_EQ(ERR_INVALID_ARGUMENT, actualStatus);
 }
 
 // Tests |Verify| with error.
 TEST_F(CertVerifierBlockAdapterTest, DefaultParamsAndError) {
   // Set up expectation.
   const int kExpectedStatus = ERR_INSUFFICIENT_RESOURCES;
-  EXPECT_CALL(*cert_verifier_mock_,
+  EXPECT_CALL(cert_verifier_mock_,
               Verify(cert_.get(), kHostName, "", 0, nullptr, _, _, _, _))
       .Times(1)
       .WillOnce(testing::Return(kExpectedStatus));
 
   // Call |Verify|.
-  scoped_ptr<CertVerifyResult> actualResult;
+  CertVerifyResult actualResult;
   int actualStatus = -1;
   CertVerifierBlockAdapter::Params params(cert_.get(), kHostName);
   Verify(params, &actualResult, &actualStatus);
 
   // Ensure that Verification results are correct.
   EXPECT_EQ(kExpectedStatus, actualStatus);
-  EXPECT_FALSE(actualResult);
 }
 
 // Tests |Verify| with all params and synchronous verification.
@@ -182,7 +181,7 @@ TEST_F(CertVerifierBlockAdapterTest, AllParamsAndSync) {
   expectedResult.verified_cert = cert_;
   const int kExpectedStatus = 0;
   scoped_refptr<CRLSet> crl_set(CRLSet::EmptyCRLSetForTesting());
-  EXPECT_CALL(*cert_verifier_mock_,
+  EXPECT_CALL(cert_verifier_mock_,
               Verify(cert_.get(), kHostName, kOcspResponse,
                      CertVerifier::VERIFY_EV_CERT, crl_set.get(), _, _, _, _))
       .Times(1)
@@ -190,7 +189,7 @@ TEST_F(CertVerifierBlockAdapterTest, AllParamsAndSync) {
                                testing::Return(kExpectedStatus)));
 
   // Call |Verify|.
-  scoped_ptr<CertVerifyResult> actualResult;
+  CertVerifyResult actualResult;
   int actualStatus = -1;
   CertVerifierBlockAdapter::Params params(cert_.get(), kHostName);
   params.ocsp_response = kOcspResponse;
@@ -200,7 +199,7 @@ TEST_F(CertVerifierBlockAdapterTest, AllParamsAndSync) {
 
   // Ensure that Verification results are correct.
   EXPECT_EQ(kExpectedStatus, actualStatus);
-  EXPECT_EQ(expectedResult.verified_cert, actualResult->verified_cert);
+  EXPECT_EQ(expectedResult.verified_cert, actualResult.verified_cert);
 }
 
 }  // namespace