Standardize usage of virtual/override/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;
 
 namespace net {
 
 namespace {
 
 const QuicStreamId kInvalidStreamId = 0;
 
 }  // namespace
 
 // A SpdyFramer visitor which passed SYN_STREAM and SYN_REPLY frames to
 // the QuicDataStream, and closes the connection if any unexpected frames
 // are received.
 class QuicHeadersStream::SpdyFramerVisitor
     : 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 {
+  void OnSynStream(SpdyStreamId stream_id,
+                   SpdyStreamId associated_stream_id,
+                   SpdyPriority priority,
+                   bool fin,
+                   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 {
+  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 {
+  bool OnControlFrameHeaderData(SpdyStreamId stream_id,
+                                const char* header_data,
+                                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 {
+  void OnStreamFrameData(SpdyStreamId stream_id,
+                         const char* data,
+                         size_t len,
+                         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 {
+  void OnError(SpdyFramer* framer) override {
     CloseConnection("SPDY framing error.");
   }
 
-  virtual void OnDataFrameHeader(SpdyStreamId stream_id,
-                                 size_t length,
-                                 bool fin) override {
+  void OnDataFrameHeader(SpdyStreamId stream_id,
+                         size_t length,
+                         bool fin) override {
     CloseConnection("SPDY DATA frame received.");
   }
 
-  virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) override {
+  void OnRstStream(SpdyStreamId stream_id,
+                   SpdyRstStreamStatus status) override {
     CloseConnection("SPDY RST_STREAM frame received.");
   }
 
-  virtual void OnSetting(SpdySettingsIds id,
-                         uint8 flags,
-                         uint32 value) override {
+  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnSettingsAck() override {
+  void OnSettingsAck() override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnSettingsEnd() override {
+  void OnSettingsEnd() override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
+  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 {
+  void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                SpdyGoAwayStatus status) override {
     CloseConnection("SPDY GOAWAY frame received.");
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
+  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 {
+  void OnWindowUpdate(SpdyStreamId stream_id,
+                      uint32 delta_window_size) override {
     CloseConnection("SPDY WINDOW_UPDATE frame received.");
   }
 
-  virtual void OnPushPromise(SpdyStreamId stream_id,
-                             SpdyStreamId promised_stream_id,
-                             bool end) override {
+  void OnPushPromise(SpdyStreamId stream_id,
+                     SpdyStreamId promised_stream_id,
+                     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 {
+  void OnContinuation(SpdyStreamId stream_id, bool end) override {
     CloseConnection("SPDY CONTINUATION frame received.");
   }
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
+  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 {}
+  void OnSendCompressedFrame(SpdyStreamId stream_id,
+                             SpdyFrameType type,
+                             size_t payload_len,
+                             size_t frame_len) override {}
 
-  virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
-                                        SpdyFrameType type,
-                                        size_t frame_len) override {
+  void OnReceiveCompressedFrame(SpdyStreamId stream_id,
+                                SpdyFrameType type,
+                                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