QUIC - cleanup changes to keep in sync with internal source tree.

net/quic/crypto/quic_crypto_server_config.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/quic_crypto_server_config.h"
 
 #include <stdlib.h>
 #include <algorithm>
 
 #include "base/stl_util.h"
@@ skipping 67 matching lines @@
   bool valid_source_address_token;
   bool client_nonce_well_formed;
   bool unique;
   StringPiece sni;
   StringPiece client_nonce;
   StringPiece server_nonce;
   StringPiece user_agent_id;
 
   // Errors from EvaluateClientHello.
   vector<uint32> reject_reasons;
+  COMPILE_ASSERT(sizeof(QuicTag) == sizeof(uint32), header_out_of_sync);
 };
 
 struct ValidateClientHelloResultCallback::Result {
   Result(const CryptoHandshakeMessage& in_client_hello,
          IPEndPoint in_client_ip,
          QuicWallTime in_now)
       : client_hello(in_client_hello),
         info(in_client_ip, in_now),
         error_code(QUIC_NO_ERROR) {
   }
@@ skipping 48 matching lines @@
       : result_(result), done_cb_(done_cb) {
   }
 
  protected:
   virtual void RunImpl(bool nonce_is_valid_and_unique) OVERRIDE {
     DVLOG(1) << "Using client nonce, unique: " << nonce_is_valid_and_unique;
     result_->info.unique = nonce_is_valid_and_unique;
     // TODO(rtenneti): Implement capturing of error from strike register.
     // Temporarily treat them as CLIENT_NONCE_UNKNOWN_FAILURE.
     if (!nonce_is_valid_and_unique) {
-      result_->info.reject_reasons.push_back(
-          static_cast<uint32>(CLIENT_NONCE_UNKNOWN_FAILURE));
+      result_->info.reject_reasons.push_back(CLIENT_NONCE_UNKNOWN_FAILURE);
     }
     done_cb_->Run(result_);
   }
 
  private:
   ValidateClientHelloResultCallback::Result* result_;
   ValidateClientHelloResultCallback* done_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(VerifyNonceIsValidAndUniqueCallback);
 };
@@ skipping 726 matching lines @@
     helper.ValidationComplete(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
                               "Invalid SNI name");
     return;
   }
 
   client_hello.GetStringPiece(kUAID, &info->user_agent_id);
 
   if (!requested_config.get()) {
     StringPiece requested_scid;
     if (client_hello.GetStringPiece(kSCID, &requested_scid)) {
-      info->reject_reasons.push_back(
-          static_cast<uint32>(SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE));
+      info->reject_reasons.push_back(SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE);
     } else {
-      info->reject_reasons.push_back(
-          static_cast<uint32>(SERVER_CONFIG_INCHOATE_HELLO_FAILURE));
+      info->reject_reasons.push_back(SERVER_CONFIG_INCHOATE_HELLO_FAILURE);
     }
     // No server config with the requested ID.
     helper.ValidationComplete(QUIC_NO_ERROR, "");
     return;
   }
 
   HandshakeFailureReason source_address_token_error;
   StringPiece srct;
   if (client_hello.GetStringPiece(kSourceAddressTokenTag, &srct)) {
     source_address_token_error =
         ValidateSourceAddressToken(*requested_config,
                                    srct,
                                    info->client_ip,
                                    info->now);
     info->valid_source_address_token =
         (source_address_token_error == HANDSHAKE_OK);
   } else {
     source_address_token_error = SOURCE_ADDRESS_TOKEN_INVALID_FAILURE;
   }
 
   bool found_error = false;
   if (source_address_token_error != HANDSHAKE_OK) {
-    info->reject_reasons.push_back(
-        static_cast<uint32>(source_address_token_error));
+    info->reject_reasons.push_back(source_address_token_error);
     // No valid source address token.
     if (FLAGS_use_early_return_when_verifying_chlo) {
       helper.ValidationComplete(QUIC_NO_ERROR, "");
       return;
     }
     found_error = true;
   }
 
   if (client_hello.GetStringPiece(kNONC, &info->client_nonce) &&
       info->client_nonce.size() == kNonceSize) {
     info->client_nonce_well_formed = true;
   } else {
-    info->reject_reasons.push_back(
-        static_cast<uint32>(CLIENT_NONCE_INVALID_FAILURE));
+    info->reject_reasons.push_back(CLIENT_NONCE_INVALID_FAILURE);
     // Invalid client nonce.
     DVLOG(1) << "Invalid client nonce.";
     if (FLAGS_use_early_return_when_verifying_chlo) {
       helper.ValidationComplete(QUIC_NO_ERROR, "");
       return;
     }
     found_error = true;
   }
 
   if (!replay_protection_) {
     if (!found_error) {
       info->unique = true;
     }
     DVLOG(1) << "No replay protection.";
     helper.ValidationComplete(QUIC_NO_ERROR, "");
     return;
   }
 
   client_hello.GetStringPiece(kServerNonceTag, &info->server_nonce);
   if (!info->server_nonce.empty()) {
     // If the server nonce is present, use it to establish uniqueness.
     HandshakeFailureReason server_nonce_error =
         ValidateServerNonce(info->server_nonce, info->now);
     if (server_nonce_error == HANDSHAKE_OK) {
       info->unique = true;
     } else {
-      info->reject_reasons.push_back(static_cast<uint32>(server_nonce_error));
+      info->reject_reasons.push_back(server_nonce_error);
       info->unique = false;
     }
     DVLOG(1) << "Using server nonce, unique: " << info->unique;
     helper.ValidationComplete(QUIC_NO_ERROR, "");
     return;
   }
 
-  // We want to contact strike register if there are no errors because it is
-  // a RPC call and is expensive.
+  // We want to contact strike register only if there are no errors because it
+  // is a RPC call and is expensive.
   if (found_error) {
     helper.ValidationComplete(QUIC_NO_ERROR, "");
     return;
   }
 
   // Use the client nonce to establish uniqueness.
   StrikeRegisterClient* strike_register_client;
   {
     base::AutoLock locked(strike_register_client_lock_);
 
@@ skipping 471 matching lines @@
 QuicCryptoServerConfig::Config::Config()
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()),
       priority(0),
       source_address_token_boxer(NULL) {}
 
 QuicCryptoServerConfig::Config::~Config() { STLDeleteElements(&key_exchanges); }
 
 }  // namespace net