Standardize usage of virtual/override/final in remoting/

remoting/test/protocol_perftest.cc

 // Copyright 2014 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 "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 46 matching lines @@
   int bandwidth;
   int max_buffers;
   base::TimeDelta latency_average;
   base::TimeDelta latency_stddev;
   double out_of_order_rate;
 };
 
 class FakeCursorShapeStub : public protocol::CursorShapeStub {
  public:
   FakeCursorShapeStub() {}
-  virtual ~FakeCursorShapeStub() {}
+  ~FakeCursorShapeStub() override {}
 
   // protocol::CursorShapeStub interface.
-  virtual void SetCursorShape(
-      const protocol::CursorShapeInfo& cursor_shape) override {};
+  void SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) override{};
 };
 
 class ProtocolPerfTest
     : public testing::Test,
       public testing::WithParamInterface<NetworkPerformanceParams>,
       public ClientUserInterface,
       public VideoRenderer,
       public HostStatusObserver {
  public:
   ProtocolPerfTest()
       : host_thread_("host"),
         capture_thread_("capture"),
         encode_thread_("encode") {
     VideoScheduler::EnableTimestampsForTests();
     host_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
     capture_thread_.Start();
     encode_thread_.Start();
   }
 
   virtual ~ProtocolPerfTest() {
     host_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE, host_.release());
     host_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE,
                                                   host_signaling_.release());
     message_loop_.RunUntilIdle();
   }
 
   // ClientUserInterface interface.
-  virtual void OnConnectionState(protocol::ConnectionToHost::State state,
-                                 protocol::ErrorCode error) override {
+  void OnConnectionState(protocol::ConnectionToHost::State state,
+                         protocol::ErrorCode error) override {
     if (state == protocol::ConnectionToHost::CONNECTED) {
       client_connected_ = true;
       if (host_connected_)
         connecting_loop_->Quit();
     }
   }
-  virtual void OnConnectionReady(bool ready) override {}
-  virtual void OnRouteChanged(const std::string& channel_name,
-                              const protocol::TransportRoute& route) override {
-  }
-  virtual void SetCapabilities(const std::string& capabilities) override {}
-  virtual void SetPairingResponse(
+  void OnConnectionReady(bool ready) override {}
+  void OnRouteChanged(const std::string& channel_name,
+                      const protocol::TransportRoute& route) override {}
+  void SetCapabilities(const std::string& capabilities) override {}
+  void SetPairingResponse(
       const protocol::PairingResponse& pairing_response) override {}
-  virtual void DeliverHostMessage(
-      const protocol::ExtensionMessage& message) override {}
-  virtual protocol::ClipboardStub* GetClipboardStub() override {
-    return NULL;
-  }
-  virtual protocol::CursorShapeStub* GetCursorShapeStub() override {
+  void DeliverHostMessage(const protocol::ExtensionMessage& message) override {}
+  protocol::ClipboardStub* GetClipboardStub() override { return NULL; }
+  protocol::CursorShapeStub* GetCursorShapeStub() override {
     return &cursor_shape_stub_;
   }
 
   // VideoRenderer interface.
-  virtual void Initialize(const protocol::SessionConfig& config) override {}
-  virtual ChromotingStats* GetStats() override { return NULL; }
-  virtual void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
-                                  const base::Closure& done) override {
+  void Initialize(const protocol::SessionConfig& config) override {}
+  ChromotingStats* GetStats() override { return NULL; }
+  void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
+                          const base::Closure& done) override {
     if (video_packet->data().empty()) {
       // Ignore keep-alive packets
       done.Run();
       return;
     }
 
     last_video_packet_ = video_packet.Pass();
 
     if (!on_frame_task_.is_null())
       on_frame_task_.Run();
 
     done.Run();
   }
 
   // HostStatusObserver interface.
-  virtual void OnClientConnected(const std::string& jid) override {
+  void OnClientConnected(const std::string& jid) override {
     message_loop_.PostTask(
         FROM_HERE,
         base::Bind(&ProtocolPerfTest::OnHostConnectedMainThread,
                    base::Unretained(this)));
   }
 
  protected:
   void WaitConnected() {
     client_connected_ = false;
     host_connected_ = false;
@@ skipping 334 matching lines @@
               << "ms Encode: " << last_video_packet_->encode_time_ms()
               << "ms Capture: " << last_video_packet_->capture_time_ms()
               << "ms";
     sum += latency;
   }
 
   LOG(INFO) << "Average: " << (sum / kFrames).InMillisecondsF();
 }
 
 }  // namespace remoting