Standardize usage of virtual/override/final in net/

net/websockets/websocket_deflate_stream_test.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/websockets/websocket_deflate_stream.h"
 
 #include <stdint.h>
 #include <deque>
 #include <string>
 
@@ skipping 93 matching lines @@
   MOCK_CONST_METHOD0(GetExtensions, std::string());
 };
 
 // This mock class relies on some assumptions.
 //  - RecordInputDataFrame is called after the corresponding WriteFrames
 //    call.
 //  - RecordWrittenDataFrame is called before writing the frame.
 class WebSocketDeflatePredictorMock : public WebSocketDeflatePredictor {
  public:
   WebSocketDeflatePredictorMock() : result_(DEFLATE) {}
-  virtual ~WebSocketDeflatePredictorMock() {
+  ~WebSocketDeflatePredictorMock() override {
     // Verify whether all expectaions are consumed.
     if (!frames_to_be_input_.empty()) {
       ADD_FAILURE() << "There are missing frames to be input.";
       return;
     }
     if (!frames_written_.empty()) {
       ADD_FAILURE() << "There are extra written frames.";
       return;
     }
   }
 
   // WebSocketDeflatePredictor functions.
-  virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
-                         size_t frame_index) override {
+  Result Predict(const ScopedVector<WebSocketFrame>& frames,
+                 size_t frame_index) override {
     return result_;
   }
-  virtual void RecordInputDataFrame(const WebSocketFrame* frame) override {
+  void RecordInputDataFrame(const WebSocketFrame* frame) override {
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
       ADD_FAILURE() << "Control frames should not be recorded.";
       return;
     }
     if (frame->header.reserved1) {
       ADD_FAILURE() << "Input frame may not be compressed.";
       return;
     }
     if (frames_to_be_input_.empty()) {
       ADD_FAILURE() << "Unexpected input data frame";
       return;
     }
     if (frame != frames_to_be_input_.front()) {
       ADD_FAILURE() << "Input data frame does not match the expectation.";
       return;
     }
     frames_to_be_input_.pop_front();
   }
-  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) override {
+  void RecordWrittenDataFrame(const WebSocketFrame* frame) override {
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
       ADD_FAILURE() << "Control frames should not be recorded.";
       return;
     }
     frames_written_.push_back(frame);
   }
 
   // Sets |result_| for the |Predict| return value.
   void set_result(Result result) { result_ = result; }
 
@@ skipping 1179 matching lines @@
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(
       std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x19\x1a\x0e\0\0", 17),
       ToString(frames_passed[0]));
 }
 
 }  // namespace
 
 }  // namespace net