Land Recent QUIC changes.

net/quic/crypto/common_cert_set.cc

 // Copyright (c) 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/common_cert_set.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 35 matching lines @@
 
 CommonCertSetsQUIC::CommonCertSetsQUIC() {
 }
 
 StringPiece CommonCertSetsQUIC::GetCommonHashes() const {
   return StringPiece(reinterpret_cast<const char*>(kSetHashes),
                      sizeof(uint64) * arraysize(kSetHashes));
 }
 
 StringPiece CommonCertSetsQUIC::GetCert(uint64 hash, uint32 index) const {
+  StringPiece cert;
   for (size_t i = 0; i < arraysize(kSets); i++) {
     if (kSets[i].hash == hash) {
-      if (index >= kSets[i].num_certs) {
-        return StringPiece();
+      if (index < kSets[i].num_certs) {
+        cert.set(kSets[i].certs[index], kSets[i].lens[index]);
       }
-      return StringPiece(reinterpret_cast<const char*>(kSets[i].certs[index]),
-                         kSets[i].lens[index]);
+      break;
     }
   }
 
-  return StringPiece();
+  return cert;
 }
 
 // Compare returns a value less than, equal to or greater than zero if |a| is
 // lexicographically less than, equal to or greater than |b|, respectively.
 static int Compare(StringPiece a, const unsigned char* b, size_t b_len) {
   size_t len = a.size();
   if (len > b_len) {
     len = b_len;
   }
   int n = memcmp(a.data(), b, len);
@@ skipping 26 matching lines @@
         continue;
       }
 
       if (kSets[j].num_certs == 0) {
         continue;
       }
 
       // Binary search for a matching certificate.
       size_t min = 0;
       size_t max = kSets[j].num_certs - 1;
-      for (;;) {
-        if (max < min) {
-          break;
-        }
-
+      while (max >= min) {
         size_t mid = min + ((max - min) / 2);
         int n = Compare(cert, kSets[j].certs[mid], kSets[j].lens[mid]);
         if (n < 0) {
           if (mid == 0) {
             break;
           }
           max = mid - 1;
         } else if (n > 0) {
           min = mid + 1;
         } else {
           *out_hash = hash;
           *out_index = mid;
           return true;
         }
       }
     }
   }
 
   return false;
 }
 
 }  // namespace net