Linux/ChromeOS Chromium style checker cleanup, chrome/browser/extensions edition.

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 "extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/public/pref_change_registrar.h"
@@ skipping 66 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() {
+  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() {
+  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_;
@@ skipping 10 matching lines @@
   permission.pref_id = gallery;
   permission.has_permission = has_access;
   vector->push_back(permission);
 }
 
 }  // namspace
 
 // Test the MediaGalleries permissions functions.
 class MediaGalleriesPermissions : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     extension1_id_ = prefs_.AddExtensionAndReturnId("test1");
     extension2_id_ = prefs_.AddExtensionAndReturnId("test2");
     extension3_id_ = prefs_.AddExtensionAndReturnId("test3");
     // Id4 isn't used to ensure that an empty permission list is ok.
     extension4_id_ = prefs_.AddExtensionAndReturnId("test4");
     Verify();
 
     prefs()->SetMediaGalleryPermission(extension1_id_, 1, false);
     AddGalleryPermission(1, false, &extension1_expectation_);
     Verify();
@@ skipping 21 matching lines @@
     prefs()->RemoveMediaGalleryPermissions(3);
     extension2_expectation_.erase(extension2_expectation_.begin() + 1);
     extension3_expectation_.erase(extension3_expectation_.begin());
     Verify();
 
     prefs()->UnsetMediaGalleryPermission(extension1_id_, 1);
     extension1_expectation_.erase(extension1_expectation_.begin());
     Verify();
   }
 
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     struct TestData {
       std::string* id;
       std::vector<chrome::MediaGalleryPermission>* expectation;
     };
 
     const TestData test_data[] = {{&extension1_id_, &extension1_expectation_},
                                   {&extension2_id_, &extension2_expectation_},
                                   {&extension3_id_, &extension3_expectation_},
                                   {&extension4_id_, &extension4_expectation_}};
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); i++) {
@@ skipping 21 matching lines @@
   std::vector<chrome::MediaGalleryPermission> extension1_expectation_;
   std::vector<chrome::MediaGalleryPermission> extension2_expectation_;
   std::vector<chrome::MediaGalleryPermission> extension3_expectation_;
   std::vector<chrome::MediaGalleryPermission> extension4_expectation_;
 };
 TEST_F(MediaGalleriesPermissions, MediaGalleries) {}
 
 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     list_.push_back(prefs_.AddExtensionAndReturnId("1"));
     list_.push_back(prefs_.AddExtensionAndReturnId("2"));
     list_.push_back(prefs_.AddExtensionAndReturnId("3"));
     std::vector<std::string> before_list = prefs()->GetToolbarOrder();
     EXPECT_TRUE(before_list.empty());
     prefs()->SetToolbarOrder(list_);
   }
 
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     std::vector<std::string> result = prefs()->GetToolbarOrder();
     ASSERT_EQ(list_.size(), result.size());
     for (size_t i = 0; i < list_.size(); i++) {
       EXPECT_EQ(list_[i], result[i]);
     }
   }
 
  private:
   std::vector<std::string> list_;
 };
 TEST_F(ExtensionPrefsToolbarOrder, ToolbarOrder) {}
 
 
 // Tests the IsExtensionDisabled/SetExtensionState functions.
 class ExtensionPrefsExtensionState : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     extension = prefs_.AddExtension("test");
     prefs()->SetExtensionState(extension->id(), Extension::DISABLED);
   }
 
