Rename variables "request_handle" to "request" in CertVerifier tests.

chrome/browser/chromeos/policy/policy_cert_verifier_browsertest.cc

 // Copyright 2014 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/chromeos/policy/policy_cert_verifier.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
@@ skipping 48 matching lines @@
     test_ca_cert_list_.push_back(test_ca_cert_);
   }
 
   void TearDown() override {
     // Destroy |cert_verifier_| before destroying the ThreadBundle, otherwise
     // BrowserThread::CurrentlyOn checks fail.
     cert_verifier_.reset();
   }
 
  protected:
-  int VerifyTestServerCert(
-      const net::TestCompletionCallback& test_callback,
-      net::CertVerifyResult* verify_result,
-      scoped_ptr<net::CertVerifier::Request>* request_handle) {
-    return cert_verifier_->Verify(test_server_cert_.get(), "127.0.0.1",
-                                  std::string(), 0, NULL, verify_result,
-                                  test_callback.callback(), request_handle,
-                                  net::BoundNetLog());
+  int VerifyTestServerCert(const net::TestCompletionCallback& test_callback,
+                           net::CertVerifyResult* verify_result,
+                           scoped_ptr<net::CertVerifier::Request>* request) {
+    return cert_verifier_->Verify(
+        test_server_cert_.get(), "127.0.0.1", std::string(), 0, NULL,
+        verify_result, test_callback.callback(), request, net::BoundNetLog());
   }
 
   bool SupportsAdditionalTrustAnchors() {
     scoped_refptr<net::CertVerifyProc> proc =
         net::CertVerifyProc::CreateDefault();
     return proc->SupportsAdditionalTrustAnchors();
   }
 
   // Returns whether |cert_verifier| signalled usage of one of the additional
   // trust anchors (i.e. of |test_ca_cert_|) for the first time or since the
@@ skipping 33 matching lines @@
   bool trust_anchor_used_;
   crypto::ScopedTestNSSChromeOSUser test_nss_user_;
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(PolicyCertVerifierTest, VerifyUntrustedCert) {
   // |test_server_cert_| is untrusted, so Verify() fails.
   {
     net::CertVerifyResult verify_result;
     net::TestCompletionCallback callback;
-    scoped_ptr<net::CertVerifier::Request> request_handle;
-    int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+    scoped_ptr<net::CertVerifier::Request> request;
+    int error = VerifyTestServerCert(callback, &verify_result, &request);
     ASSERT_EQ(net::ERR_IO_PENDING, error);
-    EXPECT_TRUE(request_handle);
+    EXPECT_TRUE(request);
     error = callback.WaitForResult();
     EXPECT_EQ(net::ERR_CERT_AUTHORITY_INVALID, error);
   }
 
   // Issuing the same request again hits the cache. This tests the synchronous
   // path.
   {
     net::CertVerifyResult verify_result;
     net::TestCompletionCallback callback;
-    scoped_ptr<net::CertVerifier::Request> request_handle;
-    int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+    scoped_ptr<net::CertVerifier::Request> request;
+    int error = VerifyTestServerCert(callback, &verify_result, &request);
     EXPECT_EQ(net::ERR_CERT_AUTHORITY_INVALID, error);
   }
 
   EXPECT_FALSE(WasTrustAnchorUsedAndReset());
 }
 
 TEST_F(PolicyCertVerifierTest, VerifyTrustedCert) {
   // Make the database trust |test_ca_cert_|.
   net::NSSCertDatabase::ImportCertFailureList failure_list;
   ASSERT_TRUE(test_cert_db_->ImportCACerts(
       test_ca_cert_list_, net::NSSCertDatabase::TRUSTED_SSL, &failure_list));
   ASSERT_TRUE(failure_list.empty());
 
   // Verify that it is now trusted.
   net::NSSCertDatabase::TrustBits trust =
       test_cert_db_->GetCertTrust(test_ca_cert_.get(), net::CA_CERT);
   EXPECT_EQ(net::NSSCertDatabase::TRUSTED_SSL, trust);
 
   // Verify() successfully verifies |test_server_cert_| after it was imported.
   net::CertVerifyResult verify_result;
   net::TestCompletionCallback callback;
-  scoped_ptr<net::CertVerifier::Request> request_handle;
-  int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+  scoped_ptr<net::CertVerifier::Request> request;
+  int error = VerifyTestServerCert(callback, &verify_result, &request);
   ASSERT_EQ(net::ERR_IO_PENDING, error);
-  EXPECT_TRUE(request_handle);
+  EXPECT_TRUE(request);
   error = callback.WaitForResult();
   EXPECT_EQ(net::OK, error);
 
   // The additional trust anchors were not used, since the certificate is
   // trusted from the database.
   EXPECT_FALSE(WasTrustAnchorUsedAndReset());
 }
 
 TEST_F(PolicyCertVerifierTest, VerifyUsingAdditionalTrustAnchor) {
   ASSERT_TRUE(SupportsAdditionalTrustAnchors());
 
   // |test_server_cert_| is untrusted, so Verify() fails.
   {
     net::CertVerifyResult verify_result;
     net::TestCompletionCallback callback;
-    scoped_ptr<net::CertVerifier::Request> request_handle;
-    int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+    scoped_ptr<net::CertVerifier::Request> request;
+    int error = VerifyTestServerCert(callback, &verify_result, &request);
     ASSERT_EQ(net::ERR_IO_PENDING, error);
-    EXPECT_TRUE(request_handle);
+    EXPECT_TRUE(request);
     error = callback.WaitForResult();
     EXPECT_EQ(net::ERR_CERT_AUTHORITY_INVALID, error);
   }
   EXPECT_FALSE(WasTrustAnchorUsedAndReset());
 
   // Verify() again with the additional trust anchors.
   cert_verifier_->SetTrustAnchors(test_ca_cert_list_);
   {
     net::CertVerifyResult verify_result;
     net::TestCompletionCallback callback;
-    scoped_ptr<net::CertVerifier::Request> request_handle;
-    int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+    scoped_ptr<net::CertVerifier::Request> request;
+    int error = VerifyTestServerCert(callback, &verify_result, &request);
     ASSERT_EQ(net::ERR_IO_PENDING, error);
-    EXPECT_TRUE(request_handle);
+    EXPECT_TRUE(request);
     error = callback.WaitForResult();
     EXPECT_EQ(net::OK, error);
   }
   EXPECT_TRUE(WasTrustAnchorUsedAndReset());
 
   // Verify() again with the additional trust anchors will hit the cache.
   cert_verifier_->SetTrustAnchors(test_ca_cert_list_);
   {
     net::CertVerifyResult verify_result;
     net::TestCompletionCallback callback;
-    scoped_ptr<net::CertVerifier::Request> request_handle;
-    int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+    scoped_ptr<net::CertVerifier::Request> request;
+    int error = VerifyTestServerCert(callback, &verify_result, &request);
     EXPECT_EQ(net::OK, error);
   }
   EXPECT_TRUE(WasTrustAnchorUsedAndReset());
 
   // Verifying after removing the trust anchors should now fail.
   cert_verifier_->SetTrustAnchors(net::CertificateList());
   {
     net::CertVerifyResult verify_result;
     net::TestCompletionCallback callback;
-    scoped_ptr<net::CertVerifier::Request> request_handle;
-    int error = VerifyTestServerCert(callback, &verify_result, &request_handle);
+    scoped_ptr<net::CertVerifier::Request> request;
+    int error = VerifyTestServerCert(callback, &verify_result, &request);
     // Note: this hits the cached result from the first Verify() in this test.
     EXPECT_EQ(net::ERR_CERT_AUTHORITY_INVALID, error);
   }
   // The additional trust anchors were reset, thus |cert_verifier_| should not
   // signal it's usage anymore.
   EXPECT_FALSE(WasTrustAnchorUsedAndReset());
 }
 
 }  // namespace policy