Standardize usage of virtual/override/final in chrome/browser/extensions/

chrome/browser/extensions/api/dial/dial_registry.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_REGISTRY_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_REGISTRY_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 40 matching lines @@
     virtual ~Observer() {}
   };
 
   // Create the DIAL registry and pass a reference to allow it to notify on
   // DIAL device events.
   DialRegistry(Observer* dial_api,
                const base::TimeDelta& refresh_interval,
                const base::TimeDelta& expiration,
                const size_t max_devices);
 
-  virtual ~DialRegistry();
+  ~DialRegistry() override;
 
   // Called by the DIAL API when event listeners are added or removed. The dial
   // service is started after the first listener is added and stopped after the
   // last listener is removed.
   void OnListenerAdded();
   void OnListenerRemoved();
 
   // Called by the DIAL API to try to kickoff a discovery if there is not one
   // already active.
   bool DiscoverNow();
 
  protected:
   // Returns a new instance of the DIAL service.  Overridden by tests.
   virtual DialService* CreateDialService();
   virtual void ClearDialService();
 
   // Returns the current time.  Overridden by tests.
   virtual base::Time Now() const;
 
  protected:
   // The DIAL service. Periodic discovery is active when this is not NULL.
   scoped_ptr<DialService> dial_;
 
  private:
   typedef base::hash_map<std::string, linked_ptr<DialDeviceData> >
       DeviceByIdMap;
   typedef std::map<std::string, linked_ptr<DialDeviceData> > DeviceByLabelMap;
 
   // DialService::Observer:
-  virtual void OnDiscoveryRequest(DialService* service) override;
-  virtual void OnDeviceDiscovered(DialService* service,
-                                  const DialDeviceData& device) override;
-  virtual void OnDiscoveryFinished(DialService* service) override;
-  virtual void OnError(DialService* service,
-                       const DialService::DialServiceErrorCode& code) override;
+  void OnDiscoveryRequest(DialService* service) override;
+  void OnDeviceDiscovered(DialService* service,
+                          const DialDeviceData& device) override;
+  void OnDiscoveryFinished(DialService* service) override;
+  void OnError(DialService* service,
+               const DialService::DialServiceErrorCode& code) override;
 
   // net::NetworkChangeObserver:
-  virtual void OnNetworkChanged(
+  void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) override;
 
   // Starts and stops periodic discovery.  Periodic discovery is done when there
   // are registered event listeners.
   void StartPeriodicDiscovery();
   void StopPeriodicDiscovery();
 
   // Check whether we are in a state ready to discover and dispatch error
   // notifications if not.
   bool ReadyToDiscover();
@@ skipping 74 matching lines @@
                            TestRemovingListenerDoesNotClearList);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestNetworkEventConnectionLost);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest,
                            TestNetworkEventConnectionRestored);
   DISALLOW_COPY_AND_ASSIGN(DialRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_REGISTRY_H_