-  virtual void Verify() {
+  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() {
+  virtual void Initialize() OVERRIDE {
     extension = prefs_.AddExtension("test");
     prefs()->SetDidExtensionEscalatePermissions(extension.get(), true);
   }
 
-  virtual void Verify() {
+  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() {
+  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 99 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() {
+  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() {
+  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);
 
     URLPatternSet ehosts;
     AddPattern(&ehosts, "http://*.google.com/*");
     AddPattern(&ehosts, "http://example.com/*");
@@ skipping 12 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_, *active);
   }
 
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     scoped_refptr<PermissionSet> permissions(
         prefs()->GetActivePermissions(extension_id_));
     EXPECT_EQ(*active_perms_, *permissions);
   }
 
  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() {
+  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() {
+  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() {
+  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() {
+  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 10 matching lines @@
 
   std::string not_installed_id_;
   std::string external_id_;
   std::string blacklisted_id_;
 };
 TEST_F(ExtensionPrefsAcknowledgment, Acknowledgment) {}
 
 // Tests force hiding browser actions.
 class ExtensionPrefsHidingBrowserActions : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     // Install 5 extensions.
     for (int i = 0; i < 5; i++) {
       std::string name = "test" + base::IntToString(i);
       extensions_.push_back(prefs_.AddExtension(name));
     }
 
     ExtensionList::const_iterator iter;
     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter)
       EXPECT_TRUE(prefs()->GetBrowserActionVisibility(*iter));
 
     prefs()->SetBrowserActionVisibility(extensions_[0], false);
     prefs()->SetBrowserActionVisibility(extensions_[1], true);
   }
 
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     // Make sure the one we hid is hidden.
     EXPECT_FALSE(prefs()->GetBrowserActionVisibility(extensions_[0]));
 
     // Make sure the other id's are not hidden.
     ExtensionList::const_iterator iter = extensions_.begin() + 1;
     for (; iter != extensions_.end(); ++iter) {
       SCOPED_TRACE(base::StringPrintf("Loop %d ",
                        static_cast<int>(iter - extensions_.begin())));
       EXPECT_TRUE(prefs()->GetBrowserActionVisibility(*iter));
     }
@@ skipping 37 matching lines @@
 
   bool HasInfoForId(extensions::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() {
+  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() {
+  virtual void Verify() OVERRIDE {
     // Make sure the info for the 3 extensions we expect is present.
     scoped_ptr<extensions::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_;
   FilePath basedir_;
   std::string id1_;
   std::string id2_;
   std::string id3_;
   std::string id4_;
 };
 TEST_F(ExtensionPrefsDelayedInstallInfo, DelayedInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(
         extension_.get(), Extension::DISABLED,
         syncer::StringOrdinal());
   }
 
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsOnExtensionInstalled,
        ExtensionPrefsOnExtensionInstalled) {}
 
 class ExtensionPrefsAppDraggedByUser : public ExtensionPrefsTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->WasAppDraggedByUser(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(), Extension::ENABLED,
                                   syncer::StringOrdinal());
   }
 
-  virtual void Verify() {
+  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() {
+  virtual void Initialize() OVERRIDE {
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName, "from_webstore");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
       webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::FROM_WEBSTORE);
     }
 
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName, "from_bookmark");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
       bookmark_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::FROM_BOOKMARK);
     }
 
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName,
                            "was_installed_by_default");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
       default_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary,
           Manifest::INTERNAL,
           Extension::WAS_INSTALLED_BY_DEFAULT);
     }
   }
 
-  virtual void Verify() {
+  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()));
   }
 
  private:
@@ skipping 109 matching lines @@
     if (extensions[i]->id() == extension_id) {
       installed[i] = false;
       break;
     }
   }
   prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false);
 }
 
 class ExtensionPrefsInstallOneExtension
     : public ExtensionPrefsPrepopulatedTest {
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
   }
 };
 TEST_F(ExtensionPrefsInstallOneExtension, ExtensionPrefsInstallOneExtension) {}
 
 // Check that we do not forget persistent incognito values after a reload.
 class ExtensionPrefsInstallIncognitoPersistent
     : public ExtensionPrefsPrepopulatedTest {
  public:
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     InstallExtControlledPrefIncognito(ext1_, kPref1,
                                       Value::CreateStringValue("val2"));
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     std::string actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
-  virtual void Verify() {
+  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(ExtensionPrefsInstallIncognitoPersistent,
        ExtensionPrefsInstallOneExtension) {}
 
 // Check that we forget 'session only' incognito values after a reload.
 class ExtensionPrefsInstallIncognitoSessionOnly
     : public ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionPrefsInstallIncognitoSessionOnly() : iteration_(0) {}
 
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     InstallExtControlledPrefIncognitoSessionOnly(
         ext1_, kPref1, Value::CreateStringValue("val2"));
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     std::string actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
-  virtual void Verify() {
+  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(ExtensionPrefsInstallIncognitoSessionOnly,
        ExtensionPrefsInstallOneExtension) {}
 
 class ExtensionPrefsUninstallExtension : public ExtensionPrefsPrepopulatedTest {
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     InstallExtControlledPref(ext1_, kPref2, Value::CreateStringValue("val2"));
     ContentSettingsStore* store = prefs()->content_settings_store();
     ContentSettingsPattern pattern =
         ContentSettingsPattern::FromString("http://[*.]example.com");
     store->SetExtensionContentSetting(ext1_->id(),
                                       pattern, pattern,
                                       CONTENT_SETTINGS_TYPE_IMAGES,
                                       std::string(),
                                       CONTENT_SETTING_BLOCK,
                                       kExtensionPrefsScopeRegular);
 
     UninstallExtension(ext1_->id());
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     EXPECT_EQ(NULL, prefs()->GetExtensionPref(ext1_->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(ExtensionPrefsUninstallExtension,
        ExtensionPrefsUninstallExtension) {}
 
 // Tests triggering of notifications to registered observers.
 class ExtensionPrefsNotifyWhenNeeded : public ExtensionPrefsPrepopulatedTest {
-  virtual void Initialize() {
+  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 45 matching lines @@
     // Uninstall.
     EXPECT_CALL(observer, OnPreferenceChanged(_));
     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
     UninstallExtension(ext1_->id());
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     registrar.Remove(kPref1);
     incognito_registrar.Remove(kPref1);
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ(kDefaultPref1, actual);
   }
 };
 TEST_F(ExtensionPrefsNotifyWhenNeeded,
     ExtensionPrefsNotifyWhenNeeded) {}
 
 // Tests disabling an extension.
 class ExtensionPrefsDisableExt : public ExtensionPrefsPrepopulatedTest {
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
     prefs()->SetExtensionState(ext1_->id(), Extension::DISABLED);
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ(kDefaultPref1, actual);
   }
 };
 TEST_F(ExtensionPrefsDisableExt,  ExtensionPrefsDisableExt) {}
 
 // Tests disabling and reenabling an extension.
 class ExtensionPrefsReenableExt : public ExtensionPrefsPrepopulatedTest {
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     prefs()->SetExtensionState(ext1_->id(), Extension::DISABLED);
     prefs()->SetExtensionState(ext1_->id(), Extension::ENABLED);
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
   }
 };
 TEST_F(ExtensionPrefsDisableExt,  ExtensionPrefsReenableExt) {}
 
 // Mock class to test whether objects are deleted correctly.
 class MockStringValue : public StringValue {
  public:
   explicit MockStringValue(const std::string& in_value)
       : StringValue(in_value) {
   }
   virtual ~MockStringValue() {
     Die();
   }
   MOCK_METHOD0(Die, void());
 };
 
 class ExtensionPrefsSetExtensionControlledPref
     : public ExtensionPrefsPrepopulatedTest {
  public:
-  virtual void Initialize() {
+  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);
     InstallExtControlledPref(ext1_, kPref1, v1);
     InstallExtControlledPrefIncognito(ext1_, 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);
     InstallExtControlledPref(ext1_, kPref1, v2);
     InstallExtControlledPrefIncognito(ext1_, kPref1, v2i);
     prefs_.RecreateExtensionPrefs();
     testing::Mock::VerifyAndClearExpectations(v1);
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}
 
 // Tests that the switches::kDisableExtensions command-line flag prevents
 // extension controlled preferences from being enacted.
 class ExtensionPrefsDisableExtensions : public ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionPrefsDisableExtensions()
       : iteration_(0) {}
   virtual ~ExtensionPrefsDisableExtensions() {}
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     // This becomes only active in the second verification phase.
     prefs_.set_extensions_disabled(true);
   }
-  virtual void Verify() {
+  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:
@@ skipping 74 matching lines @@
 
  private:
   scoped_refptr<const Extension> extension_a_;
   scoped_refptr<const Extension> extension_b_;
   scoped_refptr<const Extension> extension_c_;
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 }  // namespace extensions