Land Recent QUIC Changes

net/quic/quic_config.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/quic_config.h"
 
 using std::string;
 
 namespace net {
 
@@ skipping 53 matching lines @@
       kICSL, static_cast<uint32>(idle_connection_state_lifetime_.ToSeconds()));
   out->SetValue(kKATO, static_cast<uint32>(keepalive_timeout_.ToSeconds()));
   out->SetVector(kCGST, congestion_control_);
 }
 
 QuicErrorCode QuicConfig::ProcessFinalPeerHandshake(
     const CryptoHandshakeMessage& msg,
     CryptoUtils::Priority priority,
     QuicNegotiatedParameters* out_params,
     string* error_details) const {
+  DCHECK(error_details != NULL);
+
   const CryptoTag* their_congestion_controls;
   size_t num_their_congestion_controls;
   QuicErrorCode error;
 
   error = msg.GetTaglist(kCGST, &their_congestion_controls,
                          &num_their_congestion_controls);
   if (error != QUIC_NO_ERROR) {
-    if (error_details) {
-      *error_details = "Missing CGST";
-    }
+    *error_details = "Missing CGST";
     return error;
   }
 
   if (!CryptoUtils::FindMutualTag(congestion_control_,
                                   their_congestion_controls,
                                   num_their_congestion_controls,
                                   priority,
                                   &out_params->congestion_control,
                                   NULL)) {
-    if (error_details) {
-      *error_details = "Unsuported CGST";
-    }
+    *error_details = "Unsuported CGST";
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP;
   }
 
   uint32 idle;
   error = msg.GetUint32(kICSL, &idle);
   if (error != QUIC_NO_ERROR) {
-    if (error_details) {
-      *error_details = "Missing ICSL";
-    }
+    *error_details = "Missing ICSL";
     return error;
   }
 
   out_params->idle_connection_state_lifetime = QuicTime::Delta::FromSeconds(
       std::min(static_cast<uint32>(idle_connection_state_lifetime_.ToSeconds()),
                idle));
 
   uint32 keepalive;
   error = msg.GetUint32(kKATO, &keepalive);
   switch (error) {
     case QUIC_NO_ERROR:
       out_params->keepalive_timeout = QuicTime::Delta::FromSeconds(
           std::min(static_cast<uint32>(keepalive_timeout_.ToSeconds()),
                    keepalive));
       break;
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       // KATO is optional.
       out_params->keepalive_timeout = QuicTime::Delta::Zero();
       break;
     default:
-      if (error_details) {
-        *error_details = "Bad KATO";
-      }
+      *error_details = "Bad KATO";
       return error;
   }
 
   return QUIC_NO_ERROR;
 }
 
 }  // namespace net