Add quic_types.h and move the typedefs unrelated to the QUIC protocol

net/quic/crypto/proof_verifier_chromium.cc

 // Copyright 2013 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/quic/crypto/proof_verifier_chromium.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 24 matching lines @@
 // ProofVerifier. If the verification can not complete synchronously, it
 // will notify the ProofVerifier upon completion.
 class ProofVerifierChromium::Job {
  public:
   Job(ProofVerifierChromium* proof_verifier,
       CertVerifier* cert_verifier,
       const BoundNetLog& net_log);
 
   // Starts the proof verification.  If |PENDING| is returned, then |callback|
   // will be invoked asynchronously when the verification completes.
-  Status VerifyProof(const std::string& hostname,
-                     const std::string& server_config,
-                     const std::vector<std::string>& certs,
-                     const std::string& signature,
-                     std::string* error_details,
-                     scoped_ptr<ProofVerifyDetails>* verify_details,
-                     ProofVerifierCallback* callback);
+  QuicAsyncStatus VerifyProof(const std::string& hostname,
+                              const std::string& server_config,
+                              const std::vector<std::string>& certs,
+                              const std::string& signature,
+                              std::string* error_details,
+                              scoped_ptr<ProofVerifyDetails>* verify_details,
+                              ProofVerifierCallback* callback);
 
  private:
   enum State {
     STATE_NONE,
     STATE_VERIFY_CERT,
     STATE_VERIFY_CERT_COMPLETE,
   };
 
   int DoLoop(int last_io_result);
   void OnIOComplete(int result);
@@ skipping 29 matching lines @@
 
 ProofVerifierChromium::Job::Job(ProofVerifierChromium* proof_verifier,
                                 CertVerifier* cert_verifier,
                                 const BoundNetLog& net_log)
     : proof_verifier_(proof_verifier),
       verifier_(new SingleRequestCertVerifier(cert_verifier)),
       next_state_(STATE_NONE),
       net_log_(net_log) {
 }
 
-ProofVerifierChromium::Status ProofVerifierChromium::Job::VerifyProof(
+QuicAsyncStatus ProofVerifierChromium::Job::VerifyProof(
     const string& hostname,
     const string& server_config,
     const vector<string>& certs,
     const string& signature,
     std::string* error_details,
     scoped_ptr<ProofVerifyDetails>* verify_details,
     ProofVerifierCallback* callback) {
   DCHECK(error_details);
   DCHECK(verify_details);
   DCHECK(callback);
 
   error_details->clear();
 
   if (STATE_NONE != next_state_) {
     *error_details = "Certificate is already set and VerifyProof has begun";
     DLOG(DFATAL) << *error_details;
-    return FAILURE;
+    return QUIC_FAILURE;
   }
 
   verify_details_.reset(new ProofVerifyDetailsChromium);
 
   if (certs.empty()) {
     *error_details = "Failed to create certificate chain. Certs are empty.";
     DLOG(WARNING) << *error_details;
     verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID;
     verify_details->reset(verify_details_.release());
-    return FAILURE;
+    return QUIC_FAILURE;
   }
 
   // Convert certs to X509Certificate.
   vector<StringPiece> cert_pieces(certs.size());
   for (unsigned i = 0; i < certs.size(); i++) {
     cert_pieces[i] = base::StringPiece(certs[i]);
   }
   cert_ = X509Certificate::CreateFromDERCertChain(cert_pieces);
   if (!cert_.get()) {
     *error_details = "Failed to create certificate chain";
     DLOG(WARNING) << *error_details;
     verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID;
     verify_details->reset(verify_details_.release());
-    return FAILURE;
+    return QUIC_FAILURE;
   }
 
   // We call VerifySignature first to avoid copying of server_config and
   // signature.
   if (!VerifySignature(server_config, signature, certs[0])) {
     *error_details = "Failed to verify signature of server config";
     DLOG(WARNING) << *error_details;
     verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID;
     verify_details->reset(verify_details_.release());
-    return FAILURE;
+    return QUIC_FAILURE;
   }
 
   hostname_ = hostname;
 
   next_state_ = STATE_VERIFY_CERT;
   switch (DoLoop(OK)) {
     case OK:
       verify_details->reset(verify_details_.release());
-      return SUCCESS;
+      return QUIC_SUCCESS;
     case ERR_IO_PENDING:
       callback_.reset(callback);
-      return PENDING;
+      return QUIC_PENDING;
     default:
       *error_details = error_details_;
       verify_details->reset(verify_details_.release());
-      return FAILURE;
+      return QUIC_FAILURE;
   }
 }
 
 int ProofVerifierChromium::Job::DoLoop(int last_result) {
   int rv = last_result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_VERIFY_CERT:
@@ skipping 131 matching lines @@
   return true;
 }
 
 ProofVerifierChromium::ProofVerifierChromium(CertVerifier* cert_verifier)
     : cert_verifier_(cert_verifier) {}
 
 ProofVerifierChromium::~ProofVerifierChromium() {
   STLDeleteElements(&active_jobs_);
 }
 
-ProofVerifierChromium::Status ProofVerifierChromium::VerifyProof(
+QuicAsyncStatus ProofVerifierChromium::VerifyProof(
     const std::string& hostname,
     const std::string& server_config,
     const std::vector<std::string>& certs,
     const std::string& signature,
     const ProofVerifyContext* verify_context,
     std::string* error_details,
     scoped_ptr<ProofVerifyDetails>* verify_details,
     ProofVerifierCallback* callback) {
   if (!verify_context) {
     *error_details = "Missing context";
-    return FAILURE;
+    return QUIC_FAILURE;
   }
   const ProofVerifyContextChromium* chromium_context =
       reinterpret_cast<const ProofVerifyContextChromium*>(verify_context);
   scoped_ptr<Job> job(new Job(this, cert_verifier_, chromium_context->net_log));
-  Status status = job->VerifyProof(hostname, server_config, certs, signature,
-                                   error_details, verify_details, callback);
-  if (status == PENDING) {
+  QuicAsyncStatus status = job->VerifyProof(hostname, server_config, certs,
+                                            signature, error_details,
+                                            verify_details, callback);
+  if (status == QUIC_PENDING) {
     active_jobs_.insert(job.release());
   }
   return status;
 }
 
 void ProofVerifierChromium::OnJobComplete(Job* job) {
   active_jobs_.erase(job);
   delete job;
 }
 
 }  // namespace net