Standardize usage of virtual/override/final in net/

net/spdy/spdy_framer_test.cc

 // 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.
 
 #include <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 64 matching lines @@
     explicit DecompressionVisitor(SpdyMajorVersion version)
         : version_(version), size_(0), finished_(false) {}
 
     void ResetBuffer() {
       CHECK(buffer_.get() == NULL);
       CHECK_EQ(0u, size_);
       CHECK(!finished_);
       buffer_.reset(new char[kMaxDecompressedSize]);
     }
 
-    virtual void OnError(SpdyFramer* framer) override { LOG(FATAL); }
-    virtual void OnDataFrameHeader(SpdyStreamId stream_id,
-                                   size_t length,
-                                   bool fin) override {
+    void OnError(SpdyFramer* framer) override { LOG(FATAL); }
+    void OnDataFrameHeader(SpdyStreamId stream_id,
+                           size_t length,
+                           bool fin) override {
       LOG(FATAL) << "Unexpected data frame header";
     }
-    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 {
       LOG(FATAL);
     }
 
-    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 {
       CHECK(buffer_.get() != NULL);
       CHECK_GE(kMaxDecompressedSize, size_ + len);
       CHECK(!finished_);
       if (len != 0) {
         memcpy(buffer_.get() + size_, header_data, len);
         size_ += len;
       } else {
         // Done.
         finished_ = true;
       }
       return true;
     }
 
-    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 {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdySynStreamIR syn_stream(stream_id);
       syn_stream.set_associated_to_stream_id(associated_stream_id);
       syn_stream.set_priority(priority);
       syn_stream.set_fin(fin);
       syn_stream.set_unidirectional(unidirectional);
       scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetSynStreamMinimumSize());
       size_ += framer.GetSynStreamMinimumSize();
     }
 
-    virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
+    void OnSynReply(SpdyStreamId stream_id, bool fin) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyHeadersIR headers(stream_id);
       headers.set_fin(fin);
       scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
       size_ += framer.GetSynStreamMinimumSize();
     }
 
-    virtual void OnRstStream(SpdyStreamId stream_id,
-                             SpdyRstStreamStatus status) override {
+    void OnRstStream(SpdyStreamId stream_id,
+                     SpdyRstStreamStatus status) override {
       LOG(FATAL);
     }
-    virtual void OnSetting(SpdySettingsIds id,
-                           uint8 flags,
-                           uint32 value) override {
+    void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
       LOG(FATAL);
     }
-    virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
-      LOG(FATAL);
-    }
-    virtual void OnSettingsEnd() override { LOG(FATAL); }
-    virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                          SpdyGoAwayStatus status) override {
+    void OnPing(SpdyPingId unique_id, bool is_ack) override { LOG(FATAL); }
+    void OnSettingsEnd() override { LOG(FATAL); }
+    void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                  SpdyGoAwayStatus status) override {
       LOG(FATAL);
     }
 
-    virtual void OnHeaders(SpdyStreamId stream_id,
-                           bool fin,
-                           bool end) override {
+    void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyHeadersIR headers(stream_id);
       headers.set_fin(fin);
       scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
       size_ += framer.GetHeadersMinimumSize();
     }
 
     virtual void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {
       LOG(FATAL);
     }
 
-    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 {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
       scoped_ptr<SpdyFrame> frame(framer.SerializePushPromise(push_promise));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetPushPromiseMinimumSize());
       size_ += framer.GetPushPromiseMinimumSize();
     }
 
-    virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
+    void OnContinuation(SpdyStreamId stream_id, bool end) override {
       LOG(FATAL);
     }
 
