Update {virtual,override} to follow C++11 style in components.

components/policy/core/common/policy_loader_win_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 "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <userenv.h>
 
 #include <algorithm>
@@ skipping 152 matching lines @@
   RegKey temp_hklm_hive_key_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedGroupPolicyRegistrySandbox);
 };
 
 // A test harness that feeds policy via the Chrome GPO registry subtree.
 class RegistryTestHarness : public PolicyProviderTestHarness,
                             public AppliedGPOListProvider {
  public:
   RegistryTestHarness(HKEY hive, PolicyScope scope);
-  virtual ~RegistryTestHarness();
+  ~RegistryTestHarness() override;
 
   // PolicyProviderTestHarness:
-  virtual void SetUp() override;
+  void SetUp() override;
 
-  virtual ConfigurationPolicyProvider* CreateProvider(
+  ConfigurationPolicyProvider* CreateProvider(
       SchemaRegistry* registry,
       scoped_refptr<base::SequencedTaskRunner> task_runner) override;
 
-  virtual void InstallEmptyPolicy() override;
-  virtual void InstallStringPolicy(const std::string& policy_name,
-                                   const std::string& policy_value) override;
-  virtual void InstallIntegerPolicy(const std::string& policy_name,
-                                    int policy_value) override;
-  virtual void InstallBooleanPolicy(const std::string& policy_name,
-                                    bool policy_value) override;
-  virtual void InstallStringListPolicy(
-      const std::string& policy_name,
-      const base::ListValue* policy_value) override;
-  virtual void InstallDictionaryPolicy(
+  void InstallEmptyPolicy() override;
+  void InstallStringPolicy(const std::string& policy_name,
+                           const std::string& policy_value) override;
+  void InstallIntegerPolicy(const std::string& policy_name,
+                            int policy_value) override;
+  void InstallBooleanPolicy(const std::string& policy_name,
+                            bool policy_value) override;
+  void InstallStringListPolicy(const std::string& policy_name,
+                               const base::ListValue* policy_value) override;
+  void InstallDictionaryPolicy(
       const std::string& policy_name,
       const base::DictionaryValue* policy_value) override;
-  virtual void Install3rdPartyPolicy(
-      const base::DictionaryValue* policies) override;
+  void Install3rdPartyPolicy(const base::DictionaryValue* policies) override;
 
   // AppliedGPOListProvider:
-  virtual DWORD GetAppliedGPOList(DWORD flags,
-                                  LPCTSTR machine_name,
-                                  PSID sid_user,
-                                  GUID* extension_guid,
-                                  PGROUP_POLICY_OBJECT* gpo_list) override;
-  virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override;
+  DWORD GetAppliedGPOList(DWORD flags,
+                          LPCTSTR machine_name,
+                          PSID sid_user,
+                          GUID* extension_guid,
+                          PGROUP_POLICY_OBJECT* gpo_list) override;
+  BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override;
 
   // Creates a harness instance that will install policy in HKCU or HKLM,
   // respectively.
   static PolicyProviderTestHarness* CreateHKCU();
   static PolicyProviderTestHarness* CreateHKLM();
 
  private:
   HKEY hive_;
 
   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
 
   DISALLOW_COPY_AND_ASSIGN(RegistryTestHarness);
 };
 
 // A test harness that generates PReg files for the provider to read.
 class PRegTestHarness : public PolicyProviderTestHarness,
                         public AppliedGPOListProvider {
  public:
   PRegTestHarness();
-  virtual ~PRegTestHarness();
+  ~PRegTestHarness() override;
 
   // PolicyProviderTestHarness:
-  virtual void SetUp() override;
+  void SetUp() override;
 
-  virtual ConfigurationPolicyProvider* CreateProvider(
+  ConfigurationPolicyProvider* CreateProvider(
       SchemaRegistry* registry,
       scoped_refptr<base::SequencedTaskRunner> task_runner) override;
 
-  virtual void InstallEmptyPolicy() override;
-  virtual void InstallStringPolicy(const std::string& policy_name,
-                                   const std::string& policy_value) override;
-  virtual void InstallIntegerPolicy(const std::string& policy_name,
-                                    int policy_value) override;
-  virtual void InstallBooleanPolicy(const std::string& policy_name,
-                                    bool policy_value) override;
-  virtual void InstallStringListPolicy(
-      const std::string& policy_name,
-      const base::ListValue* policy_value) override;
-  virtual void InstallDictionaryPolicy(
+  void InstallEmptyPolicy() override;
+  void InstallStringPolicy(const std::string& policy_name,
+                           const std::string& policy_value) override;
+  void InstallIntegerPolicy(const std::string& policy_name,
+                            int policy_value) override;
+  void InstallBooleanPolicy(const std::string& policy_name,
+                            bool policy_value) override;
+  void InstallStringListPolicy(const std::string& policy_name,
+                               const base::ListValue* policy_value) override;
+  void InstallDictionaryPolicy(
       const std::string& policy_name,
       const base::DictionaryValue* policy_value) override;
-  virtual void Install3rdPartyPolicy(
-      const base::DictionaryValue* policies) override;
+  void Install3rdPartyPolicy(const base::DictionaryValue* policies) override;
 
   // AppliedGPOListProvider:
-  virtual DWORD GetAppliedGPOList(DWORD flags,
-                                  LPCTSTR machine_name,
-                                  PSID sid_user,
-                                  GUID* extension_guid,
-                                  PGROUP_POLICY_OBJECT* gpo_list) override;
-  virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override;
+  DWORD GetAppliedGPOList(DWORD flags,
+                          LPCTSTR machine_name,
+                          PSID sid_user,
+                          GUID* extension_guid,
+                          PGROUP_POLICY_OBJECT* gpo_list) override;
+  BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override;
 
   // Creates a harness instance.
   static PolicyProviderTestHarness* Create();
 
  private:
   // Helper to append a base::string16 to an uint8 buffer.
   static void AppendChars(std::vector<uint8>* buffer,
                           const base::string16& chars);
 
   // Appends a record with the given fields to the PReg file.
@@ skipping 427 matching lines @@
 class PolicyLoaderWinTest : public PolicyTestBase,
                             public AppliedGPOListProvider {
  protected:
   // The policy key this tests places data under. This must match the data
   // files in chrome/test/data/policy/gpo.
   static const base::char16 kTestPolicyKey[];
 
   PolicyLoaderWinTest()
       : gpo_list_(NULL),
         gpo_list_status_(ERROR_ACCESS_DENIED) {}
-  virtual ~PolicyLoaderWinTest() {}
+  ~PolicyLoaderWinTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     base::win::SetDomainStateForTesting(false);
     PolicyTestBase::SetUp();
 
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
     test_data_dir_ = test_data_dir_.AppendASCII("chrome")
                                    .AppendASCII("test")
                                    .AppendASCII("data")
                                    .AppendASCII("policy")
                                    .AppendASCII("gpo");
 
     gpo_list_provider_ = this;
   }
 
   // AppliedGPOListProvider:
-  virtual DWORD GetAppliedGPOList(DWORD flags,
-                                  LPCTSTR machine_name,
-                                  PSID sid_user,
-                                  GUID* extension_guid,
-                                  PGROUP_POLICY_OBJECT* gpo_list) override {
+  DWORD GetAppliedGPOList(DWORD flags,
+                          LPCTSTR machine_name,
+                          PSID sid_user,
+                          GUID* extension_guid,
+                          PGROUP_POLICY_OBJECT* gpo_list) override {
     *gpo_list = gpo_list_;
     return gpo_list_status_;
   }
-  virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override {
+  BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) override {
     return TRUE;
   }
 
   void InitGPO(GROUP_POLICY_OBJECT* gpo,
                DWORD options,
                const base::FilePath& path,
                GROUP_POLICY_OBJECT* next,
                GROUP_POLICY_OBJECT* prev) {
     memset(gpo, 0, sizeof(GROUP_POLICY_OBJECT));
     gpo->dwOptions = options;
@@ skipping 484 matching lines @@
   PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("alternative_browser_path",
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       list.DeepCopy(), NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy