replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/network/shill_property_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/shill_property_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 23 matching lines @@
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 class TestListener : public internal::ShillPropertyHandler::Listener {
  public:
   TestListener() : technology_list_updates_(0),
                    errors_(0) {
   }
 
   virtual void UpdateManagedList(ManagedState::ManagedType type,
-                                 const base::ListValue& entries) OVERRIDE {
+                                 const base::ListValue& entries) override {
     VLOG(1) << "UpdateManagedList[" << ManagedState::TypeToString(type) << "]: "
             << entries.GetSize();
     UpdateEntries(GetTypeString(type), entries);
   }
 
   virtual void UpdateManagedStateProperties(
       ManagedState::ManagedType type,
       const std::string& path,
-      const base::DictionaryValue& properties) OVERRIDE {
+      const base::DictionaryValue& properties) override {
     VLOG(2) << "UpdateManagedStateProperties: " << GetTypeString(type);
     initial_property_updates(GetTypeString(type))[path] += 1;
   }
 
-  virtual void ProfileListChanged() OVERRIDE {
+  virtual void ProfileListChanged() override {
   }
 
   virtual void UpdateNetworkServiceProperty(
       const std::string& service_path,
       const std::string& key,
-      const base::Value& value) OVERRIDE {
+      const base::Value& value) override {
     AddPropertyUpdate(shill::kServiceCompleteListProperty, service_path);
   }
 
   virtual void UpdateDeviceProperty(
       const std::string& device_path,
       const std::string& key,
-      const base::Value& value) OVERRIDE {
+      const base::Value& value) override {
     AddPropertyUpdate(shill::kDevicesProperty, device_path);
   }
 
   virtual void UpdateIPConfigProperties(
       ManagedState::ManagedType type,
       const std::string& path,
       const std::string& ip_config_path,
-      const base::DictionaryValue& properties) OVERRIDE {
+      const base::DictionaryValue& properties) override {
     AddPropertyUpdate(shill::kIPConfigsProperty, ip_config_path);
   }
 
-  virtual void TechnologyListChanged() OVERRIDE {
+  virtual void TechnologyListChanged() override {
     VLOG(1) << "TechnologyListChanged.";
     ++technology_list_updates_;
   }
 
   virtual void CheckPortalListChanged(
-      const std::string& check_portal_list) OVERRIDE {
+      const std::string& check_portal_list) override {
   }
 
   virtual void ManagedStateListChanged(
-      ManagedState::ManagedType type) OVERRIDE {
+      ManagedState::ManagedType type) override {
     VLOG(1) << "ManagedStateListChanged: " << GetTypeString(type);
     AddStateListUpdate(GetTypeString(type));
   }
 
   virtual void DefaultNetworkServiceChanged(
-      const std::string& service_path) OVERRIDE {
+      const std::string& service_path) override {
   }
 
   std::vector<std::string>& entries(const std::string& type) {
     return entries_[type];
   }
   std::map<std::string, int>& property_updates(const std::string& type) {
     return property_updates_[type];
   }
   std::map<std::string, int>& initial_property_updates(
       const std::string& type) {
@@ skipping 58 matching lines @@
  public:
   ShillPropertyHandlerTest()
       : manager_test_(NULL),
         device_test_(NULL),
         service_test_(NULL),
         profile_test_(NULL) {
   }
   virtual ~ShillPropertyHandlerTest() {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Initialize DBusThreadManager with a stub implementation.
     DBusThreadManager::Initialize();
     // Get the test interface for manager / device / service and clear the
     // default stub properties.
     manager_test_ =
         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
     ASSERT_TRUE(manager_test_);
     device_test_ =
         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     ASSERT_TRUE(device_test_);
     service_test_ =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     ASSERT_TRUE(service_test_);
     profile_test_ =
         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
     ASSERT_TRUE(profile_test_);
     SetupShillPropertyHandler();
     message_loop_.RunUntilIdle();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     shill_property_handler_.reset();
     listener_.reset();
     DBusThreadManager::Shutdown();
   }
 
   void AddDevice(const std::string& type, const std::string& id) {
     ASSERT_TRUE(IsValidType(type));
     device_test_->AddDevice(id, type, id);
   }
 
@@ skipping 294 matching lines @@
   shill_property_handler_->UpdateManagerProperties();
   message_loop_.RunUntilIdle();
   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
   EXPECT_EQ(1, listener_->initial_property_updates(
       shill::kServiceCompleteListProperty)[kTestServicePath2]);
   EXPECT_EQ(1, listener_->property_updates(
       shill::kServiceCompleteListProperty)[kTestServicePath2]);
 }
 
 }  // namespace chromeos