Re-enable the omitted tests in path_builder_unittest.cc.

net/cert/internal/path_builder.cc

 // Copyright 2016 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/cert/internal/path_builder.h"
 
 #include <set>
 #include <unordered_set>
 
 #include "base/logging.h"
@@ skipping 64 matching lines @@
   void GetNextIssuer(CertificateOrTrustAnchor* out);
 
   // Returns the |cert| for which issuers are being retrieved.
   const ParsedCertificate* cert() const { return cert_.get(); }
   scoped_refptr<ParsedCertificate> reference_cert() const { return cert_; }
 
  private:
   void AddIssuers(ParsedCertificateList issuers);
   void DoAsyncIssuerQuery();
 
+  // Returns true if |issuers_| contains unconsumed certificates.
+  bool HasCurrentIssuer() const { return cur_issuer_ < issuers_.size(); }
+
   scoped_refptr<ParsedCertificate> cert_;
   CertIssuerSources* cert_issuer_sources_;
   const TrustStore* trust_store_;
 
   // The list of trust anchors that match the issuer name for |cert_|.
   TrustAnchors anchors_;
   // The index of the next trust anchor in |anchors_| to return.
   size_t cur_anchor_ = 0;
 
   // The list of issuers for |cert_|. This is added to incrementally (first
@@ skipping 58 matching lines @@
   if (cur_anchor_ < anchors_.size()) {
     DVLOG(1) << "CertIssuersIter(" << CertDebugString(cert())
              << "): returning anchor " << cur_anchor_ << " of "
              << anchors_.size();
     // Still have anchors that haven't been returned yet, return one of them.
     *out = CertificateOrTrustAnchor(anchors_[cur_anchor_++]);
     return;
   }
 
   // If there aren't any issuers left, block until async results are ready.
-  if (cur_issuer_ >= issuers_.size()) {
+  if (!HasCurrentIssuer()) {
     if (!did_async_issuer_query_) {
       // Now issue request(s) for async ones (AIA, etc).
       DoAsyncIssuerQuery();
     }
 
     // TODO(eroman): Rather than blocking on the async requests in FIFO order,
     // consume in the order they become ready.
-    while (cur_async_request_ < pending_async_requests_.size()) {
+    while (!HasCurrentIssuer() &&
+           cur_async_request_ < pending_async_requests_.size()) {
       ParsedCertificateList new_issuers;
       pending_async_requests_[cur_async_request_]->GetNext(&new_issuers);
       if (new_issuers.empty()) {
         // Request is exhausted, no more results pending from that
         // CertIssuerSource.
         pending_async_requests_[cur_async_request_++].reset();
-        continue;
+      } else {
+        AddIssuers(std::move(new_issuers));
       }
-
-      AddIssuers(std::move(new_issuers));
-      break;
     }
   }
 
-  if (cur_issuer_ < issuers_.size()) {
+  if (HasCurrentIssuer()) {
     DVLOG(1) << "CertIssuersIter(" << CertDebugString(cert())
              << "): returning issuer " << cur_issuer_ << " of "
              << issuers_.size();
     // Still have issuers that haven't been returned yet, return one of them.
     // A reference to the returned issuer is retained, since |present_issuers_|
     // points to data owned by it.
     *out = CertificateOrTrustAnchor(issuers_[cur_issuer_++]);
     return;
   }
 
@@ skipping 360 matching lines @@
 
 void CertPathBuilder::AddResultPath(std::unique_ptr<ResultPath> result_path) {
   // TODO(mattm): set best_result_index based on number or severity of errors.
   if (result_path->valid)
     out_result_->best_result_index = out_result_->paths.size();
   // TODO(mattm): add flag to only return a single path or all attempted paths?
   out_result_->paths.push_back(std::move(result_path));
 }
 
 }  // namespace net