Standardize usage of virtual/override/final specifiers.

net/quic/quic_end_to_end_unittest.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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/elements_upload_data_stream.h"
@@ skipping 31 matching lines @@
 namespace {
 
 const char kResponseBody[] = "some arbitrary response body";
 
 // Factory for creating HttpTransactions, used by TestTransactionConsumer.
 class TestTransactionFactory : public HttpTransactionFactory {
  public:
   TestTransactionFactory(const HttpNetworkSession::Params& params)
       : session_(new HttpNetworkSession(params)) {}
 
-  virtual ~TestTransactionFactory() {
-  }
+  ~TestTransactionFactory() override {}
 
   // HttpTransactionFactory methods
-  virtual int CreateTransaction(RequestPriority priority,
-                                scoped_ptr<HttpTransaction>* trans) override {
+  int CreateTransaction(RequestPriority priority,
+                        scoped_ptr<HttpTransaction>* trans) override {
     trans->reset(new HttpNetworkTransaction(priority, session_.get()));
     return OK;
   }
 
-  virtual HttpCache* GetCache() override {
-    return nullptr;
-  }
+  HttpCache* GetCache() override { return nullptr; }
 
-  virtual HttpNetworkSession* GetSession() override { return session_.get(); };
+  HttpNetworkSession* GetSession() override { return session_.get(); };
 
  private:
   scoped_refptr<HttpNetworkSession> session_;
 };
 
 }  // namespace
 
 class QuicEndToEndTest : public PlatformTest {
  protected:
   QuicEndToEndTest()
@@ skipping 21 matching lines @@
   }
 
   // Creates a mock host resolver in which www.google.com
   // resolves to localhost.
   static MockHostResolver* CreateResolverImpl() {
     MockHostResolver* resolver = new MockHostResolver();
     resolver->rules()->AddRule("www.google.com", "127.0.0.1");
     return resolver;
   }
 
-  virtual void SetUp() {
+  void SetUp() override {
     QuicInMemoryCachePeer::ResetForTests();
     StartServer();
 
     // Use a mapped host resolver so that request for www.google.com (port 80)
     // reach the server running on localhost.
     std::string map_rule = "MAP www.google.com www.google.com:" +
         base::IntToString(server_thread_->GetPort());
     EXPECT_TRUE(host_resolver_.AddRuleFromString(map_rule));
 
     // To simplify the test, and avoid the race with the HTTP request, we force
     // QUIC for these requests.
     params_.origin_to_force_quic_on =
         HostPortPair::FromString("www.google.com:80");
 
     transaction_factory_.reset(new TestTransactionFactory(params_));
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     StopServer();
     QuicInMemoryCachePeer::ResetForTests();
   }
 
   // Starts the QUIC server listening on a random port.
   void StartServer() {
     net::IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
     server_address_ = IPEndPoint(ip, 0);
     server_config_.SetInitialFlowControlWindowToSend(
@@ skipping 168 matching lines @@
   base::MessageLoop::current()->Run();
 
   for (size_t i = 0; i < num_requests; ++i) {
     CheckResponse(*consumers[i], "HTTP/1.1 200 OK", kResponseBody);
   }
   STLDeleteElements(&consumers);
 }
 
 }  // namespace test
 }  // namespace net