Move chain building/verification out of X509Certificate

net/base/cert_verifier.cc

 // Copyright (c) 2008 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 "net/base/cert_verifier.h"
 
 #if defined(USE_NSS)
 #include <private/pprthred.h>  // PR_DetatchThread
 #endif
 
 #include "base/message_loop.h"
 #include "base/worker_pool.h"
 #include "net/base/cert_verify_result.h"
 #include "net/base/net_errors.h"
 #include "net/base/x509_certificate.h"
+#include "net/base/x509_chain.h"
 
 namespace net {
 
 class CertVerifier::Request :
     public base::RefCountedThreadSafe<CertVerifier::Request> {
  public:
   Request(CertVerifier* verifier,
           X509Certificate* cert,
           const std::string& hostname,
           int flags,
           CertVerifyResult* verify_result,
           CompletionCallback* callback)
       : cert_(cert),
         hostname_(hostname),
         flags_(flags),
         verifier_(verifier),
         verify_result_(verify_result),
         callback_(callback),
         origin_loop_(MessageLoop::current()),
         error_(OK) {
   }
 
   void DoVerify() {
     // Running on the worker thread
-    error_ = cert_->Verify(hostname_, flags_, &result_);
+    error_ = x509_chain::VerifySSLServer(cert_, hostname_, flags_, &result_);
 #if defined(USE_NSS)
     // Detach the thread from NSPR.
     // Calling NSS functions attaches the thread to NSPR, which stores
     // the NSPR thread ID in thread-specific data.
     // The threads in our thread pool terminate after we have called
     // PR_Cleanup.  Unless we detach them from NSPR, net_unittests gets
     // segfaults on shutdown when the threads' thread-specific data
     // destructors run.
     PR_DetachThread();
 #endif
@@ skipping 76 matching lines @@
 int CertVerifier::Verify(X509Certificate* cert,
                          const std::string& hostname,
                          int flags,
                          CertVerifyResult* verify_result,
                          CompletionCallback* callback) {
   DCHECK(!request_) << "verifier already in use";
 
   // Do a synchronous verification.
   if (!callback) {
     CertVerifyResult result;
-    int rv = cert->Verify(hostname, flags, &result);
+    int rv = x509_chain::VerifySSLServer(cert, hostname, flags, &result);
     *verify_result = result;
     return rv;
   }
 
   request_ = new Request(this, cert, hostname, flags, verify_result, callback);
 
   // Dispatch to worker thread...
   if (!WorkerPool::PostTask(FROM_HERE,
           NewRunnableMethod(request_.get(), &Request::DoVerify), true)) {
     NOTREACHED();
     request_ = NULL;
     return ERR_FAILED;
   }
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net