replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/network/network_state_handler_unittest.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 "chromeos/network/network_state_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 42 matching lines @@
         device_list_changed_count_(0),
         device_count_(0),
         network_list_changed_count_(0),
         network_count_(0),
         default_network_change_count_(0) {
   }
 
   virtual ~TestObserver() {
   }
 
-  virtual void DeviceListChanged() OVERRIDE {
+  virtual void DeviceListChanged() override {
     NetworkStateHandler::DeviceStateList devices;
     handler_->GetDeviceList(&devices);
     device_count_ = devices.size();
     ++device_list_changed_count_;
   }
 
-  virtual void NetworkListChanged() OVERRIDE {
+  virtual void NetworkListChanged() override {
     NetworkStateHandler::NetworkStateList networks;
     handler_->GetNetworkListByType(chromeos::NetworkTypePattern::Default(),
                                    false /* configured_only */,
                                    false /* visible_only */,
                                    0 /* no limit */,
                                    &networks);
     network_count_ = networks.size();
     if (network_count_ == 0) {
       default_network_ = "";
       default_network_connection_state_ = "";
     }
     ++network_list_changed_count_;
   }
 
-  virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE {
+  virtual void DefaultNetworkChanged(const NetworkState* network) override {
     ++default_network_change_count_;
     default_network_ = network ? network->path() : "";
     default_network_connection_state_ =
         network ? network->connection_state() : "";
     DVLOG(1) << "DefaultNetworkChanged: " << default_network_
              << " State: " << default_network_connection_state_;
   }
 
   virtual void NetworkConnectionStateChanged(
-      const NetworkState* network) OVERRIDE {
+      const NetworkState* network) override {
     network_connection_state_[network->path()] = network->connection_state();
     connection_state_changes_[network->path()]++;
   }
 
-  virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE {
+  virtual void NetworkPropertiesUpdated(const NetworkState* network) override {
     DCHECK(network);
     property_updates_[network->path()]++;
   }
 
-  virtual void DevicePropertiesUpdated(const DeviceState* device) OVERRIDE {
+  virtual void DevicePropertiesUpdated(const DeviceState* device) override {
     DCHECK(device);
     device_property_updates_[device->path()]++;
   }
 
   size_t device_list_changed_count() { return device_list_changed_count_; }
   size_t device_count() { return device_count_; }
   size_t network_list_changed_count() { return network_list_changed_count_; }
   size_t network_count() { return network_count_; }
   size_t default_network_change_count() {
     return default_network_change_count_;
@@ skipping 54 matching lines @@
 
 class NetworkStateHandlerTest : public testing::Test {
  public:
   NetworkStateHandlerTest()
       : device_test_(NULL),
         manager_test_(NULL),
         profile_test_(NULL),
         service_test_(NULL) {}
   virtual ~NetworkStateHandlerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Initialize DBusThreadManager with a stub implementation.
     DBusThreadManager::Initialize();
     SetupDefaultShillState();
     network_state_handler_.reset(new NetworkStateHandler);
     test_observer_.reset(new TestObserver(network_state_handler_.get()));
     network_state_handler_->AddObserver(test_observer_.get(), FROM_HERE);
     network_state_handler_->InitShillPropertyHandler();
     message_loop_.RunUntilIdle();
     test_observer_->reset_change_counts();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     network_state_handler_->RemoveObserver(test_observer_.get(), FROM_HERE);
     test_observer_.reset();
     network_state_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
  protected:
   void AddService(const std::string& service_path,
                   const std::string& guid,
                   const std::string& name,
@@ skipping 571 matching lines @@
       kShillManagerClientStubDefaultWifi, shill::kIPConfigProperty,
       base::StringValue(kIPConfigPath));
   UpdateManagerProperties();
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(
       kShillManagerClientStubWifiDevice));
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultWifi));
 }
 
 }  // namespace chromeos