replace OVERRIDE and FINAL with override and 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 645 matching lines @@
     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;
+  virtual 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;
+  virtual 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;
+  virtual 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();
 
   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;
+  virtual 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:
@@ skipping 25 matching lines @@
 
   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;
+  virtual 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;
+  virtual 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();
   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;
+  virtual 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;
+  virtual 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;
+  virtual 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;
+  virtual 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;
+  virtual 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;
+  virtual 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;
+  virtual 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;
+  virtual 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_