Standardize usage of virtual/override/final in net/

net/spdy/spdy_protocol.h

 // Copyright (c) 2012 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.
 
 // This file contains some protocol structures for use with SPDY 2 and 3
 // The SPDY 2 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
@@ skipping 541 matching lines @@
   SpdyFrameIR() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameIR);
 };
 
 // Abstract class intended to be inherited by IRs that have a stream associated
 // to them.
 class NET_EXPORT_PRIVATE SpdyFrameWithStreamIdIR : public SpdyFrameIR {
  public:
-  virtual ~SpdyFrameWithStreamIdIR() {}
+  ~SpdyFrameWithStreamIdIR() override {}
   SpdyStreamId stream_id() const { return stream_id_; }
   void set_stream_id(SpdyStreamId stream_id) {
     DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
     stream_id_ = stream_id;
   }
 
  protected:
   explicit SpdyFrameWithStreamIdIR(SpdyStreamId stream_id) {
     set_stream_id(stream_id);
   }
 
  private:
   SpdyStreamId stream_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithStreamIdIR);
 };
 
 // Abstract class intended to be inherited by IRs that have the option of a FIN
 // flag. Implies SpdyFrameWithStreamIdIR.
 class NET_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameWithStreamIdIR {
  public:
-  virtual ~SpdyFrameWithFinIR() {}
+  ~SpdyFrameWithFinIR() override {}
   bool fin() const { return fin_; }
   void set_fin(bool fin) { fin_ = fin; }
 
  protected:
   explicit SpdyFrameWithFinIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id),
         fin_(false) {}
 
  private:
   bool fin_;
@@ skipping 16 matching lines @@
   void SetHeader(const base::StringPiece& name,
                  const base::StringPiece& value) {
     name_value_block_[name.as_string()] = value.as_string();
   }
   SpdyNameValueBlock* mutable_name_value_block() {
     return &name_value_block_;
   }
 
  protected:
   explicit SpdyFrameWithNameValueBlockIR(SpdyStreamId stream_id);
