replace OVERRIDE and FINAL with override and final in net/

net/quic/quic_headers_stream.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/quic_headers_stream.h"
 
 #include "net/quic/quic_session.h"
 
 using base::StringPiece;
 
@@ skipping 12 matching lines @@
     : public SpdyFramerVisitorInterface,
       public SpdyFramerDebugVisitorInterface {
  public:
   explicit SpdyFramerVisitor(QuicHeadersStream* stream) : stream_(stream) {}
 
   // SpdyFramerVisitorInterface implementation
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
-                           bool unidirectional) OVERRIDE {
+                           bool unidirectional) override {
     if (!stream_->IsConnected()) {
       return;
     }
 
     if (associated_stream_id != 0) {
       CloseConnection("associated_stream_id != 0");
       return;
     }
 
     if (unidirectional != 0) {
       CloseConnection("unidirectional != 0");
       return;
     }
 
     stream_->OnSynStream(stream_id, priority, fin);
   }
 
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
+  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
     if (!stream_->IsConnected()) {
       return;
     }
 
     stream_->OnSynReply(stream_id, fin);
   }
 
   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                         const char* header_data,
-                                        size_t len) OVERRIDE {
+                                        size_t len) override {
     if (!stream_->IsConnected()) {
       return false;
     }
     stream_->OnControlFrameHeaderData(stream_id, header_data, len);
     return true;
   }
 
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     if (fin && len == 0) {
       // The framer invokes OnStreamFrameData with zero-length data and
       // fin = true after processing a SYN_STREAM or SYN_REPLY frame
       // that had the fin bit set.
       return;
     }
     CloseConnection("SPDY DATA frame received.");
   }
 
-  virtual void OnError(SpdyFramer* framer) OVERRIDE {
+  virtual void OnError(SpdyFramer* framer) override {
     CloseConnection("SPDY framing error.");
   }
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     CloseConnection("SPDY DATA frame received.");
   }
 
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE {
+                           SpdyRstStreamStatus status) override {
     CloseConnection("SPDY RST_STREAM frame received.");
   }
 
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
-                         uint32 value) OVERRIDE {
+                         uint32 value) override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnSettingsAck() OVERRIDE {
+  virtual void OnSettingsAck() override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnSettingsEnd() OVERRIDE {
+  virtual void OnSettingsEnd() override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
     CloseConnection("SPDY PING frame received.");
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {
+                        SpdyGoAwayStatus status) override {
     CloseConnection("SPDY GOAWAY frame received.");
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
+  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
     CloseConnection("SPDY HEADERS frame received.");
   }
 
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE {
+                              uint32 delta_window_size) override {
     CloseConnection("SPDY WINDOW_UPDATE frame received.");
   }
 
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             bool end) OVERRIDE {
+                             bool end) override {
     LOG(DFATAL) << "PUSH_PROMISE frame received from a SPDY/3 framer";
     CloseConnection("SPDY PUSH_PROMISE frame received.");
   }
 
-  virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
+  virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
     CloseConnection("SPDY CONTINUATION frame received.");
   }
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     CloseConnection("SPDY unknown frame received.");
     return false;
   }
 
   // SpdyFramerDebugVisitorInterface implementation
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
-                                     size_t frame_len) OVERRIDE {}
+                                     size_t frame_len) override {}
 
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
-                                        size_t frame_len) OVERRIDE {
+                                        size_t frame_len) override {
     if (stream_->IsConnected()) {
       stream_->OnCompressedFrameSize(frame_len);
     }
   }
 
  private:
   void CloseConnection(const string& details) {
     if (stream_->IsConnected()) {
       stream_->CloseConnectionWithDetails(
           QUIC_INVALID_HEADERS_STREAM_DATA, details);
@@ skipping 103 matching lines @@
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   DCHECK_EQ(0u, frame_len_);
   frame_len_ = frame_len;
 }
 
 bool QuicHeadersStream::IsConnected() {
   return session()->connection()->connected();
 }
 
 }  // namespace net