Standardize usage of virtual/override/final in net/

net/quic/quic_config.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_CONFIG_H_
 #define NET_QUIC_QUIC_CONFIG_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 43 matching lines @@
       std::string* error_details) = 0;
 
  protected:
   const QuicTag tag_;
   const QuicConfigPresence presence_;
 };
 
 class NET_EXPORT_PRIVATE QuicNegotiableValue : public QuicConfigValue {
  public:
   QuicNegotiableValue(QuicTag tag, QuicConfigPresence presence);
-  virtual ~QuicNegotiableValue();
+  ~QuicNegotiableValue() override;
 
   bool negotiated() const {
     return negotiated_;
   }
 
  protected:
   bool negotiated_;
 };
 
 class NET_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue {
  public:
   // Default and max values default to 0.
   QuicNegotiableUint32(QuicTag name, QuicConfigPresence presence);
-  virtual ~QuicNegotiableUint32();
+  ~QuicNegotiableUint32() override;
 
   // Sets the maximum possible value that can be achieved after negotiation and
   // also the default values to be assumed if PRESENCE_OPTIONAL and the *HLO msg
   // doesn't contain a value corresponding to |name_|. |max| is serialised via
   // ToHandshakeMessage call if |negotiated_| is false.
   void set(uint32 max, uint32 default_value);
 
   // Returns the value negotiated if |negotiated_| is true, otherwise returns
   // default_value_ (used to set default values before negotiation finishes).
   uint32 GetUint32() const;
 
   // Serialises |name_| and value to |out|. If |negotiated_| is true then
   // |negotiated_value_| is serialised, otherwise |max_value_| is serialised.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
+  void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |negotiated_value_| to the minimum of |max_value_| and the
   // corresponding value from |peer_hello|. If the corresponding value is
   // missing and PRESENCE_OPTIONAL then |negotiated_value_| is set to
   // |default_value_|.
-  virtual QuicErrorCode ProcessPeerHello(
-      const CryptoHandshakeMessage& peer_hello,
-      HelloType hello_type,
-      std::string* error_details) override;
+  QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
+                                 HelloType hello_type,
+                                 std::string* error_details) override;
 
  private:
   uint32 max_value_;
   uint32 default_value_;
   uint32 negotiated_value_;
 };
 
 class NET_EXPORT_PRIVATE QuicNegotiableTag : public QuicNegotiableValue {
  public:
   QuicNegotiableTag(QuicTag name, QuicConfigPresence presence);
-  virtual ~QuicNegotiableTag();
+  ~QuicNegotiableTag() override;
 
   // Sets the possible values that |negotiated_tag_| can take after negotiation
   // and the default value that |negotiated_tag_| takes if OPTIONAL and *HLO
   // msg doesn't contain tag |name_|.
   void set(const QuicTagVector& possible_values, QuicTag default_value);
 
   // Returns the negotiated tag if |negotiated_| is true, otherwise returns
   // |default_value_| (used to set default values before negotiation finishes).
   QuicTag GetTag() const;
 
   // Serialises |name_| and vector (either possible or negotiated) to |out|. If
   // |negotiated_| is true then |negotiated_tag_| is serialised, otherwise
   // |possible_values_| is serialised.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
+  void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Selects the tag common to both tags in |client_hello| for |name_| and
   // |possible_values_| with preference to tag in |possible_values_|. The
   // selected tag is set as |negotiated_tag_|.
-  virtual QuicErrorCode ProcessPeerHello(
-      const CryptoHandshakeMessage& peer_hello,
-      HelloType hello_type,
-      std::string* error_details) override;
+  QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
+                                 HelloType hello_type,
+                                 std::string* error_details) override;
 
  private:
   // Reads the vector corresponding to |name_| from |msg| into |out|. If the
   // |name_| is absent in |msg| and |presence_| is set to OPTIONAL |out| is set
   // to |possible_values_|.
   QuicErrorCode ReadVector(const CryptoHandshakeMessage& msg,
                            const QuicTag** out,
                            size_t* out_length,
                            std::string* error_details) const;
 
   QuicTag negotiated_tag_;
   QuicTagVector possible_values_;
   QuicTag default_value_;
 };
 
 // Stores uint32 from CHLO or SHLO messages that are not negotiated.
 class NET_EXPORT_PRIVATE QuicFixedUint32 : public QuicConfigValue {
  public:
   QuicFixedUint32(QuicTag name, QuicConfigPresence presence);
-  virtual ~QuicFixedUint32();
+  ~QuicFixedUint32() override;
 
   bool HasSendValue() const;
 
   uint32 GetSendValue() const;
 
   void SetSendValue(uint32 value);
 
   bool HasReceivedValue() const;
 
   uint32 GetReceivedValue() const;
 
   void SetReceivedValue(uint32 value);
 
   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
+  void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |value_| to the corresponding value from |peer_hello_| if it exists.
-  virtual QuicErrorCode ProcessPeerHello(
-      const CryptoHandshakeMessage& peer_hello,
-      HelloType hello_type,
-      std::string* error_details) override;
+  QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
+                                 HelloType hello_type,
+                                 std::string* error_details) override;
 
  private:
   uint32 send_value_;
   bool has_send_value_;
   uint32 receive_value_;
   bool has_receive_value_;
 };
 
 // Stores tag from CHLO or SHLO messages that are not negotiated.
 class NET_EXPORT_PRIVATE QuicFixedTag : public QuicConfigValue {
  public:
   QuicFixedTag(QuicTag name, QuicConfigPresence presence);
-  virtual ~QuicFixedTag();
+  ~QuicFixedTag() override;
 
   bool HasSendValue() const;
 
   QuicTag GetSendValue() const;
 
   void SetSendValue(QuicTag value);
 
   bool HasReceivedValue() const;
 
   QuicTag GetReceivedValue() const;
 
   void SetReceivedValue(QuicTag value);
 
   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
+  void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |value_| to the corresponding value from |client_hello_| if it exists.
-  virtual QuicErrorCode ProcessPeerHello(
-      const CryptoHandshakeMessage& peer_hello,
-      HelloType hello_type,
-      std::string* error_details) override;
+  QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
+                                 HelloType hello_type,
+                                 std::string* error_details) override;
 
  private:
   QuicTag send_value_;
   bool has_send_value_;
   QuicTag receive_value_;
   bool has_receive_value_;
 };
 
 // Stores tag from CHLO or SHLO messages that are not negotiated.
 class NET_EXPORT_PRIVATE QuicFixedTagVector : public QuicConfigValue {
  public:
   QuicFixedTagVector(QuicTag name, QuicConfigPresence presence);
-  virtual ~QuicFixedTagVector();
+  ~QuicFixedTagVector() override;
 
   bool HasSendValues() const;
 
   QuicTagVector GetSendValues() const;
 
   void SetSendValues(const QuicTagVector& values);
 
   bool HasReceivedValues() const;
 
   QuicTagVector GetReceivedValues() const;
 
   void SetReceivedValues(const QuicTagVector& values);
 
   // If has_send_value is true, serialises |tag_vector_| and |send_value_| to
   // |out|.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
+  void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |receive_values_| to the corresponding value from |client_hello_| if
   // it exists.
-  virtual QuicErrorCode ProcessPeerHello(
-      const CryptoHandshakeMessage& peer_hello,
-      HelloType hello_type,
-      std::string* error_details) override;
+  QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
+                                 HelloType hello_type,
+                                 std::string* error_details) override;
 
  private:
   QuicTagVector send_values_;
   bool has_send_values_;
   QuicTagVector receive_values_;
   bool has_receive_values_;
 };
 
 // QuicConfig contains non-crypto configuration options that are negotiated in
 // the crypto handshake.
@@ skipping 162 matching lines @@
   // Initial session flow control receive window in bytes.
   QuicFixedUint32 initial_session_flow_control_window_bytes_;
 
   // Socket receive buffer in bytes.
   QuicFixedUint32 socket_receive_buffer_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONFIG_H_