Update from https://crrev.com/304121

net/quic/crypto/quic_crypto_client_config.h

 // 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.
 
 #ifndef NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_
 #define NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 17 matching lines @@
 // QuicCryptoClientConfig contains crypto-related configuration settings for a
 // client. Note that this object isn't thread-safe. It's designed to be used on
 // a single thread at a time.
 class NET_EXPORT_PRIVATE QuicCryptoClientConfig : public QuicCryptoConfig {
  public:
   // A CachedState contains the information that the client needs in order to
   // perform a 0-RTT handshake with a server. This information can be reused
   // over several connections to the same server.
   class NET_EXPORT_PRIVATE CachedState {
    public:
+    // Enum to track if the server config is valid or not. If it is not valid,
+    // it specifies why it is invalid.
+    enum ServerConfigState {
+      // WARNING: Do not change the numerical values of any of server config
+      // state. Do not remove deprecated server config states - just comment
+      // them as deprecated.
+      SERVER_CONFIG_EMPTY = 0,
+      SERVER_CONFIG_INVALID = 1,
+      SERVER_CONFIG_CORRUPTED = 2,
+      SERVER_CONFIG_EXPIRED = 3,
+      SERVER_CONFIG_INVALID_EXPIRY = 4,
+      SERVER_CONFIG_VALID = 5,
+      // NOTE: Add new server config states only immediately above this line.
+      // Make sure to update the QuicServerConfigState enum in
+      // tools/metrics/histograms/histograms.xml accordingly.
+      SERVER_CONFIG_COUNT
+    };
+
     CachedState();
     ~CachedState();
 
     // IsComplete returns true if this object contains enough information to
     // perform a handshake with the server. |now| is used to judge whether any
     // cached server config has expired.
     bool IsComplete(QuicWallTime now) const;
 
     // IsEmpty returns true if |server_config_| is empty.
     bool IsEmpty() const;
 
     // GetServerConfig returns the parsed contents of |server_config|, or
     // nullptr if |server_config| is empty. The return value is owned by this
     // object and is destroyed when this object is.
     const CryptoHandshakeMessage* GetServerConfig() const;
 
     // SetServerConfig checks that |server_config| parses correctly and stores
     // it in |server_config_|. |now| is used to judge whether |server_config|
     // has expired.
-    QuicErrorCode SetServerConfig(base::StringPiece server_config,
-                                  QuicWallTime now,
-                                  std::string* error_details);
+    ServerConfigState SetServerConfig(base::StringPiece server_config,
+                                      QuicWallTime now,
+                                      std::string* error_details);
 
     // InvalidateServerConfig clears the cached server config (if any).
     void InvalidateServerConfig();
 
     // SetProof stores a certificate chain and signature.
     void SetProof(const std::vector<std::string>& certs,
                   base::StringPiece signature);
 
     // Clears all the data.
     void Clear();
@@ skipping 205 matching lines @@
   // updated server config during a connection.
   QuicErrorCode CacheNewServerConfig(
       const CryptoHandshakeMessage& message,
       QuicWallTime now,
       const std::vector<std::string>& cached_certs,
       CachedState* cached,
       std::string* error_details);
 
   // If the suffix of the hostname in |server_id| is in |canonical_suffixes_|,
   // then populate |cached| with the canonical cached state from
-  // |canonical_server_map_| for that suffix.
-  void PopulateFromCanonicalConfig(const QuicServerId& server_id,
+  // |canonical_server_map_| for that suffix. Returns true if |cached| is
+  // initialized with canonical cached state.
+  bool PopulateFromCanonicalConfig(const QuicServerId& server_id,
                                    CachedState* cached);
 
   // cached_states_ maps from the server_id to the cached information about
   // that server.
   CachedStateMap cached_states_;
 
   // Contains a map of servers which could share the same server config. Map
   // from a canonical host suffix/port/scheme to a representative server with
   // the canonical suffix, which has a plausible set of initial certificates
   // (or at least server public key).
@@ skipping 11 matching lines @@
 
   // The |user_agent_id_| passed in QUIC's CHLO message.
   std::string user_agent_id_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientConfig);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_