Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/safe_browsing/download_protection_service_unittest.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 "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include <map>
 #include <string>
 
 #include "base/base_paths.h"
@@ skipping 355 matching lines @@
   EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
   EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(GURL("http://www.google.com/a.exe")))
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(2);
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(a_tmp, _)).Times(2);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 
   // Check that the referrer is matched against the whitelist.
   url_chain.pop_back();
@@ skipping 27 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _));
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(a_tmp, _));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadSuccess) {
@@ skipping 21 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(5);
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(a_tmp, _)).Times(5);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 
   // Invalid response should be safe too.
   response.Clear();
@@ skipping 89 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(1);
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(a_tmp, _)).Times(1);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
@@ skipping 41 matching lines @@
       zip_source_dir.path().Append(FILE_PATH_LITERAL("file.txt")),
       file_contents.data(), file_contents.size()));
   ASSERT_TRUE(zip::Zip(zip_source_dir.path(), a_tmp, false));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_);
-  Mock::VerifyAndClearExpectations(signature_util_);
+  Mock::VerifyAndClearExpectations(sb_service_.get());
+  Mock::VerifyAndClearExpectations(signature_util_.get());
 
   // Now check with an executable in the zip file as well.
   ASSERT_EQ(static_cast<int>(file_contents.size()), file_util::WriteFile(
       zip_source_dir.path().Append(FILE_PATH_LITERAL("file.exe")),
       file_contents.data(), file_contents.size()));
   ASSERT_TRUE(zip::Zip(zip_source_dir.path(), a_tmp, false));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(signature_util_);
+  Mock::VerifyAndClearExpectations(signature_util_.get());
 
   // If the response is dangerous the result should also be marked as
   // dangerous.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
-  Mock::VerifyAndClearExpectations(signature_util_);
+  Mock::VerifyAndClearExpectations(signature_util_.get());
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadCorruptZip) {
   base::ScopedTempDir download_dir;
   ASSERT_TRUE(download_dir.CreateUniqueTempDir());
 
   base::FilePath a_tmp(download_dir.path().Append(FILE_PATH_LITERAL("a.tmp")));
   base::FilePath a_zip(FILE_PATH_LITERAL("a.zip"));
   std::vector<GURL> url_chain;
   url_chain.push_back(GURL("http://www.evil.com/a.zip"));
@@ skipping 15 matching lines @@
   std::string file_contents = "corrupt zip file";
   ASSERT_EQ(static_cast<int>(file_contents.size()), file_util::WriteFile(
       a_tmp, file_contents.data(), file_contents.size()));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_);
-  Mock::VerifyAndClearExpectations(signature_util_);
+  Mock::VerifyAndClearExpectations(sb_service_.get());
+  Mock::VerifyAndClearExpectations(signature_util_.get());
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientCrxDownloadSuccess) {
   ClientDownloadResponse response;
   // Even if the server verdict is dangerous we should return SAFE because
   // DownloadProtectionService::IsSupportedDownload() will return false
   // for crx downloads.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   net::FakeURLFetcherFactory factory(NULL);
   // Empty response means SAFE.
@@ skipping 17 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(1);
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(a_tmp, _)).Times(1);
 
   EXPECT_FALSE(download_service_->IsSupportedDownload(item, a_crx));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
@@ skipping 17 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(remote_address));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _))
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(tmp_path, _))
       .WillOnce(SetCertificateContents("dummy cert data"));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
 #if !defined(OS_WIN)
   // SendRequest is not called.  Wait for FinishRequest to call our callback.
   msg_loop_.Run();
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
@@ skipping 56 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(remote_address));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _));
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(tmp_path, _));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
 #if !defined(OS_WIN)
   // SendRequest is not called.  Wait for FinishRequest to call our callback.
   msg_loop_.Run();
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   EXPECT_EQ(NULL, fetcher);
@@ skipping 45 matching lines @@
   // CheckClientDownload must still be called.
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
       .WillOnce(Return(true));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_);
+  Mock::VerifyAndClearExpectations(sb_service_.get());
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
       .WillOnce(DoAll(CheckDownloadUrlDone(SB_THREAT_TYPE_SAFE),
                       Return(false)));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_);
+  Mock::VerifyAndClearExpectations(sb_service_.get());
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
       .WillOnce(DoAll(
           CheckDownloadUrlDone(SB_THREAT_TYPE_URL_MALWARE),
           Return(false)));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_);
