Standardize usage of virtual/override/final in google_apis/

google_apis/gcm/engine/connection_factory_impl_unittest.cc

 // Copyright (c) 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 "google_apis/gcm/engine/connection_factory_impl.h"
 
 #include <cmath>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 65 matching lines @@
 void ReadContinuation(
     scoped_ptr<google::protobuf::MessageLite> message) {
 }
 
 void WriteContinuation() {
 }
 
 class TestBackoffEntry : public net::BackoffEntry {
  public:
   explicit TestBackoffEntry(base::SimpleTestTickClock* tick_clock);
-  virtual ~TestBackoffEntry();
+  ~TestBackoffEntry() override;
 
-  virtual base::TimeTicks ImplGetTimeNow() const override;
+  base::TimeTicks ImplGetTimeNow() const override;
 
  private:
   base::SimpleTestTickClock* tick_clock_;
 };
 
 TestBackoffEntry::TestBackoffEntry(base::SimpleTestTickClock* tick_clock)
     : BackoffEntry(&kTestBackoffPolicy),
       tick_clock_(tick_clock) {
 }
 
 TestBackoffEntry::~TestBackoffEntry() {}
 
 base::TimeTicks TestBackoffEntry::ImplGetTimeNow() const {
   return tick_clock_->NowTicks();
 }
 
 // A connection factory that stubs out network requests and overrides the
 // backoff policy.
 class TestConnectionFactoryImpl : public ConnectionFactoryImpl {
  public:
   TestConnectionFactoryImpl(const base::Closure& finished_callback);
-  virtual ~TestConnectionFactoryImpl();
+  ~TestConnectionFactoryImpl() override;
 
   void InitializeFactory();
 
   // Overridden stubs.
-  virtual void ConnectImpl() override;
-  virtual void InitHandler() override;
-  virtual scoped_ptr<net::BackoffEntry> CreateBackoffEntry(
+  void ConnectImpl() override;
+  void InitHandler() override;
+  scoped_ptr<net::BackoffEntry> CreateBackoffEntry(
       const net::BackoffEntry::Policy* const policy) override;
-  virtual scoped_ptr<ConnectionHandler> CreateConnectionHandler(
+  scoped_ptr<ConnectionHandler> CreateConnectionHandler(
       base::TimeDelta read_timeout,
       const ConnectionHandler::ProtoReceivedCallback& read_callback,
       const ConnectionHandler::ProtoSentCallback& write_callback,
       const ConnectionHandler::ConnectionChangedCallback& connection_callback)
-          override;
-  virtual base::TimeTicks NowTicks() override;
+      override;
+  base::TimeTicks NowTicks() override;
 
   // Helpers for verifying connection attempts are made. Connection results
   // must be consumed.
   void SetConnectResult(int connect_result);
   void SetMultipleConnectResults(int connect_result, int num_expected_attempts);
 
   // Force a login handshake to be delayed.
   void SetDelayLogin(bool delay_login);
 
   base::SimpleTestTickClock* tick_clock() { return &tick_clock_; }
@@ skipping 123 matching lines @@
  public:
   ConnectionFactoryImplTest();
   virtual ~ConnectionFactoryImplTest();
 
   TestConnectionFactoryImpl* factory() { return &factory_; }
   GURL& connected_server() { return connected_server_; }
 
   void WaitForConnections();
 
   // ConnectionFactory::ConnectionListener
-  virtual void OnConnected(const GURL& current_server,
-                           const net::IPEndPoint& ip_endpoint) override;
-  virtual void OnDisconnected() override;
+  void OnConnected(const GURL& current_server,
+                   const net::IPEndPoint& ip_endpoint) override;
+  void OnDisconnected() override;
 
  private:
   void ConnectionsComplete();
 
   TestConnectionFactoryImpl factory_;
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   GURL connected_server_;
 };
@@ skipping 259 matching lines @@
   // When the network returns, attempt to connect.
   factory()->SetConnectResult(net::OK);
   factory()->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_4G);
   WaitForConnections();
 
   EXPECT_TRUE(factory()->IsEndpointReachable());
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
 }
 
 }  // namespace gcm