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

chrome/browser/extensions/extension_prefs_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 "chrome/browser/extensions/./extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/mock_pref_change_callback.h"
@@ skipping 56 matching lines @@
   message_loop_.RunUntilIdle();
 }
 
 // Tests the LastPingDay/SetLastPingDay functions.
 class ExtensionPrefsLastPingDay : public ExtensionPrefsTest {
  public:
   ExtensionPrefsLastPingDay()
       : extension_time_(Time::Now() - TimeDelta::FromHours(4)),
         blacklist_time_(Time::Now() - TimeDelta::FromHours(2)) {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_id_ = prefs_.AddExtensionAndReturnId("last_ping_day");
     EXPECT_TRUE(prefs()->LastPingDay(extension_id_).is_null());
     prefs()->SetLastPingDay(extension_id_, extension_time_);
     prefs()->SetBlacklistLastPingDay(blacklist_time_);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     Time result = prefs()->LastPingDay(extension_id_);
     EXPECT_FALSE(result.is_null());
     EXPECT_TRUE(result == extension_time_);
     result = prefs()->BlacklistLastPingDay();
     EXPECT_FALSE(result.is_null());
     EXPECT_TRUE(result == blacklist_time_);
   }
 
  private:
   Time extension_time_;
   Time blacklist_time_;
   std::string extension_id_;
 };
 TEST_F(ExtensionPrefsLastPingDay, LastPingDay) {}
 
 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     list_.push_back(prefs_.AddExtensionAndReturnId("1"));
     list_.push_back(prefs_.AddExtensionAndReturnId("2"));
     list_.push_back(prefs_.AddExtensionAndReturnId("3"));
     ExtensionIdList before_list = prefs()->GetToolbarOrder();
     EXPECT_TRUE(before_list.empty());
     prefs()->SetToolbarOrder(list_);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     ExtensionIdList result = prefs()->GetToolbarOrder();
     ASSERT_EQ(list_, result);
   }
 
  private:
   ExtensionIdList list_;
 };
 TEST_F(ExtensionPrefsToolbarOrder, ToolbarOrder) {}
 
 // Tests the IsExtensionDisabled/SetExtensionState functions.
 class ExtensionPrefsExtensionState : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension = prefs_.AddExtension("test");
     prefs()->SetExtensionState(extension->id(), Extension::DISABLED);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsExtensionState, ExtensionState) {}
 
 class ExtensionPrefsEscalatePermissions : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension = prefs_.AddExtension("test");
     prefs()->SetDidExtensionEscalatePermissions(extension.get(), true);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_TRUE(prefs()->DidExtensionEscalatePermissions(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsEscalatePermissions, EscalatePermissions) {}
 
 // Tests the AddGrantedPermissions / GetGrantedPermissions functions.
 class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     const APIPermissionInfo* permission_info =
       PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
     api_perm_set1_.insert(APIPermission::kTab);
     api_perm_set1_.insert(APIPermission::kBookmark);
     scoped_ptr<APIPermission> permission(
         permission_info->CreateAPIPermission());
     {
@@ skipping 100 matching lines @@
     EXPECT_EQ(ehost_permissions_,
               granted_permissions->explicit_hosts());
     EXPECT_EQ(shost_permissions_,
               granted_permissions->scriptable_hosts());
     effective_permissions_.ClearPatterns();
     URLPatternSet::CreateUnion(ehost_permissions_, shost_permissions_,
                                &effective_permissions_);
     EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     scoped_refptr<PermissionSet> permissions(
         prefs()->GetGrantedPermissions(extension_id_));
     EXPECT_TRUE(permissions.get());
     EXPECT_FALSE(permissions->HasEffectiveFullAccess());
     EXPECT_EQ(api_permissions_, permissions->apis());
     EXPECT_EQ(ehost_permissions_,
               permissions->explicit_hosts());
     EXPECT_EQ(shost_permissions_,
               permissions->scriptable_hosts());
   }
@@ skipping 10 matching lines @@
   APIPermissionSet api_permissions_;
   URLPatternSet ehost_permissions_;
   URLPatternSet shost_permissions_;
   URLPatternSet effective_permissions_;
 };
 TEST_F(ExtensionPrefsGrantedPermissions, GrantedPermissions) {}
 
 // Tests the SetActivePermissions / GetActivePermissions functions.
 class ExtensionPrefsActivePermissions : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
     APIPermissionSet api_perms;
     api_perms.insert(APIPermission::kTab);
     api_perms.insert(APIPermission::kBookmark);
     api_perms.insert(APIPermission::kHistory);
 
     ManifestPermissionSet empty_manifest_permissions;
 
     URLPatternSet ehosts;
