Standardize usage of virtual/override/final in content/browser/

content/browser/devtools/tethering_handler.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 "content/browser/devtools/tethering_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 32 matching lines @@
   }
 
   std::string Init() {
     std::string channel_name;
     server_socket_ = delegate_->CreateSocketForTethering(this, &channel_name);
     if (!server_socket_.get() || channel_name.empty())
       SelfDestruct();
     return channel_name;
   }
 
-  virtual ~SocketPump() { }
+  ~SocketPump() override {}
 
  private:
-  virtual void DidAccept(net::StreamListenSocket* server,
-                         scoped_ptr<net::StreamListenSocket> socket) override {
+  void DidAccept(net::StreamListenSocket* server,
+                 scoped_ptr<net::StreamListenSocket> socket) override {
     if (accepted_socket_.get())
       return;
 
     buffer_ = new net::IOBuffer(kBufferSize);
     wire_buffer_ = new net::GrowableIOBuffer();
     wire_buffer_->SetCapacity(kBufferSize);
 
     accepted_socket_ = socket.Pass();
     int result = client_socket_->Read(
         buffer_.get(),
         kBufferSize,
         base::Bind(&SocketPump::OnClientRead, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       OnClientRead(result);
   }
 
-  virtual void DidRead(net::StreamListenSocket* socket,
-                       const char* data,
-                       int len) override {
+  void DidRead(net::StreamListenSocket* socket,
+               const char* data,
+               int len) override {
     int old_size = wire_buffer_size_;
     wire_buffer_size_ += len;
     while (wire_buffer_->capacity() < wire_buffer_size_)
       wire_buffer_->SetCapacity(wire_buffer_->capacity() * 2);
     memcpy(wire_buffer_->StartOfBuffer() + old_size, data, len);
     if (old_size != wire_buffer_->offset())
       return;
     OnClientWrite(0);
   }
 
-  virtual void DidClose(net::StreamListenSocket* socket) override {
-    SelfDestruct();
-  }
+  void DidClose(net::StreamListenSocket* socket) override { SelfDestruct(); }
 
   void OnClientRead(int result) {
     if (result <= 0) {
       SelfDestruct();
       return;
     }
 
     accepted_socket_->Send(buffer_->data(), result);
     result = client_socket_->Read(
         buffer_.get(),
@@ skipping 334 matching lines @@
   SendAsyncResponse(command->SuccessResponse(nullptr));
 }
 
 void TetheringHandler::SendInternalError(
     scoped_refptr<DevToolsProtocol::Command> command,
     const std::string& message) {
   SendAsyncResponse(command->InternalErrorResponse(message));
 }
 
 }  // namespace content