-    virtual void OnPriority(SpdyStreamId stream_id,
-                            SpdyStreamId parent_stream_id,
-                            uint8 weight,
-                            bool exclusive) override {
+    void OnPriority(SpdyStreamId stream_id,
+                    SpdyStreamId parent_stream_id,
+                    uint8 weight,
+                    bool exclusive) override {
       // Do nothing.
     }
 
-    virtual bool OnUnknownFrame(SpdyStreamId stream_id,
-                                int frame_type) override {
+    bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
       LOG(FATAL);
       return false;
     }
 
     char* ReleaseBuffer() {
       CHECK(finished_);
       return buffer_.release();
     }
 
-    virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                                uint32 delta_window_size) override {
+    void OnWindowUpdate(SpdyStreamId stream_id,
+                        uint32 delta_window_size) override {
       LOG(FATAL);
     }
 
     size_t size() const {
       CHECK(finished_);
       return size_;
     }
 
    private:
     SpdyMajorVersion version_;
@@ skipping 46 matching lines @@
         data_frame_count_(0),
         last_payload_len_(0),
         last_frame_len_(0),
         header_buffer_(new char[kDefaultHeaderBufferSize]),
         header_buffer_length_(0),
         header_buffer_size_(kDefaultHeaderBufferSize),
         header_stream_id_(static_cast<SpdyStreamId>(-1)),
         header_control_type_(DATA),
         header_buffer_valid_(false) {}
 
-  virtual void OnError(SpdyFramer* f) override {
+  void OnError(SpdyFramer* f) override {
     LOG(INFO) << "SpdyFramer Error: "
               << SpdyFramer::ErrorCodeToString(f->error_code());
     ++error_count_;
   }
 
-  virtual void OnDataFrameHeader(SpdyStreamId stream_id,
-                                 size_t length,
-                                 bool fin) override {
+  void OnDataFrameHeader(SpdyStreamId stream_id,
+                         size_t length,
+                         bool fin) override {
     ++data_frame_count_;
     header_stream_id_ = stream_id;
   }
 
-  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 {
     EXPECT_EQ(header_stream_id_, stream_id);
     if (len == 0)
       ++zero_length_data_frame_count_;
 
     data_bytes_ += len;
     std::cerr << "OnStreamFrameData(" << stream_id << ", \"";
     if (len > 0) {
       for (size_t i = 0 ; i < len; ++i) {
         std::cerr << std::hex << (0xFF & (unsigned int)data[i]) << std::dec;
       }
     }
     std::cerr << "\", " << len << ")\n";
   }
 
-  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 {
     ++control_frame_header_data_count_;
     CHECK_EQ(header_stream_id_, stream_id);
     if (len == 0) {
       ++zero_length_control_frame_header_data_count_;
       // Indicates end-of-header-block.
       headers_.clear();
       CHECK(header_buffer_valid_);
       size_t parsed_length = framer_.ParseHeaderBlockInBuffer(
           header_buffer_.get(), header_buffer_length_, &headers_);
       LOG_IF(DFATAL, header_buffer_length_ != parsed_length)
           << "Check failed: header_buffer_length_ == parsed_length "
           << "(" << header_buffer_length_ << " vs. " << parsed_length << ")";
       return true;
     }
     const size_t available = header_buffer_size_ - header_buffer_length_;
     if (len > available) {
       header_buffer_valid_ = false;
       return false;
     }
     memcpy(header_buffer_.get() + header_buffer_length_, header_data, len);
     header_buffer_length_ += len;
     return true;
   }
 
-  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 {
     ++syn_frame_count_;
     if (framer_.protocol_version() > SPDY3) {
       InitHeaderStreaming(HEADERS, stream_id);
     } else {
       InitHeaderStreaming(SYN_STREAM, stream_id);
     }
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
+  void OnSynReply(SpdyStreamId stream_id, bool fin) override {
     ++syn_reply_frame_count_;
     if (framer_.protocol_version() > SPDY3) {
       InitHeaderStreaming(HEADERS, stream_id);
     } else {
       InitHeaderStreaming(SYN_REPLY, stream_id);
     }
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
-  virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) override {
+  void OnRstStream(SpdyStreamId stream_id,
+                   SpdyRstStreamStatus status) override {
     ++fin_frame_count_;
   }
 
-  virtual bool OnRstStreamFrameData(const char* rst_stream_data,
-                                    size_t len) override {
+  bool OnRstStreamFrameData(const char* rst_stream_data, size_t len) override {
     if ((rst_stream_data != NULL) && (len > 0)) {
       fin_opaque_data_ += std::string(rst_stream_data, len);
     }
     return true;
   }
 
-  virtual void OnSetting(SpdySettingsIds id,
-                         uint8 flags,
-                         uint32 value) override {
+  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
     ++setting_count_;
   }
 
-  virtual void OnSettingsAck() override {
+  void OnSettingsAck() override {
     DCHECK_LT(SPDY3, framer_.protocol_version());
     ++settings_ack_received_;
   }
 
-  virtual void OnSettingsEnd() override {
+  void OnSettingsEnd() override {
     if (framer_.protocol_version() <= SPDY3) { return; }
     ++settings_ack_sent_;
   }
 
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
-    DLOG(FATAL);
-  }
+  void OnPing(SpdyPingId unique_id, bool is_ack) override { DLOG(FATAL); }
 
-  virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) override {
+  void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                SpdyGoAwayStatus status) override {
     ++goaway_count_;
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
+  void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
     ++headers_frame_count_;
     InitHeaderStreaming(HEADERS, stream_id);
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
-  virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) override {
+  void OnWindowUpdate(SpdyStreamId stream_id,
+                      uint32 delta_window_size) override {
     last_window_update_stream_ = stream_id;
     last_window_update_delta_ = delta_window_size;
   }
 
-  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 {
     ++push_promise_frame_count_;
     InitHeaderStreaming(PUSH_PROMISE, stream_id);
     last_push_promise_stream_ = stream_id;
     last_push_promise_promised_stream_ = promised_stream_id;
   }
 
-  virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
+  void OnContinuation(SpdyStreamId stream_id, bool end) override {
     ++continuation_count_;
   }
 
-  virtual void OnAltSvc(SpdyStreamId stream_id,
-                        uint32 max_age,
-                        uint16 port,
-                        StringPiece protocol_id,
-                        StringPiece host,
-                        StringPiece origin) override {
+  void OnAltSvc(SpdyStreamId stream_id,
+                uint32 max_age,
+                uint16 port,
+                StringPiece protocol_id,
+                StringPiece host,
+                StringPiece origin) override {
     test_altsvc_ir_.set_stream_id(stream_id);
     test_altsvc_ir_.set_max_age(max_age);
     test_altsvc_ir_.set_port(port);
     test_altsvc_ir_.set_protocol_id(protocol_id.as_string());
     test_altsvc_ir_.set_host(host.as_string());
     if (origin.length() > 0) {
       test_altsvc_ir_.set_origin(origin.as_string());
     }
     ++altsvc_count_;
   }
 
-  virtual void OnPriority(SpdyStreamId stream_id,
-                          SpdyStreamId parent_stream_id,
-                          uint8 weight,
-                          bool exclusive) override {
+  void OnPriority(SpdyStreamId stream_id,
+                  SpdyStreamId parent_stream_id,
+                  uint8 weight,
+                  bool exclusive) override {
     ++priority_count_;
   }
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
+  bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     DLOG(INFO) << "Unknown frame type " << frame_type;
     return on_unknown_frame_result_;
   }
 
-  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 {
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
-  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 {
     last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
     size_t input_remaining = size;
     const char* input_ptr = reinterpret_cast<const char*>(input);
     while (input_remaining > 0 &&
@@ skipping 5070 matching lines @@
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 }  // namespace net