@@ skipping 15 matching lines @@
 
     // Set the active permissions.
     prefs()->SetActivePermissions(extension_id_, active_perms_.get());
     active = prefs()->GetActivePermissions(extension_id_);
     EXPECT_EQ(active_perms_->apis(), active->apis());
     EXPECT_EQ(active_perms_->explicit_hosts(), active->explicit_hosts());
     EXPECT_EQ(active_perms_->scriptable_hosts(), active->scriptable_hosts());
     EXPECT_EQ(*active_perms_.get(), *active.get());
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     scoped_refptr<PermissionSet> permissions(
         prefs()->GetActivePermissions(extension_id_));
     EXPECT_EQ(*active_perms_.get(), *permissions.get());
   }
 
  private:
   std::string extension_id_;
   scoped_refptr<PermissionSet> active_perms_;
 };
 TEST_F(ExtensionPrefsActivePermissions, SetAndGetActivePermissions) {}
 
 // Tests the GetVersionString function.
 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension = prefs_.AddExtension("test");
     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
     prefs()->OnExtensionUninstalled(extension->id(),
                                     Manifest::INTERNAL, false);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_EQ("", prefs()->GetVersionString(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsVersionString, VersionString) {}
 
 class ExtensionPrefsAcknowledgment : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     not_installed_id_ = "pghjnghklobnfoidcldiidjjjhkeeaoi";
 
     // Install some extensions.
     for (int i = 0; i < 5; i++) {
       std::string name = "test" + base::IntToString(i);
       extensions_.push_back(prefs_.AddExtension(name));
     }
     EXPECT_EQ(NULL,
               prefs()->GetInstalledExtensionInfo(not_installed_id_).get());
 
@@ skipping 12 matching lines @@
       }
     }
     // For each type of acknowledgment, acknowledge one installed and one
     // not-installed extension id.
     prefs()->AcknowledgeExternalExtension(external_id_);
     prefs()->AcknowledgeBlacklistedExtension(blacklisted_id_);
     prefs()->AcknowledgeExternalExtension(not_installed_id_);
     prefs()->AcknowledgeBlacklistedExtension(not_installed_id_);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     ExtensionList::const_iterator iter;
     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
       std::string id = (*iter)->id();
       if (id == external_id_) {
         EXPECT_TRUE(prefs()->IsExternalExtensionAcknowledged(id));
       } else {
         EXPECT_FALSE(prefs()->IsExternalExtensionAcknowledged(id));
       }
       if (id == blacklisted_id_) {
         EXPECT_TRUE(prefs()->IsBlacklistedExtensionAcknowledged(id));
@@ skipping 51 matching lines @@
 
   bool HasInfoForId(ExtensionPrefs::ExtensionsInfo* info,
                     const std::string& id) {
     for (size_t i = 0; i < info->size(); ++i) {
       if (info->at(i)->extension_id == id)
         return true;
     }
     return false;
   }
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     PathService::Get(chrome::DIR_TEST_DATA, &basedir_);
     now_ = Time::Now();
     id1_ = prefs_.AddExtensionAndReturnId("1");
     id2_ = prefs_.AddExtensionAndReturnId("2");
     id3_ = prefs_.AddExtensionAndReturnId("3");
     id4_ = prefs_.AddExtensionAndReturnId("4");
 
     // Set info for two extensions, then remove it.
     SetIdleInfo(id1_, 1);
     SetIdleInfo(id2_, 2);
@@ skipping 22 matching lines @@
     SetIdleInfo(id2_, 2);
     SetIdleInfo(id3_, 3);
     SetIdleInfo(id4_, 4);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id3_, 3);
     VerifyIdleInfo(id4_, 4);
     prefs()->RemoveDelayedInstallInfo(id3_);
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     // Make sure the info for the 3 extensions we expect is present.
     scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
         prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(3u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
     EXPECT_TRUE(HasInfoForId(info.get(), id4_));
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id4_, 4);
 
     // Make sure there isn't info the for the one extension id we removed.
     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
   }
 
  protected:
   Time now_;
   base::FilePath basedir_;
   std::string id1_;
   std::string id2_;
   std::string id3_;
   std::string id4_;
 };
 TEST_F(ExtensionPrefsDelayedInstallInfo, DelayedInstallInfo) {}
 
 // Tests the FinishDelayedInstallInfo function.
 class ExtensionPrefsFinishDelayedInstallInfo : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     base::DictionaryValue dictionary;
     dictionary.SetString(manifest_keys::kName, "test");
     dictionary.SetString(manifest_keys::kVersion, "0.1");
     dictionary.SetString(manifest_keys::kBackgroundPage, "background.html");
     scoped_refptr<Extension> extension =
         prefs_.AddExtensionWithManifest(dictionary, Manifest::INTERNAL);
     id_ = extension->id();
 
 
     // Set idle info
