replace OVERRIDE and FINAL with override and final in chrome/browser/chromeos/

chrome/browser/chromeos/policy/network_configuration_updater_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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 42 matching lines @@
 
 class FakeUser : public user_manager::User {
  public:
   FakeUser() : User(kFakeUserEmail) {
     set_display_email(kFakeUserEmail);
     set_username_hash(kFakeUsernameHash);
   }
   virtual ~FakeUser() {}
 
   // User overrides
-  virtual user_manager::UserType GetType() const OVERRIDE {
+  virtual user_manager::UserType GetType() const override {
     return user_manager::USER_TYPE_REGULAR;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeUser);
 };
 
 class FakeWebTrustedCertsObserver
     : public UserNetworkConfigurationUpdater::WebTrustedCertsObserver {
  public:
   FakeWebTrustedCertsObserver() {}
 
   virtual void OnTrustAnchorsChanged(
-      const net::CertificateList& trust_anchors) OVERRIDE {
+      const net::CertificateList& trust_anchors) override {
     trust_anchors_ = trust_anchors;
   }
   net::CertificateList trust_anchors_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeWebTrustedCertsObserver);
 };
 
 class FakeNetworkDeviceHandler : public chromeos::FakeNetworkDeviceHandler {
   public:
    FakeNetworkDeviceHandler() : allow_roaming_(false) {}
 
-   virtual void SetCellularAllowRoaming(bool allow_roaming) OVERRIDE {
+   virtual void SetCellularAllowRoaming(bool allow_roaming) override {
      allow_roaming_ = allow_roaming;
    }
 
    bool allow_roaming_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeNetworkDeviceHandler);
 };
 
 class FakeCertificateImporter : public chromeos::onc::CertificateImporter {
@@ skipping 16 matching lines @@
   }
 
   unsigned int GetAndResetImportCount() {
     unsigned int count = call_count_;
     call_count_ = 0;
     return count;
   }
 
   virtual void ImportCertificates(const base::ListValue& certificates,
                                   ::onc::ONCSource source,
-                                  const DoneCallback& done_callback) OVERRIDE {
+                                  const DoneCallback& done_callback) override {
     if (expected_onc_source_ != ::onc::ONC_SOURCE_UNKNOWN)
       EXPECT_EQ(expected_onc_source_, source);
     if (expected_onc_certificates_) {
       EXPECT_TRUE(chromeos::onc::test_utils::Equals(
           expected_onc_certificates_.get(), &certificates));
     }
     ++call_count_;
     done_callback.Run(true, onc_trusted_certificates_);
   }
 
@@ skipping 57 matching lines @@
     *arg2 = list;
   return true;
 }
 
 }  // namespace
 
 class NetworkConfigurationUpdaterTest : public testing::Test {
  protected:
   NetworkConfigurationUpdaterTest() : certificate_importer_(NULL) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(false));
     provider_.Init();
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
 
     scoped_ptr<base::DictionaryValue> fake_toplevel_onc =
         chromeos::onc::ReadDictionaryFromJson(kFakeONC);
 
     base::ListValue* network_configs = NULL;
     fake_toplevel_onc->GetListWithoutPathExpansion(
         onc::toplevel_config::kNetworkConfigurations, &network_configs);
     AppendAll(*network_configs, &fake_network_configs_);
 
     base::DictionaryValue* global_config = NULL;
     fake_toplevel_onc->GetDictionaryWithoutPathExpansion(
         onc::toplevel_config::kGlobalNetworkConfiguration, &global_config);
     fake_global_network_config_.MergeDictionary(global_config);
 
     base::ListValue* certs = NULL;
     fake_toplevel_onc->GetListWithoutPathExpansion(
         onc::toplevel_config::kCertificates, &certs);
     AppendAll(*certs, &fake_certificates_);
 
     certificate_importer_ = new FakeCertificateImporter;
     certificate_importer_owned_.reset(certificate_importer_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     network_configuration_updater_.reset();
     provider_.Shutdown();
     base::RunLoop().RunUntilIdle();
   }
 
   void MarkPolicyProviderInitialized() {
     Mock::VerifyAndClearExpectations(&provider_);
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     provider_.SetAutoRefresh();
@@ skipping 427 matching lines @@
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 }
 
 INSTANTIATE_TEST_CASE_P(NetworkConfigurationUpdaterTestWithParamInstance,
                         NetworkConfigurationUpdaterTestWithParam,
                         testing::Values(key::kDeviceOpenNetworkConfiguration,
                                         key::kOpenNetworkConfiguration));
 
 }  // namespace policy