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

chrome/browser/extensions/api/preference/preference_api_prefs_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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/mock_pref_change_callback.h"
 #include "base/values.h"
@@ skipping 31 matching lines @@
 class TestPreferenceAPI : public PreferenceAPIBase {
  public:
   explicit TestPreferenceAPI(TestExtensionPrefs* test_extension_prefs,
                              ContentSettingsService* content_settings)
       : test_extension_prefs_(test_extension_prefs),
         content_settings_(content_settings) {}
   ~TestPreferenceAPI() {}
 
  private:
   // PreferenceAPIBase implementation.
-  virtual ExtensionPrefs* extension_prefs() OVERRIDE {
+  virtual ExtensionPrefs* extension_prefs() override {
     return test_extension_prefs_->prefs();
   }
-  virtual ExtensionPrefValueMap* extension_pref_value_map() OVERRIDE {
+  virtual ExtensionPrefValueMap* extension_pref_value_map() override {
     return test_extension_prefs_->extension_pref_value_map();
   }
   virtual scoped_refptr<ContentSettingsStore> content_settings_store()
-      OVERRIDE {
+      override {
     return content_settings_->content_settings_store();
   }
 
   TestExtensionPrefs* test_extension_prefs_;
   ContentSettingsService* content_settings_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPreferenceAPI);
 };
 
 class ExtensionControlledPrefsTest : public PrefsPrepopulatedTestBase {
  public:
   ExtensionControlledPrefsTest();
   virtual ~ExtensionControlledPrefsTest();
 
   virtual void RegisterPreferences(user_prefs::PrefRegistrySyncable* registry)
-      OVERRIDE;
+      override;
   void InstallExtensionControlledPref(Extension* extension,
                                       const std::string& key,
                                       base::Value* value);
   void InstallExtensionControlledPrefIncognito(Extension* extension,
                                                const std::string& key,
                                                base::Value* value);
   void InstallExtensionControlledPrefIncognitoSessionOnly(
       Extension* extension,
       const std::string& key,
       base::Value* value);
@@ skipping 101 matching lines @@
     if (extensions[i]->id() == extension_id) {
       installed_[i] = false;
       break;
     }
   }
   prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false);
 }
 
 class ControlledPrefsInstallOneExtension
     : public ExtensionControlledPrefsTest {
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(extension1(),
                                    kPref1,
                                    new base::StringValue("val1"));
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
   }
 };
 TEST_F(ControlledPrefsInstallOneExtension,
        ControlledPrefsInstallOneExtension) { }
 
 // Check that we do not forget persistent incognito values after a reload.
 class ControlledPrefsInstallIncognitoPersistent
     : public ExtensionControlledPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     InstallExtensionControlledPrefIncognito(
         extension1(), kPref1, new base::StringValue("val2"));
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     std::string actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     // Main pref service shall see only non-incognito settings.
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
     // Incognito pref service shall see incognito values.
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
 };
 TEST_F(ControlledPrefsInstallIncognitoPersistent,
        ControlledPrefsInstallIncognitoPersistent) { }
 
 // Check that we forget 'session only' incognito values after a reload.
 class ControlledPrefsInstallIncognitoSessionOnly
     : public ExtensionControlledPrefsTest {
  public:
   ControlledPrefsInstallIncognitoSessionOnly() : iteration_(0) {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     InstallExtensionControlledPrefIncognitoSessionOnly(
         extension1(), kPref1, new base::StringValue("val2"));
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     std::string actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     // Main pref service shall see only non-incognito settings.
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
     // Incognito pref service shall see session-only incognito values only
     // during first run. Once the pref service was reloaded, all values shall be
     // discarded.
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     actual = incog_prefs->GetString(kPref1);
     if (iteration_ == 0) {
       EXPECT_EQ("val2", actual);
     } else {
       EXPECT_EQ("val1", actual);
     }
     ++iteration_;
   }
   int iteration_;
 };
 TEST_F(ControlledPrefsInstallIncognitoSessionOnly,
        ControlledPrefsInstallIncognitoSessionOnly) { }
 
 class ControlledPrefsUninstallExtension : public ExtensionControlledPrefsTest {
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     InstallExtensionControlledPref(
         extension1(), kPref2, new base::StringValue("val2"));
     scoped_refptr<ContentSettingsStore> store = content_settings_store();
     ContentSettingsPattern pattern =
         ContentSettingsPattern::FromString("http://[*.]example.com");
     store->SetExtensionContentSetting(extension1()->id(),
                                       pattern, pattern,
                                       CONTENT_SETTINGS_TYPE_IMAGES,
                                       std::string(),
                                       CONTENT_SETTING_BLOCK,
                                       kExtensionPrefsScopeRegular);
 
     UninstallExtension(extension1()->id());
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_FALSE(prefs()->HasPrefForExtension(extension1()->id()));
 
     std::string actual;
     actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ(kDefaultPref1, actual);
     actual = prefs()->pref_service()->GetString(kPref2);
     EXPECT_EQ(kDefaultPref2, actual);
   }
 };
 TEST_F(ControlledPrefsUninstallExtension,
        ControlledPrefsUninstallExtension) { }
 
 // Tests triggering of notifications to registered observers.
 class ControlledPrefsNotifyWhenNeeded : public ExtensionControlledPrefsTest {
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     using testing::_;
     using testing::Mock;
     using testing::StrEq;
 
     MockPrefChangeCallback observer(prefs()->pref_service());
     PrefChangeRegistrar registrar;
     registrar.Init(prefs()->pref_service());
     registrar.Add(kPref1, observer.GetCallback());
 
     MockPrefChangeCallback incognito_observer(prefs()->pref_service());
@@ skipping 44 matching lines @@
     // Uninstall.
     EXPECT_CALL(observer, OnPreferenceChanged(_));
     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
     UninstallExtension(extension1()->id());
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     registrar.Remove(kPref1);
     incognito_registrar.Remove(kPref1);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ(kDefaultPref1, actual);
   }
 };
 TEST_F(ControlledPrefsNotifyWhenNeeded,
        ControlledPrefsNotifyWhenNeeded) { }
 
 // Tests disabling an extension.
 class ControlledPrefsDisableExtension : public ExtensionControlledPrefsTest {
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
     prefs()->SetExtensionState(extension1()->id(), Extension::DISABLED);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ(kDefaultPref1, actual);
   }
 };
 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsDisableExtension) { }
 
 // Tests disabling and reenabling an extension.
 class ControlledPrefsReenableExtension : public ExtensionControlledPrefsTest {
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     prefs()->SetExtensionState(extension1()->id(), Extension::DISABLED);
     prefs()->SetExtensionState(extension1()->id(), Extension::ENABLED);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
   }
 };
 TEST_F(ControlledPrefsDisableExtension, ControlledPrefsReenableExtension) { }
 
 // Mock class to test whether objects are deleted correctly.
 class MockStringValue : public base::StringValue {
  public:
   explicit MockStringValue(const std::string& in_value)
       : base::StringValue(in_value) {
   }
   virtual ~MockStringValue() {
     Die();
   }
   MOCK_METHOD0(Die, void());
 };
 
 class ControlledPrefsSetExtensionControlledPref
     : public ExtensionControlledPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     MockStringValue* v1 = new MockStringValue("https://www.chromium.org");
     MockStringValue* v2 = new MockStringValue("https://www.chromium.org");
     MockStringValue* v1i = new MockStringValue("https://www.chromium.org");
     MockStringValue* v2i = new MockStringValue("https://www.chromium.org");
     // Ownership is taken, value shall not be deleted.
     EXPECT_CALL(*v1, Die()).Times(0);
     EXPECT_CALL(*v1i, Die()).Times(0);
     InstallExtensionControlledPref(extension1(), kPref1, v1);
     InstallExtensionControlledPrefIncognito(extension1(), kPref1, v1i);
     testing::Mock::VerifyAndClearExpectations(v1);
     testing::Mock::VerifyAndClearExpectations(v1i);
     // Make sure there is no memory leak and both values are deleted.
     EXPECT_CALL(*v1, Die()).Times(1);
     EXPECT_CALL(*v1i, Die()).Times(1);
     EXPECT_CALL(*v2, Die()).Times(1);
     EXPECT_CALL(*v2i, Die()).Times(1);
     InstallExtensionControlledPref(extension1(), kPref1, v2);
     InstallExtensionControlledPrefIncognito(extension1(), kPref1, v2i);
     prefs_.RecreateExtensionPrefs();
     testing::Mock::VerifyAndClearExpectations(v1);
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
   }
 };
 TEST_F(ControlledPrefsSetExtensionControlledPref,
        ControlledPrefsSetExtensionControlledPref) { }
 
 // Tests that the switches::kDisableExtensions command-line flag prevents
 // extension controlled preferences from being enacted.
 class ControlledPrefsDisableExtensions : public ExtensionControlledPrefsTest {
  public:
   ControlledPrefsDisableExtensions()
       : iteration_(0) {}
   virtual ~ControlledPrefsDisableExtensions() {}
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     // This becomes only active in the second verification phase.
     prefs_.set_extensions_disabled(true);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     if (iteration_ == 0) {
       EXPECT_EQ("val1", actual);
       ++iteration_;
     } else {
       EXPECT_EQ(kDefaultPref1, actual);
     }
   }
 
  private:
   int iteration_;
 };
 TEST_F(ControlledPrefsDisableExtensions, ControlledPrefsDisableExtensions) { }
 
 }  // namespace extensions