@@ skipping 14 matching lines @@
                                    Extension::ENABLED,
                                    kInstallFlagNone,
                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    syncer::StringOrdinal(),
                                    "Param");
 
     // Finish idle installation
     ASSERT_TRUE(prefs()->FinishDelayedInstallInfo(id_));
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id_));
     EXPECT_EQ(std::string("Param"), prefs()->GetInstallParam(id_));
 
     const base::DictionaryValue* manifest;
     ASSERT_TRUE(prefs()->ReadPrefAsDictionary(id_, "manifest", &manifest));
     ASSERT_TRUE(manifest);
     std::string value;
     EXPECT_TRUE(manifest->GetString(manifest_keys::kName, &value));
     EXPECT_EQ("test", value);
     EXPECT_TRUE(manifest->GetString(manifest_keys::kVersion, &value));
     EXPECT_EQ("0.2", value);
     EXPECT_FALSE(manifest->GetString(manifest_keys::kBackgroundPage, &value));
     const base::ListValue* scripts;
     ASSERT_TRUE(manifest->GetList(manifest_keys::kBackgroundScripts, &scripts));
     EXPECT_EQ(1u, scripts->GetSize());
   }
 
  protected:
   std::string id_;
 };
 TEST_F(ExtensionPrefsFinishDelayedInstallInfo, FinishDelayedInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::DISABLED,
                                   syncer::StringOrdinal(),
                                   "Param");
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension_->id()));
     EXPECT_EQ(std::string("Param"), prefs()->GetInstallParam(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsOnExtensionInstalled,
        ExtensionPrefsOnExtensionInstalled) {}
 
 class ExtensionPrefsAppDraggedByUser : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->WasAppDraggedByUser(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::ENABLED,
                                   syncer::StringOrdinal(),
                                   std::string());
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     // Set the flag and see if it persisted.
     prefs()->SetAppDraggedByUser(extension_->id());
     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
 
     // Make sure it doesn't change on consecutive calls.
     prefs()->SetAppDraggedByUser(extension_->id());
     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsAppDraggedByUser, ExtensionPrefsAppDraggedByUser) {}
 
 class ExtensionPrefsFlags : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(manifest_keys::kName, "from_webstore");
       dictionary.SetString(manifest_keys::kVersion, "0.1");
       webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::FROM_WEBSTORE);
     }
 
     {
       base::DictionaryValue dictionary;
@@ skipping 15 matching lines @@
 
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(manifest_keys::kName, "was_installed_by_oem");
       dictionary.SetString(manifest_keys::kVersion, "0.1");
       oem_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::WAS_INSTALLED_BY_OEM);
     }
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_TRUE(prefs()->IsFromWebStore(webstore_extension_->id()));
     EXPECT_FALSE(prefs()->IsFromBookmark(webstore_extension_->id()));
 
     EXPECT_TRUE(prefs()->IsFromBookmark(bookmark_extension_->id()));
     EXPECT_FALSE(prefs()->IsFromWebStore(bookmark_extension_->id()));
 
     EXPECT_TRUE(prefs()->WasInstalledByDefault(default_extension_->id()));
     EXPECT_TRUE(prefs()->WasInstalledByOem(oem_extension_->id()));
   }
 
@@ skipping 43 matching lines @@
 }
 
 PrefsPrepopulatedTestBase::~PrefsPrepopulatedTestBase() {
 }
 
 // Tests that blacklist state can be queried.
 class ExtensionPrefsBlacklistedExtensions : public ExtensionPrefsTest {
  public:
   virtual ~ExtensionPrefsBlacklistedExtensions() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_a_ = prefs_.AddExtension("a");
     extension_b_ = prefs_.AddExtension("b");
     extension_c_ = prefs_.AddExtension("c");
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     {
       ExtensionIdSet ids;
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
     {
       ExtensionIdSet ids;
       ids.insert(extension_a_->id());
       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
     }
@@ skipping 53 matching lines @@
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 // Tests the blacklist state. Old "blacklist" preference should take precedence
 // over new "blacklist_state".
 class ExtensionPrefsBlacklistState : public ExtensionPrefsTest {
  public:
   virtual ~ExtensionPrefsBlacklistState() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_a_ = prefs_.AddExtension("a");
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     ExtensionIdSet empty_ids;
     EXPECT_EQ(empty_ids, prefs()->GetBlacklistedExtensions());
 
     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
     EXPECT_EQ(BLACKLISTED_MALWARE,
               prefs()->GetExtensionBlacklistState(extension_a_->id()));
 
     prefs()->SetExtensionBlacklistState(extension_a_->id(),
                                         BLACKLISTED_POTENTIALLY_UNWANTED);
     EXPECT_EQ(BLACKLISTED_POTENTIALLY_UNWANTED,
@@ skipping 14 matching lines @@
     EXPECT_FALSE(prefs()->IsExtensionBlacklisted(extension_a_->id()));
     EXPECT_EQ(empty_ids, prefs()->GetBlacklistedExtensions());
   }
 
  private:
   scoped_refptr<const Extension> extension_a_;
 };
 TEST_F(ExtensionPrefsBlacklistState, ExtensionPrefsBlacklistState) {}
 
 }  // namespace extensions