+  Mock::VerifyAndClearExpectations(sb_service_.get());
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               CheckDownloadUrl(ContainerEq(url_chain),
                                NotNull()))
       .WillOnce(DoAll(
           CheckDownloadUrlDone(SB_THREAT_TYPE_BINARY_MALWARE_URL),
           Return(false)));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
@@ skipping 20 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _));
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(tmp_path, _));
 
   download_service_->download_request_timeout_ms_ = 10;
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
   // The request should time out because the HTTP request hasn't returned
   // anything yet.
   msg_loop_.Run();
@@ skipping 20 matching lines @@
   EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(100));
   EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _));
+  EXPECT_CALL(*signature_util_.get(), CheckSignature(tmp_path, _));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::SyncCheckDoneCallback,
                  base::Unretained(this)));
 
   ASSERT_TRUE(observer != NULL);
   observer->OnDownloadDestroyed(&item);
 
   EXPECT_TRUE(observer == NULL);
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, GetCertificateWhitelistStrings) {
   // We'll pass this cert in as the "issuer", even though it isn't really
   // used to sign the certs below.  GetCertificateWhitelistStirngs doesn't care
   // about this.
   scoped_refptr<net::X509Certificate> issuer_cert(
       ReadTestCertificate("issuer.pem"));
   ASSERT_TRUE(issuer_cert.get());
   std::string cert_base = "cert/" + base::HexEncode(
       issuer_cert->fingerprint().data,
       sizeof(issuer_cert->fingerprint().data));
 
   scoped_refptr<net::X509Certificate> cert(ReadTestCertificate("test_cn.pem"));
   ASSERT_TRUE(cert.get());
   std::vector<std::string> whitelist_strings;
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
   // This also tests escaping of characters in the certificate attributes.
   EXPECT_THAT(whitelist_strings, ElementsAre(
       cert_base + "/CN=subject%2F%251"));
 
   cert = ReadTestCertificate("test_cn_o.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
-  EXPECT_THAT(whitelist_strings, ElementsAre(
-      cert_base + "/CN=subject",
-      cert_base + "/CN=subject/O=org",
-      cert_base + "/O=org"));
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
+  EXPECT_THAT(whitelist_strings,
+              ElementsAre(cert_base + "/CN=subject",
+                          cert_base + "/CN=subject/O=org",
+                          cert_base + "/O=org"));
 
   cert = ReadTestCertificate("test_cn_o_ou.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
-  EXPECT_THAT(whitelist_strings, ElementsAre(
-      cert_base + "/CN=subject",
-      cert_base + "/CN=subject/O=org",
-      cert_base + "/CN=subject/O=org/OU=unit",
-      cert_base + "/CN=subject/OU=unit",
-      cert_base + "/O=org",
-      cert_base + "/O=org/OU=unit",
-      cert_base + "/OU=unit"));
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
+  EXPECT_THAT(whitelist_strings,
+              ElementsAre(cert_base + "/CN=subject",
+                          cert_base + "/CN=subject/O=org",
+                          cert_base + "/CN=subject/O=org/OU=unit",
+                          cert_base + "/CN=subject/OU=unit",
+                          cert_base + "/O=org",
+                          cert_base + "/O=org/OU=unit",
+                          cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_cn_ou.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
-  EXPECT_THAT(whitelist_strings, ElementsAre(
-      cert_base + "/CN=subject",
-      cert_base + "/CN=subject/OU=unit",
-      cert_base + "/OU=unit"));
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
+  EXPECT_THAT(whitelist_strings,
+              ElementsAre(cert_base + "/CN=subject",
+                          cert_base + "/CN=subject/OU=unit",
+                          cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_o.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre(cert_base + "/O=org"));
 
   cert = ReadTestCertificate("test_o_ou.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
-  EXPECT_THAT(whitelist_strings, ElementsAre(
-      cert_base + "/O=org",
-      cert_base + "/O=org/OU=unit",
-      cert_base + "/OU=unit"));
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
+  EXPECT_THAT(whitelist_strings,
+              ElementsAre(cert_base + "/O=org",
+                          cert_base + "/O=org/OU=unit",
+                          cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_ou.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre(cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_c.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
-  GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
+  GetCertificateWhitelistStrings(
+      *cert.get(), *issuer_cert.get(), &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre());
 }
 }  // namespace safe_browsing