-  virtual ~SpdyFrameWithNameValueBlockIR();
+  ~SpdyFrameWithNameValueBlockIR() override;
 
  private:
   SpdyNameValueBlock name_value_block_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithNameValueBlockIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyDataIR
     : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) {
  public:
   // Performs deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, const base::StringPiece& data);
 
   // Use in conjunction with SetDataShallow() for shallow-copy on data.
   explicit SpdyDataIR(SpdyStreamId stream_id);
 
-  virtual ~SpdyDataIR();
+  ~SpdyDataIR() override;
 
   base::StringPiece data() const { return data_; }
 
   bool padded() const { return padded_; }
 
   int padding_payload_len() const { return padding_payload_len_; }
 
   void set_padding_len(int padding_len) {
     DCHECK_GT(padding_len, 0);
     DCHECK_LE(padding_len, kPaddingSizePerFrame);
     padded_ = true;
     // The pad field takes one octet on the wire.
     padding_payload_len_ = padding_len - 1;
   }
 
   // Deep-copy of data (keep private copy).
   void SetDataDeep(const base::StringPiece& data) {
     data_store_.reset(new std::string(data.data(), data.length()));
     data_ = *(data_store_.get());
   }
 
   // Shallow-copy of data (do not keep private copy).
   void SetDataShallow(const base::StringPiece& data) {
     data_store_.reset();
     data_ = data;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   // Used to store data that this SpdyDataIR should own.
   scoped_ptr<std::string> data_store_;
   base::StringPiece data_;
 
   bool padded_;
   // padding_payload_len_ = desired padding length - len(padding length field).
   int padding_payload_len_;
 
@@ skipping 14 matching lines @@
   void set_associated_to_stream_id(SpdyStreamId stream_id) {
     associated_to_stream_id_ = stream_id;
   }
   SpdyPriority priority() const { return priority_; }
   void set_priority(SpdyPriority priority) { priority_ = priority; }
   bool unidirectional() const { return unidirectional_; }
   void set_unidirectional(bool unidirectional) {
     unidirectional_ = unidirectional;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId associated_to_stream_id_;
   SpdyPriority priority_;
   bool unidirectional_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySynStreamIR);
 };
 
 class NET_EXPORT_PRIVATE SpdySynReplyIR : public SpdyFrameWithNameValueBlockIR {
  public:
   explicit SpdySynReplyIR(SpdyStreamId stream_id)
       : SpdyFrameWithNameValueBlockIR(stream_id) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdySynReplyIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameWithStreamIdIR {
  public:
   SpdyRstStreamIR(SpdyStreamId stream_id, SpdyRstStreamStatus status,
                   base::StringPiece description);
 
-  virtual ~SpdyRstStreamIR();
+  ~SpdyRstStreamIR() override;
 
   SpdyRstStreamStatus status() const {
     return status_;
   }
   void set_status(SpdyRstStreamStatus status) {
     status_ = status;
   }
 
   base::StringPiece description() const { return description_; }
 
   void set_description(base::StringPiece description) {
     description_ = description;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyRstStreamStatus status_;
   base::StringPiece description_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyRstStreamIR);
 };
 
 class NET_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
  public:
   // Associates flags with a value.
   struct Value {
     Value() : persist_value(false),
               persisted(false),
               value(0) {}
     bool persist_value;
     bool persisted;
     int32 value;
   };
   typedef std::map<SpdySettingsIds, Value> ValueMap;
 
   SpdySettingsIR();
 
-  virtual ~SpdySettingsIR();
+  ~SpdySettingsIR() override;
 
   // Overwrites as appropriate.
   const ValueMap& values() const { return values_; }
   void AddSetting(SpdySettingsIds id,
                   bool persist_value,
                   bool persisted,
                   int32 value) {
     values_[id].persist_value = persist_value;
     values_[id].persisted = persisted;
     values_[id].value = value;
   }
 
   bool clear_settings() const { return clear_settings_; }
   void set_clear_settings(bool clear_settings) {
     clear_settings_ = clear_settings;
   }
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) {
     is_ack_ = is_ack;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   ValueMap values_;
   bool clear_settings_;
   bool is_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySettingsIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyPingIR : public SpdyFrameIR {
  public:
   explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {}
   SpdyPingId id() const { return id_; }
 
   // ACK logic is valid only for SPDY versions 4 and above.
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyPingId id_;
   bool is_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyPingIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR {
  public:
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyGoAwayStatus status,
                const base::StringPiece& description);
-  virtual ~SpdyGoAwayIR();
+  ~SpdyGoAwayIR() override;
   SpdyStreamId last_good_stream_id() const { return last_good_stream_id_; }
   void set_last_good_stream_id(SpdyStreamId last_good_stream_id) {
     DCHECK_LE(0u, last_good_stream_id);
     DCHECK_EQ(0u, last_good_stream_id & ~kStreamIdMask);
     last_good_stream_id_ = last_good_stream_id;
   }
   SpdyGoAwayStatus status() const { return status_; }
   void set_status(SpdyGoAwayStatus status) {
     // TODO(hkhalil): Check valid ranges of status?
     status_ = status;
   }
 
   const base::StringPiece& description() const;
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId last_good_stream_id_;
   SpdyGoAwayStatus status_;
   const base::StringPiece description_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyGoAwayIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithNameValueBlockIR {
  public:
   explicit SpdyHeadersIR(SpdyStreamId stream_id)
     : SpdyFrameWithNameValueBlockIR(stream_id),
       has_priority_(false),
       priority_(0) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
   bool has_priority() const { return has_priority_; }
   void set_has_priority(bool has_priority) { has_priority_ = has_priority; }
   uint32 priority() const { return priority_; }
   void set_priority(SpdyPriority priority) { priority_ = priority; }
 
  private:
   bool has_priority_;
   // 31-bit priority.
   uint32 priority_;
   DISALLOW_COPY_AND_ASSIGN(SpdyHeadersIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameWithStreamIdIR {
  public:
   SpdyWindowUpdateIR(SpdyStreamId stream_id, int32 delta)
       : SpdyFrameWithStreamIdIR(stream_id) {
     set_delta(delta);
   }
   int32 delta() const { return delta_; }
   void set_delta(int32 delta) {
     DCHECK_LT(0, delta);
     DCHECK_LE(delta, kSpdyMaximumWindowSize);
     delta_ = delta;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   int32 delta_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWindowUpdateIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyBlockedIR
     : public NON_EXPORTED_BASE(SpdyFrameWithStreamIdIR) {
  public:
   explicit SpdyBlockedIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyBlockedIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyPushPromiseIR
     : public SpdyFrameWithNameValueBlockIR {
  public:
   SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
       : SpdyFrameWithNameValueBlockIR(stream_id),
         promised_stream_id_(promised_stream_id) {}
   SpdyStreamId promised_stream_id() const { return promised_stream_id_; }
   void set_promised_stream_id(SpdyStreamId id) { promised_stream_id_ = id; }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId promised_stream_id_;
   DISALLOW_COPY_AND_ASSIGN(SpdyPushPromiseIR);
 };
 
 // TODO(jgraettinger): This representation needs review. SpdyContinuationIR
 // needs to frame a portion of a single, arbitrarily-broken encoded buffer.
 class NET_EXPORT_PRIVATE SpdyContinuationIR
     : public SpdyFrameWithNameValueBlockIR {
  public:
   explicit SpdyContinuationIR(SpdyStreamId stream_id)
       : SpdyFrameWithNameValueBlockIR(stream_id),
         end_headers_(false) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
   bool end_headers() const { return end_headers_; }
   void set_end_headers(bool end_headers) {end_headers_ = end_headers;}
 
  private:
   bool end_headers_;
   DISALLOW_COPY_AND_ASSIGN(SpdyContinuationIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
@@ skipping 13 matching lines @@
   void set_protocol_id(SpdyProtocolId protocol_id) {
     protocol_id_ = protocol_id;
   }
   void set_host(std::string host) {
     host_ = host;
   }
   void set_origin(std::string origin) {
     origin_ = origin;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   uint32 max_age_;
   uint16 port_;
   SpdyProtocolId protocol_id_;
   std::string host_;
   std::string origin_;
   DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
  public:
   explicit SpdyPriorityIR(SpdyStreamId stream_id);
   explicit SpdyPriorityIR(SpdyStreamId stream_id,
                           SpdyStreamId parent_stream_id,
                           uint8 weight,
                           bool exclusive);
   SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
   void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
   uint8 weight() const { return weight_; }
   void set_weight(uint8 weight) { weight_ = weight; }
   bool exclusive() const { return exclusive_; }
   void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const override;
+  void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId parent_stream_id_;
   uint8 weight_;
   bool exclusive_;
   DISALLOW_COPY_AND_ASSIGN(SpdyPriorityIR);
 };
 
 // -------------------------------------------------------------------------
 // Wrapper classes for various SPDY frames.
@@ skipping 63 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_